{"messages": [{"role": "user", "content": "There are 100 doors in a row that are all initially closed.\n\nYou make 100 passes by the doors.\n\nThe first time through, visit every door and *toggle* the door (if the door is closed, open it; if it is open, close it).\n\nThe second time, only visit every 2nd door (door #2, #4, #6, ...), and toggle it.\n\nThe third time, visit every 3rd door (door #3, #6, #9, ...), etc, until you only visit the 100th door.\n\nTask\n\nAnswer the question: what state are the doors in after the last pass? Which are open, which are closed?\n\n**Alternate:**\nAs noted in this page's discussion page, the only doors that remain open are those whose numbers are perfect squares.\n\nOpening only those doors is an optimization that may also be expressed;\nhowever, as should be obvious, this defeats the intent of comparing implementations across programming languages.\n\nWhy doesn't syntax highlighting work on this page ?\n\nCurrently, there is a limit on how many <syntaxhighlight> tags can appear on a page, so only the first few languages get highlighting, the rest are shown in monochrome.  \nYou could try \"manual highlighting\", possibly using one of the highlighters on Syntax highlighting using Mediawiki formatting or something similar."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### unoptimized\n\n**Works with**: Rakudo version 2015.09\"\n\n```\nmy @doors = False xx 101;\n \n(.=not for @doors[0, $_ ... 100]) for 1..100;\n \nsay \"Door $_ is \", <closed open>[ @doors[$_] ] for 1..100;\n```\n\n### optimized\n\n```\nsay \"Door $_ is open\" for map {$^n ** 2}, 1..10;\n```\n\n### probably the most compact idiom\n\n```\nsay 'Door $_ is open' for (1..10)»²;\n```\n\n### Here's a version using the cross meta-operator instead of a map:\n\n```\n say \"Door $_ is open\" for 1..10 X** 2;\n```\n\nThis one prints both opened and closed doors:\n\n```\nsay \"Door $_ is \", <closed open>[.sqrt == .sqrt.floor] for 1..100;\n```\n\n### verbose version, but uses ordinary components\n\n**Works with**: Rakudo version 2016.07 Tom Legrady\n\n```\nsub  output( @arr, $max ) {\n    my $output = 1;\n    for 1..^$max -> $index {\n\tif @arr[$index] {\n\t    printf \"%4d\", $index;\n\t    say '' if $output++ %%  10;\n\t}\n    }\n    say '';\n}\n\nsub MAIN ( Int :$doors = 100 ) {\n    my $doorcount = $doors + 1;\n    my @door[$doorcount] = 0 xx ($doorcount);\n    \n    INDEX:\n    for 1...^$doorcount -> $index {\n        # flip door $index & its multiples, up to last door.\n        #\n\tfor ($index, * + $index ... *)[^$doors] -> $multiple {\n\t    next INDEX if $multiple > $doors;\n\t    @door[$multiple] =  @door[$multiple] ?? 0 !! 1;\n\t}\n    }\n    output @door, $doors+1;\n}\n```\n\nOutput:\n\n```\n$ ./100_doors.pl6 -doors=100\n   1   4   9  16  25  36  49  64  81\n\n```"}]}
{"messages": [{"role": "user", "content": "The Problem\n\n* 100 prisoners are individually numbered 1 to 100\n* A room having a cupboard of 100 opaque drawers numbered 1 to 100, that cannot be seen from outside.\n* Cards numbered 1 to 100 are placed randomly, one to a drawer, and the drawers all closed; at the start.\n* Prisoners start outside the room\n\n:   * They can decide some strategy before any enter the room.\n    * Prisoners enter the room one by one, can open a drawer, inspect the card number in the drawer, then close the drawer.\n    * A prisoner can open no more than 50 drawers.\n    * A prisoner tries to find his own number.\n    * A prisoner finding his own number is then held apart from the others.\n\n* If **all** 100 prisoners find their own numbers then they will all be pardoned. If *any* don't then *all* sentences stand.\n\nThe task\n\n1. Simulate several thousand instances of the game where the prisoners randomly open drawers\n2. Simulate several thousand instances of the game where the prisoners use the optimal strategy mentioned in the Wikipedia article, of:\n\n:   * First opening the drawer whose outside number is his prisoner number.\n    * If the card within has his number then he succeeds otherwise he opens the drawer with the same number as that of the revealed card. (until he opens his maximum).\n\nShow and compare the computed probabilities of success for the two strategies, here, on this page.\n\nReferences\n\n1. The unbelievable solution to the 100 prisoner puzzle standupmaths (Video).\n2. wp:100 prisoners problem\n3. 100 Prisoners Escape Puzzle DataGenetics.\n4. Random permutation statistics#One hundred prisoners on Wikipedia."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nAccepts command line parameters to modify the number of prisoners and the number of simulations to run.\n\nAlso test with 10 prisoners to verify that the logic is correct for random selection. Random selection should succeed with 10 prisoners at a probability of (1/2)\\*\\*10, so in 100\\_000 simulations, should get pardons about .0977 percent of the time.\n\n```\nunit sub MAIN (:$prisoners = 100, :$simulations = 10000);\nmy @prisoners = ^$prisoners;\nmy $half = floor +@prisoners / 2;\n\nsub random ($n) {\n    ^$n .race.map( {\n        my @drawers = @prisoners.pick: *;\n        @prisoners.map( -> $prisoner {\n            my $found = 0;\n            for @drawers.pick($half) -> $card {\n                $found = 1 and last if $card == $prisoner\n            }\n            last unless $found;\n            $found\n        }\n        ).sum == @prisoners\n    }\n    ).grep( *.so ).elems / $n * 100\n}\n\nsub optimal ($n) {\n    ^$n .race.map( {\n        my @drawers = @prisoners.pick: *;\n        @prisoners.map( -> $prisoner {\n            my $found = 0;\n            my $card = @drawers[$prisoner];\n            if $card == $prisoner {\n                $found = 1\n            } else {\n                for ^($half - 1) {\n                    $card = @drawers[$card];\n                    $found = 1 and last if $card == $prisoner\n                }\n            }\n            last unless $found;\n            $found\n        }\n        ).sum == @prisoners\n    }\n    ).grep( *.so ).elems / $n * 100\n}\n\nsay \"Testing $simulations simulations with $prisoners prisoners.\";\nprintf \" Random play wins: %.3f%% of simulations\\n\", random $simulations;\nprintf \"Optimal play wins: %.3f%% of simulations\\n\", optimal $simulations;\n\n```\n\nOutput:\n\n**With defaults**\n\n```\nTesting 10000 simulations with 100 prisoners.\n Random play wins: 0.000% of simulations\nOptimal play wins: 30.510% of simulations\n```\n\n**With passed parameters: --prisoners=10, --simulations=100000**\n\n```\nTesting 100000 simulations with 10 prisoners.\n Random play wins: 0.099% of simulations\nOptimal play wins: 35.461% of simulations\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show on this page the 10001st prime number."}, {"role": "assistant", "content": "```\nsay (^∞).grep( &is-prime )[10000]\n\n```\n\nOutput:\n\n```\n104743\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement the Fifteen Puzzle Game.\n\nThe   **15-puzzle**   is also known as:\n\n:   :   :   * **Fifteen Puzzle**\n            * **Gem Puzzle**\n            * **Boss Puzzle**\n            * **Game of Fifteen**\n            * **Mystic Square**\n            * **14-15 Puzzle**\n            * and some others.\n\nRelated Tasks\n:   * 15 Puzzle Solver\n    * 16 Puzzle Game"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.06\n\nMost of this is interface code. Reused substantial portions from the 2048 task. Use the arrow keys to slide tiles, press 'q' to quit or 'n' for a new puzzle. Requires a POSIX termios aware terminal. Ensures that the puzzle is solvable by shuffling the board with an even number of swaps, then checking for even taxicab parity for the empty space.\n\n```\nuse Term::termios;\n\nconstant $saved   = Term::termios.new(fd => 1).getattr;\nconstant $termios = Term::termios.new(fd => 1).getattr;\n# raw mode interferes with carriage returns, so\n# set flags needed to emulate it manually\n$termios.unset_iflags(<BRKINT ICRNL ISTRIP IXON>);\n$termios.unset_lflags(< ECHO ICANON IEXTEN ISIG>);\n$termios.setattr(:DRAIN);\n\n# reset terminal to original setting on exit\nEND { $saved.setattr(:NOW) }\n\nconstant n    = 4; # board size\nconstant cell = 6; # cell width\n\nconstant $top = join '─' x cell, '┌', '┬' xx n-1, '┐';\nconstant $mid = join '─' x cell, '├', '┼' xx n-1, '┤';\nconstant $bot = join '─' x cell, '└', '┴' xx n-1, '┘';\n\nmy %dir = (\n   \"\\e[A\" => 'up',\n   \"\\e[B\" => 'down',\n   \"\\e[C\" => 'right',\n   \"\\e[D\" => 'left',\n);\n\nmy @solved = [1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,' '];\nmy @board;\nnew();\n\nsub new () {\n    loop {\n       @board = shuffle();\n       last if parity-ok(@board);\n   }\n}\n\nsub parity-ok (@b) {\n    my $row = @b.first(/' '/,:k);\n    my $col = @b[$row].first(/' '/,:k);\n    so ([3,3] <<->> [$row,$col]).sum %% 2;\n}\n\nsub shuffle () {\n    my @c = [1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,' '];\n    for (^16).pick(*) -> $y, $x {\n        my ($yd, $ym, $xd, $xm) = ($y div n, $y mod n, $x div n, $x mod n);\n        @(@c[$ym;$yd],@c[$xm;$xd]) = @(@c[$xm;$xd],@c[$ym;$yd]);\n    }\n    @c;\n}\n\nsub row (@row) { '│' ~ (join '│', @row».&center) ~ '│' }\n\nsub center ($s){\n    my $c   = cell - $s.chars;\n    my $pad = ' ' x ceiling($c/2);\n    sprintf \"%{cell}s\", \"$s$pad\";\n}\n\nsub draw-board {\n    run('clear');\n    print qq:to/END/;\n\n\n\tPress direction arrows to move.\n\n\tPress q to quit. Press n for a new puzzle.\n\n\t$top\n\t{ join \"\\n\\t$mid\\n\\t\", map { .&row }, @board }\n\t$bot\n\n\t{ (so @board ~~ @solved) ?? 'Solved!!' !! '' }\nEND\n}\n\nsub slide (@c is copy) {\n    my $t = (grep { /' '/ }, :k, @c)[0];\n    return @c unless $t and $t > 0;\n    @c[$t,$t-1] = @c[$t-1,$t];\n    @c;\n}\n\nproto sub move (|) {*};\n\nmulti move('up') {\n    map { @board[*;$_] = reverse slide reverse @board[*;$_] }, ^n;\n}\n\nmulti move('down') {\n    map { @board[*;$_] = slide @board[*;$_] }, ^n;\n}\n\nmulti move('left') {\n    map { @board[$_] = reverse slide reverse @board[$_] }, ^n;\n}\n\nmulti move('right') {\n    map { @board[$_] = slide @board[$_] }, ^n;\n}\n\nloop {\n    draw-board;\n\n    # Read up to 4 bytes from keyboard buffer.\n    # Page navigation keys are 3-4 bytes each.\n    # Specifically, arrow keys are 3.\n    my $key = $*IN.read(4).decode;\n\n    move %dir{$key} if so %dir{$key};\n    last if $key eq 'q'; # (q)uit\n    new() if $key eq 'n';\n}\n\n```\n\nSample screen shot:\n\n```\n\tPress direction arrows to move.\n\n\tPress q to quit. Press n for a new puzzle.\n\n\t┌──────┬──────┬──────┬──────┐\n\t│  2   │  1   │  10  │  14  │\n\t├──────┼──────┼──────┼──────┤\n\t│  15  │  11  │  12  │      │\n\t├──────┼──────┼──────┼──────┤\n\t│  13  │  3   │  6   │  7   │\n\t├──────┼──────┼──────┼──────┤\n\t│  9   │  4   │  5   │  8   │\n\t└──────┴──────┴──────┴──────┘\n\n```"}]}
{"messages": [{"role": "user", "content": "Your task is to write a program that finds a solution in the fewest moves possible single moves to a random Fifteen Puzzle Game.  \nFor this task you will be using the following puzzle:\n\n```\n15 14  1  6\n 9 11  4 12\n 0 10  7  3\n13  8  5  2\n```\n\nSolution:\n\n```\n 1  2  3  4\n 5  6  7  8\n 9 10 11 12\n13 14 15  0\n\n```\n\nThe output must show the moves' directions, like so: left, left, left, down, right... and so on.  \nThere are two solutions, of fifty-two moves:  \nrrrulddluuuldrurdddrullulurrrddldluurddlulurruldrdrd  \nrrruldluuldrurdddluulurrrdlddruldluurddlulurruldrrdd  \nsee: Pretty Print of Optimal Solution\n\nFinding either one, or both is an acceptable result.\n\nExtra credit.\n\nSolve the following problem:\n\n```\n  0 12  9 13\n 15 11 10 14\n  3  7  2  5\n  4  8  6  1\n\n```\n\nRelated Task\n\n* 15 puzzle game\n* A\\* search algorithm"}, {"role": "assistant", "content": "**Translation of**: C++\n\n```\n# 20210623 Raku programming solution vCSMt9hkak0\n\nconstant \\Nr = <3 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3>;\nconstant \\Nc = <3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2>;\n\nmy ($n,$m) = 0,0 ;\nmy @N0 is default(0);\nmy @N3 is default(0);\nmy @N4 is default(0);\nmy @N2 is default(0);\n\nsub fY() {\n   if @N2[$n] == 0x123456789abcdef0 {\n      say \"Solution found in \", $n, \" moves: \", [~] @N3[1..$n] and exit();\n   }\n   return @N4[$n] ≤ $m ?? fN() !! False ;\n}\n\nsub fN() {\n   sub common { ++$n; return True if fY(); --$n }\n   if (@N3[$n] ne 'u' && @N0[$n] div 4 < 3) { fI() and common }\n   if (@N3[$n] ne 'd' && @N0[$n] div 4 > 0) { fG() and common }\n   if (@N3[$n] ne 'l' && @N0[$n]  %  4 < 3) { fE() and common }\n   if (@N3[$n] ne 'r' && @N0[$n]  %  4 > 0) { fL() and common }\n   return False;\n}\n\nsub fI() {\n   my \\g = (11-@N0[$n])*4;\n   my \\a = @N2[$n] +& (15 +< g);\n   @N0[$n+1]=@N0[$n]+4;\n   @N2[$n+1]=@N2[$n]-a+(a+<16);\n   @N3[$n+1]='d';\n   @N4[$n+1]=@N4[$n]+(Nr[a+>g] ≤ @N0[$n] div 4 ?? 0 !! 1);\n}\n\nsub fG() {\n   my \\g = (19-@N0[$n])*4;\n   my \\a = @N2[$n] +& (15 +< g);\n   @N0[$n+1]=@N0[$n]-4;\n   @N2[$n+1]=@N2[$n]-a+(a+>16);\n   @N3[$n+1]='u';\n   @N4[$n+1]=@N4[$n]+(Nr[a+>g] ≥ @N0[$n] div 4 ?? 0 !! 1);\n}\n\nsub fE() {\n   my \\g = (14-@N0[$n])*4;\n   my \\a = @N2[$n] +& (15 +< g);\n   @N0[$n+1]=@N0[$n]+1;\n   @N2[$n+1]=@N2[$n]-a+(a+<4);\n   @N3[$n+1]='r';\n   @N4[$n+1]=@N4[$n]+(Nc[a+>g] ≤ @N0[$n]%4 ?? 0 !! 1);\n}\n\nsub fL(){\n   my \\g = (16-@N0[$n])*4;\n   my \\a = @N2[$n] +& (15 +< g);\n   @N0[$n+1]=@N0[$n]-1;\n   @N2[$n+1]=@N2[$n]-a+(a+>4);\n   @N3[$n+1]='l';\n   @N4[$n+1]=@N4[$n]+(Nc[a+>g] ≥ @N0[$n]%4 ?? 0 !! 1);\n}\n\nsub fifteenSolver(\\n, \\g){@N0[0]=n; @N2[0]=g}\n\n\nfifteenSolver(8,0xfe169b4c0a73d852);\nloop { fY() or ++$m }\n\n```\n\nOutput:\n\n```\nSolution found in 52 moves: rrrulddluuuldrurdddrullulurrrddldluurddlulurruldrdrd\n\n```"}]}
{"messages": [{"role": "user", "content": "16 numbered pieces of the puzzle are placed out of order on a 4 X 4 grid. The correct order to win is to order the pieces\nas 1 through 16, read left to right, top to bottom:\n\n```\n  1  2  3  4\n  5  6  7  8\n  9 10 11 12\n 13 14 15 16\n\n```\n\nHow to Play: The aim is to get the pieces back in order by clicking on the yellow arrows (choosing a location to rotate a row or column) to slide the pieces left or right, up or down.\n\n```\n  1 14  3  4          1  2  3  4\n  5  2  7  8   -->    5  6  7  8\n  9  6 11 12          9 10 11 12\n 13 10 15 16         13 14 15 16\n     ^\n\n\n```\n\nThe Easy puzzle target is 3 moves, for the Hard puzzle it is 12 moves (or less!). Can it be that simple?\n\nTask\n\nCreate 16 Puzzle Game.\n\nSee details: [1]\n\nVideo: 16 Puzzle Game\n\nRelated task\n:   * 15 Puzzle Game"}, {"role": "assistant", "content": "For brevity, changed to zero-based and skipped some error handling.\n\n**Translation of**: Go\n\n```\n# 20210914 Raku programming solution \n\nmy (\\easy,\\hard) = 1,4 ; my @n = ^16; my \\level = $ = easy ; my \\moves = $ = 0;\n\nsub hasWon { @n eq ^16 }\n\nsub setDiff($level) {\n   say \"\\nTarget is \", ( moves = $level == hard ?? 12 !! 3 ).Str, \" moves.\"; \n   for ^moves {\n      my \\s = (^4).roll;\n      @n[ ( [ s, s+4 ... s+12 ] , [ s*4 .. s*4+3 ] ).roll ] .= rotate ;\n      redo if hasWon\n   }\n}\n\nsub drawGrid {\n   say \"\\n     U1   U2   U3   U4\";\n   say \"   ╔════╦════╦════╦════╗\";\n   printf  \"L1 ║ %2d ║ %2d ║ %2d ║ %2d ║ R1\\n\", @n[0..3];\n   say \"   ╠════╬════╬════╬════╣\";\n   printf  \"L2 ║ %2d ║ %2d ║ %2d ║ %2d ║ R2\\n\", @n[4..7];\n   say \"   ╠════╬════╬════╬════╣\";\n   printf  \"L3 ║ %2d ║ %2d ║ %2d ║ %2d ║ R3\\n\", @n[8..11];\n   say \"   ╠════╬════╬════╬════╣\";\n   printf  \"L4 ║ %2d ║ %2d ║ %2d ║ %2d ║ R4\\n\", @n[12..15];\n   say \"   ╚════╩════╩════╩════╝\";\n   say \"     D1   D2   D3   D4\\n\"\n}\n\nsub init {\n   loop {\n      print \"Enter difficulty level easy or hard E/H : \";\n      given $*IN.get.uc {\n         when 'E'|'H' { level = $_ eq 'H' ?? hard !! easy ;  last  } \n         default      { say \"Invalid response, try again.\" }\n      }\n   }\n   setDiff(level);\n   moves = 0;\n}\n\ninit;\n\nloop {\n   drawGrid;\n   if hasWon() {\n      say \"Congratulations, you have won the game in {moves} moves.\\n\" and exit\n   } \n   say \"When entering moves, you can also enter Q to quit or S to start again.\";\n   say \"\\nMoves so far = {moves}\\n\";\n   print \"Enter move : \" ;\n   given $*IN.get.uc {\n      my \\c = .substr(*-1).ord - 49 ; moves++ ; \n      when 'D1'|'D2'|'D3'|'D4' { @n[ (12,8,4,0) >>+>> c   ] .= rotate }\n      when 'L1'|'L2'|'L3'|'L4' { @n[ (0,1,2,3)  >>+>> 4*c ] .= rotate }\n      when 'U1'|'U2'|'U3'|'U4' { @n[ (0,4,8,12) >>+>> c   ] .= rotate }\n      when 'R1'|'R2'|'R3'|'R4' { @n[ (3,2,1,0)  >>+>> 4*c ] .= rotate }\n      when 'Q'                 { exit } \n      when 'S'                 { init } \n      default                  { say \"\\nInvalid move, try again.\" and moves-- }\n   }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a 2D sliding block puzzle game where blocks with numbers are combined to add their values.\n\nRules of the game\n:   * The rules are that on each turn the player must choose a direction   (up, down, left or right).\n    * All tiles move as far as possible in that direction, some move more than others.\n    * Two adjacent tiles (in that direction only) with matching numbers combine into one bearing the sum of those numbers.\n    * A move is valid when at least one tile can be moved, including by combination.\n    * A new tile is spawned at the end of each turn at a randomly chosen empty square   (if there is one).\n    * Most of the time, a new **2** is to be added, but occasionally (**10%** of the time), a **4**.\n    * To win, the player must create a tile with the number **2048**.\n    * The player loses if no valid moves are possible.\n\nThe name comes from the popular open-source implementation of this game mechanic, 2048.\n\nRequirements\n\n* \"Non-greedy\" movement.  \n    The tiles that were created by combining other tiles should not be combined again during the same turn (move).  \n    That is to say, that moving the tile row of:\n\n```\n               [2][2][2][2] \n\n```\n\n:   :   to the right should result in:\n\n```\n               ......[4][4] \n\n```\n\n:   :   and not:\n\n```\n               .........[8] \n\n```\n\n* \"Move direction priority\".  \n    If more than one variant of combining is possible, move direction shall indicate which combination will take effect.   \n    For example, moving the tile row of:\n\n```\n               ...[2][2][2] \n\n```\n\n:   :   to the right should result in:\n\n```\n               ......[2][4] \n\n```\n\n:   :   and not:\n\n```\n               ......[4][2] \n\n```\n\n* Check for valid moves. The player shouldn't be able to gain new tile by trying a move that doesn't change the board.\n* Check for a win condition.\n* Check for a lose condition."}, {"role": "assistant", "content": "(formerly Perl 6)\nUses termios to set the terminal options, so only compatible with POSIX terminals. This version does not include a specific \"win\" or \"lose\" condition. (though it would be trivial to add them.) You can continue to play this even after getting a 2048 tile; and if there is no valid move you can make, you can't do anything but quit.\n\n**Works with**: Rakudo version 2018.05\n\n```\nuse Term::termios;\n\nconstant $saved   = Term::termios.new(fd => 1).getattr;\nconstant $termios = Term::termios.new(fd => 1).getattr;\n# raw mode interferes with carriage returns, so\n# set flags needed to emulate it manually\n$termios.unset_iflags(<BRKINT ICRNL ISTRIP IXON>);\n$termios.unset_lflags(< ECHO ICANON IEXTEN ISIG>);\n$termios.setattr(:DRAIN);\n\n# reset terminal to original setting on exit\nEND { $saved.setattr(:NOW) }\n\nconstant n    = 4; # board size\nconstant cell = 6; # cell width\nconstant ansi = True; # color!\n\nmy @board = ( ['' xx n] xx n );\nmy $save  = '';\nmy $score = 0;\n\nconstant $top = join '─' x cell, '┌', '┬' xx n-1, '┐';\nconstant $mid = join '─' x cell, '├', '┼' xx n-1, '┤';\nconstant $bot = join '─' x cell, '└', '┴' xx n-1, '┘';\n\nmy %dir = (\n   \"\\e[A\" => 'up',\n   \"\\e[B\" => 'down',\n   \"\\e[C\" => 'right',\n   \"\\e[D\" => 'left',\n);\n\nmy @ANSI = <0 1;97 1;93 1;92 1;96 1;91 1;95 1;94 1;30;47 1;43\n    1;42 1;46 1;41 1;45 1;44 1;33;43 1;33;42 1;33;41 1;33;44>;\n\nsub row (@row) { '│' ~ (join '│', @row».&center) ~ '│' }\n\nsub center ($s){\n    my $c   = cell - $s.chars;\n    my $pad = ' ' x ceiling($c/2);\n    my $tile = sprintf \"%{cell}s\", \"$s$pad\";\n    my $idx = $s ?? $s.log(2) !! 0;\n    ansi ?? \"\\e[{@ANSI[$idx]}m$tile\\e[0m\" !! $tile;\n}\n\nsub draw-board {\n    run('clear');\n    print qq:to/END/;\n\n\n\tPress direction arrows to move.\n\n\tPress q to quit.\n\n\t$top\n\t{ join \"\\n\\t$mid\\n\\t\", map { .&row }, @board }\n\t$bot\n\n\tScore: $score\n\nEND\n}\n\nsub squash (@c) {\n    my @t = grep { .chars }, @c;\n    map { combine(@t[$_], @t[$_+1]) if @t[$_] && @t[$_+1] == @t[$_] }, ^@t-1;\n    @t = grep { .chars }, @t;\n    @t.push: '' while @t < n;\n    @t;\n}\n\nsub combine ($v is rw, $w is rw) { $v += $w; $w = ''; $score += $v; }\n\nproto sub move (|) {*};\n\nmulti move('up') {\n    map { @board[*;$_] = squash @board[*;$_] }, ^n;\n}\n\nmulti move('down') {\n    map { @board[*;$_] = reverse squash reverse @board[*;$_] }, ^n;\n}\n\nmulti move('left') {\n    map { @board[$_] = squash @board[$_] }, ^n;\n}\n\nmulti move('right') {\n    map { @board[$_;*] = reverse squash reverse @board[$_] }, ^n;\n}\n\nsub another {\n    my @empties;\n    for @board.kv -> $r, @row {\n        @empties.push(($r, $_)) for @row.grep(:k, '');\n    }\n    my ( $x, $y ) = @empties.roll;\n    @board[$x; $y] = (flat 2 xx 9, 4).roll;\n}\n\nsub save () { join '|', flat @board».list }\n\nloop {\n    another if $save ne save();\n    draw-board;\n    $save = save();\n\n    # Read up to 4 bytes from keyboard buffer.\n    # Page navigation keys are 3-4 bytes each.\n    # Specifically, arrow keys are 3.\n    my $key = $*IN.read(4).decode;\n\n    move %dir{$key} if so %dir{$key};\n    last if $key eq 'q'; # (q)uit\n}\n\n```\n\nSample output:\n\n```\n\n\n\tPress direction arrows to move.\n\n\tPress q to quit. \n\n\t┌──────┬──────┬──────┬──────┐\n\t│  4   │  2   │      │      │\n\t├──────┼──────┼──────┼──────┤\n\t│  16  │  8   │      │      │\n\t├──────┼──────┼──────┼──────┤\n\t│  64  │  32  │  16  │      │\n\t├──────┼──────┼──────┼──────┤\n\t│ 128  │ 512  │ 128  │  64  │\n\t└──────┴──────┴──────┴──────┘\n\n\tScore: 6392\n\n```"}]}
{"messages": [{"role": "user", "content": "**21** is a two player game, the game is played by choosing\na number (**1**, **2**, or **3**) to be added to the *running total*.\n\nThe game is won by the player whose chosen number causes the *running total*\nto reach *exactly* **21**.\n\nThe *running total* starts at zero.\nOne player will be the computer.\n\nPlayers alternate supplying a number to be added to the *running total*.\n\nTask\n\nWrite a computer program that will:\n\n:   :   * do the prompting (or provide a button menu),\n        * check for errors and display appropriate error messages,\n        * do the additions (add a chosen number to the *running total*),\n        * display the *running total*,\n        * provide a mechanism for the player to quit/exit/halt/stop/close the program,\n        * issue a notification when there is a winner, and\n        * determine who goes first (maybe a random or user choice, or can be specified when the game begins)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\nSince there is no requirement that the computer play sensibly, it always plays a random guess so the player has some chance to win.\n\n```\nsay qq :to 'HERE';\n    The 21 game. Each player chooses to add 1, 2, or 3 to a running total.\n    The player whose turn it is when the total reaches 21 wins. Enter q to quit.\n    HERE\n\nmy $total = 0;\nloop {\n    say \"Running total is: $total\";\n    my ($me,$comp);\n    loop {\n        $me = prompt 'What number do you play> ';\n        last if $me ~~ /^<[123]>$/;\n        insult $me;\n    }\n    $total += $me;\n    win('Human') if $total >= 21;\n    say \"Computer plays: { $comp = (1,2,3).roll }\\n\";\n    $total += $comp;\n    win('Computer') if $total >= 21;\n}\n\nsub win ($player) {\n    say \"$player wins.\";\n    exit;\n}\n\nsub insult ($g) {\n    exit if $g eq 'q';\n    print ('Yo mama,', 'Jeez,', 'Ummmm,', 'Grow up,', 'Did you even READ the instructions?').roll;\n    say \" $g is not an integer between 1 & 3...\"\n}\n\n```\n\nSample game:\n\n```\nThe 21 game. Each player chooses to add 1, 2, or 3 to a running total.\nThe player whose turn it is when the total reaches 21 wins. Enter q to quit.\n\nRunning total is: 0\nWhat number do you play> 5\nDid you even READ the instructions? 5 is not an integer between 1 & 3...\nWhat number do you play> g\nYo mama, g is not an integer between 1 & 3...\nWhat number do you play> 12\nJeez, 12 is not an integer between 1 & 3...\nWhat number do you play> 3\nComputer plays: 2\n\nRunning total is: 5\nWhat number do you play> 3\nComputer plays: 3\n\nRunning total is: 11\nWhat number do you play> 1\nComputer plays: 1\n\nRunning total is: 13\nWhat number do you play> 3\nComputer plays: 2\n\nRunning total is: 18\nWhat number do you play> 3\nHuman wins.\n```"}]}
{"messages": [{"role": "user", "content": "The 24 Game tests one's mental arithmetic.\n\nTask\n\nWrite a program that randomly chooses and displays four digits, each from 1 ──► 9 (inclusive) with repetitions allowed.\n\nThe program should prompt for the player to enter an arithmetic expression using *just* those, and *all* of those four digits, used exactly *once* each. The program should *check* then evaluate the expression.\n\nThe goal is for the player to enter an expression that (numerically) evaluates to **24**.\n\n* Only the following operators/functions are allowed: multiplication, division, addition, subtraction\n* Division should use floating point or rational arithmetic, etc, to preserve remainders.\n* Brackets are allowed, if using an infix expression evaluator.\n* Forming multiple digit numbers from the supplied digits is *disallowed*. (So an answer of 12+12 when given 1, 2, 2, and 1 is wrong).\n* The order of the digits when given does not have to be preserved.\n\nNotes\n\n* The type of expression evaluator used is not mandated. An RPN evaluator is equally acceptable for example.\n* The task is not for the program to generate the expression, or test whether an expression is even possible.\n\nRelated tasks\n\n* 24 game/Solve\n\nReference\n\n* The 24 Game on h2g2."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nuse MONKEY-SEE-NO-EVAL;\n\nsay \"Here are your digits: \", \nconstant @digits = (1..9).roll(4)».Str;\n \ngrammar Exp24 {\n    token TOP { ^ <exp> $ { fail unless EVAL($/) == 24 } }\n    rule exp { <term>+ % <op> }\n    rule term { '(' <exp> ')' | <@digits> }\n    token op { < + - * / > }\n}\n \nwhile my $exp = prompt \"\\n24? \" {\n    if try Exp24.parse: $exp {\n        say \"You win :)\";\n        last;\n    } else {\n        say (\n            'Sorry.  Try again.' xx 20,\n            'Try harder.' xx 5,\n            'Nope.  Not even close.' xx 2,\n            'Are you five or something?',\n            'Come on, you can do better than that.'\n        ).flat.pick\n    }\n}\n\n```\n\nThe `MONKEY-SEE-NO-EVAL` pragma enables the dangerous `EVAL` function, which will compile and execute even user input. In this example, the grammar used to parse the input should ensure that only safe expressions are evaluated."}]}
{"messages": [{"role": "user", "content": "task\n\nWrite a program that takes four digits, either from user input or by random generation, and computes arithmetic expressions following the rules of the 24 game.\n\nShow examples of solutions generated by the program.\n\nRelated task\n\n* Arithmetic Evaluator"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### With EVAL\n\nA loose translation of the Perl entry. Does not return every possible permutation of the possible solutions. Filters out duplicates (from repeated digits) and only reports the solution for a particular order of digits and operators with the fewest parenthesis (avoids reporting duplicate solutions only differing by unnecessary parenthesis). Does not guarantee the order in which results are returned.\n\nSince Raku uses Rational numbers for division (whenever possible) there is no loss of precision as is common with floating point division. So a comparison like (1 + 7) / (1 / 3) == 24 \"Just Works\"™\n\n```\nuse MONKEY-SEE-NO-EVAL;\n\nmy @digits;\nmy $amount = 4;\n\n# Get $amount digits from the user,\n# ask for more if they don't supply enough\nwhile @digits.elems < $amount {\n    @digits.append: (prompt \"Enter {$amount - @digits} digits from 1 to 9, \"\n    ~ '(repeats allowed): ').comb(/<[1..9]>/);\n}\n# Throw away any extras\n@digits = @digits[^$amount];\n\n# Generate combinations of operators\nmy @ops = [X,] <+ - * /> xx 3;\n\n# Enough sprintf formats to cover most precedence orderings\nmy @formats = (\n    '%d %s %d %s %d %s %d',\n    '(%d %s %d) %s %d %s %d',\n    '(%d %s %d %s %d) %s %d',\n    '((%d %s %d) %s %d) %s %d',\n    '(%d %s %d) %s (%d %s %d)',\n    '%d %s (%d %s %d %s %d)',\n    '%d %s (%d %s (%d %s %d))',\n);\n\n# Brute force test the different permutations\n@digits.permutations».join.unique».comb.race.map: -> @p {\n    for @ops -> @o {\n        for @formats -> $format {\n            my $result = .EVAL given my $string = sprintf $format, roundrobin(@p, @o, :slip);\n            say \"$string = 24\" and last if $result and $result == 24;\n        }\n    }\n}\n\n```\n\nOutput:\n\n```\nEnter 4 digits from 1 to 9, (repeats allowed): 3711\n(1 + 7) * 3 * 1 = 24\n(1 + 7) * 3 / 1 = 24\n(1 * 3) * (1 + 7) = 24\n3 * (1 + 1 * 7) = 24\n(3 * 1) * (1 + 7) = 24\n3 * (1 / 1 + 7) = 24\n(3 / 1) * (1 + 7) = 24\n3 / (1 / (1 + 7)) = 24\n(1 + 7) * 1 * 3 = 24\n(1 + 7) / 1 * 3 = 24\n(1 + 7) / (1 / 3) = 24\n(1 * 7 + 1) * 3 = 24\n(7 + 1) * 3 * 1 = 24\n(7 + 1) * 3 / 1 = 24\n(7 - 1) * (3 + 1) = 24\n(1 + 1 * 7) * 3 = 24\n(1 * 1 + 7) * 3 = 24\n(1 / 1 + 7) * 3 = 24\n(3 + 1) * (7 - 1) = 24\n3 * (1 + 7 * 1) = 24\n3 * (1 + 7 / 1) = 24\n(3 * 1) * (7 + 1) = 24\n(3 / 1) * (7 + 1) = 24\n3 / (1 / (7 + 1)) = 24\n(1 + 3) * (7 - 1) = 24\n(1 * 3) * (7 + 1) = 24\n(7 + 1) * 1 * 3 = 24\n(7 + 1) / 1 * 3 = 24\n(7 + 1) / (1 / 3) = 24\n(7 - 1) * (1 + 3) = 24\n(7 * 1 + 1) * 3 = 24\n(7 / 1 + 1) * 3 = 24\n3 * (7 + 1 * 1) = 24\n3 * (7 + 1 / 1) = 24\n3 * (7 * 1 + 1) = 24\n3 * (7 / 1 + 1) = 24\n\nEnter 4 digits from 1 to 9, (repeats allowed):  5 5 5 5\n5 * 5 - 5 / 5 = 24\n\nEnter 4 digits from 1 to 9, (repeats allowed): 8833\n8 / (3 - 8 / 3) = 24\n\n```\n\n### No EVAL\n\nAlternately, a version that doesn't use EVAL. More general case. Able to handle 3 or 4 integers, able to select the goal value.\n\n```\nmy %*SUB-MAIN-OPTS = :named-anywhere;\n\nsub MAIN (*@parameters, Int :$goal = 24) {\n    my @numbers;\n    if +@parameters == 1 {\n        @numbers = @parameters[0].comb(/\\d/);\n        USAGE() and exit unless 2 < @numbers < 5;\n    } elsif +@parameters > 4 {\n        USAGE() and exit;\n    } elsif +@parameters == 3|4 {\n        @numbers = @parameters;\n        USAGE() and exit if @numbers.any ~~ /<-[-\\d]>/;\n    } else {\n        USAGE();\n        exit if +@parameters == 2;\n        @numbers = 3,3,8,8;\n        say 'Running demonstration with: ', |@numbers, \"\\n\";\n    }\n    solve @numbers, $goal\n}\n\nsub solve (@numbers, $goal = 24) {\n    my @operators = < + - * / >;\n    my @ops   = [X] @operators xx (@numbers - 1);\n    my @perms = @numbers.permutations.unique( :with(&[eqv]) );\n    my @order = (^(@numbers - 1)).permutations;\n    my @sol;\n    @sol[250]; # preallocate some stack space\n\n    my $batch = ceiling +@perms/4;\n\n    my atomicint $i;\n    @perms.race(:batch($batch)).map: -> @p {\n        for @ops -> @o {\n            for @order -> @r {\n                my $result = evaluate(@p, @o, @r);\n                @sol[$i⚛++] = $result[1] if $result[0] and $result[0] == $goal;\n            }\n        }\n    }\n    @sol.=unique;\n    say @sol.join: \"\\n\";\n    my $pl = +@sol == 1 ?? '' !! 's';\n    my $sg = $pl ?? '' !! 's';\n    say +@sol, \" equation{$pl} evaluate{$sg} to $goal using: {@numbers}\";\n}\n\nsub evaluate ( @digit, @ops, @orders ) {\n    my @result = @digit.map: { [ $_, $_ ] };\n    my @offset = 0 xx +@orders;\n\n    for ^@orders {\n        my $this  = @orders[$_];\n        my $order = $this - @offset[$this];\n        my $op    = @ops[$this];\n        my $result = op( $op, @result[$order;0], @result[$order+1;0] );\n        return [ NaN, Str ] unless defined $result;\n        my $string = \"({@result[$order;1]} $op {@result[$order+1;1]})\";\n        @result.splice: $order, 2, [ $[ $result, $string ] ];\n        @offset[$_]++ if $order < $_ for ^@offset;\n    }\n    @result[0];\n}\n\nmulti op ( '+', $m, $n ) { $m + $n }\nmulti op ( '-', $m, $n ) { $m - $n }\nmulti op ( '/', $m, $n ) { $n == 0 ?? fail() !! $m / $n }\nmulti op ( '*', $m, $n ) { $m * $n }\n\nmy $txt = \"\\e[0;96m\";\nmy $cmd = \"\\e[0;92m> {$*EXECUTABLE-NAME} {$*PROGRAM-NAME}\";\nsub USAGE {\n    say qq:to\n    '========================================================================'\n    {$txt}Supply 3 or 4 integers on the command line, and optionally a value\n    to equate to.\n\n    Integers may be all one group: {$cmd} 2233{$txt}\n          Or, separated by spaces: {$cmd} 2 4 6 7{$txt}\n\n    If you wish to supply multi-digit or negative numbers, you must\n        separate them with spaces: {$cmd} -2 6 12{$txt}\n\n    If you wish to use a different equate value,\n    supply a new --goal parameter: {$cmd} --goal=17 2 -3 1 9{$txt}\n\n    If you don't supply any parameters, will use 24 as the goal, will run a\n    demo and will show this message.\\e[0m\n    ========================================================================\n}\n\n```\n\nOutput:\n\nWhen supplied 1399 on the command line:\n\n```\n(((9 - 1) / 3) * 9)\n((9 - 1) / (3 / 9))\n((9 / 3) * (9 - 1))\n(9 / (3 / (9 - 1)))\n((9 * (9 - 1)) / 3)\n(9 * ((9 - 1) / 3))\n(((9 - 1) * 9) / 3)\n((9 - 1) * (9 / 3))\n8 equations evaluate to 24 using: 1 3 9 9\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nReplace       **a, b, c, d, e, f,**   and\n  **g**        with the decimal\ndigits   LOW   ───►   HIGH\n  \nsuch that the sum of the letters inside of each of the four large squares add up to\nthe same sum.\n\n```\n            ╔══════════════╗      ╔══════════════╗\n            ║              ║      ║              ║\n            ║      a       ║      ║      e       ║\n            ║              ║      ║              ║\n            ║          ┌───╫──────╫───┐      ┌───╫─────────┐\n            ║          │   ║      ║   │      │   ║         │\n            ║          │ b ║      ║ d │      │ f ║         │\n            ║          │   ║      ║   │      │   ║         │\n            ║          │   ║      ║   │      │   ║         │\n            ╚══════════╪═══╝      ╚═══╪══════╪═══╝         │\n                       │       c      │      │      g      │\n                       │              │      │             │\n                       │              │      │             │\n                       └──────────────┘      └─────────────┘\n\n```\n\nShow all output here.\n\n:   * Show all solutions for each letter being unique with\n\n```\n        LOW=1     HIGH=7\n\n```\n\n:   * Show all solutions for each letter being unique with\n\n```\n        LOW=3     HIGH=9\n\n```\n\n:   * Show only the   *number*   of solutions when each letter can be non-unique\n\n```\n        LOW=0     HIGH=9\n\n```\n\nRelated task\n\n* Solve the no connection puzzle"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.12\n\n```\nsub four-squares ( @list, :$unique=1, :$show=1 ) {\n\n    my @solutions;\n\n    for $unique.&combos -> @c {\n        @solutions.push: @c if [==]\n          @c[0] + @c[1],\n          @c[1] + @c[2] + @c[3],\n          @c[3] + @c[4] + @c[5],\n          @c[5] + @c[6];\n    }\n\n    say +@solutions, ($unique ?? ' ' !! ' non-'), \"unique solutions found using {join(', ', @list)}.\\n\";\n\n    my $f = \"%{@list.max.chars}s\";\n\n    say join \"\\n\", (('a'..'g').fmt: $f), @solutions».fmt($f), \"\\n\" if $show;\n\n    multi combos ( $ where so * ) { @list.combinations(7).map: |*.permutations }\n\n    multi combos ( $ where not * ) { [X] @list xx 7 }\n}\n\n# TASK\nfour-squares( [1..7] );\nfour-squares( [3..9] );\nfour-squares( [8, 9, 11, 12, 17, 18, 20, 21] );\nfour-squares( [0..9], :unique(0), :show(0) );\n\n```\n\nOutput:\n\n```\n8 unique solutions found using 1, 2, 3, 4, 5, 6, 7.\n\na b c d e f g\n3 7 2 1 5 4 6\n4 5 3 1 6 2 7\n4 7 1 3 2 6 5\n5 6 2 3 1 7 4\n6 4 1 5 2 3 7\n6 4 5 1 2 7 3\n7 2 6 1 3 5 4\n7 3 2 5 1 4 6\n\n\n4 unique solutions found using 3, 4, 5, 6, 7, 8, 9.\n\na b c d e f g\n7 8 3 4 5 6 9\n8 7 3 5 4 6 9\n9 6 4 5 3 7 8\n9 6 5 4 3 8 7\n\n\n8 unique solutions found using 8, 9, 11, 12, 17, 18, 20, 21.\n\n a  b  c  d  e  f  g\n17 21  8  9 11 18 20\n20 18 11  9  8 21 17\n17 21  9  8 12 18 20\n20 18  8 12  9 17 21\n20 18 12  8  9 21 17\n21 17  9 12  8 18 20\n20 18 11  9 12 17 21\n21 17 12  9 11 18 20\n\n\n2860 non-unique solutions found using 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.\n\n```"}]}
{"messages": [{"role": "user", "content": "This task is a variation of the short story by Arthur C. Clarke.\n\n(Solvers should be aware of the consequences of completing this task.)\n\nIn detail, to specify what is meant by a   “name”:\n\n:   The integer 1 has 1 name     “1”.\n:   The integer 2 has 2 names   “1+1”,   and   “2”.\n:   The integer 3 has 3 names   “1+1+1”,   “2+1”,   and   “3”.\n:   The integer 4 has 5 names   “1+1+1+1”,   “2+1+1”,   “2+2”,   “3+1”,   “4”.\n:   The integer 5 has 7 names   “1+1+1+1+1”,   “2+1+1+1”,   “2+2+1”,   “3+1+1”,   “3+2”,   “4+1”,   “5”.\n\nTask\n\nDisplay the first 25 rows of a number triangle which begins:\n\n```\n                                      1\n                                    1   1\n                                  1   1   1 \n                                1   2   1   1\n                              1   2   2   1   1\n                            1   3   3   2   1   1\n\n```\n\nWhere row   \n\nn\n{\\displaystyle {\\displaystyle n}}\n   corresponds to integer   \n\nn\n{\\displaystyle {\\displaystyle n}}\n,   and each column   \n\nC\n{\\displaystyle {\\displaystyle C}}\n   in row   \n\nm\n{\\displaystyle {\\displaystyle m}}\n   from left to right corresponds to the number of names beginning with   \n\nC\n{\\displaystyle {\\displaystyle C}}\n.\n\nA function   \n\nG\n(\nn\n)\n{\\displaystyle {\\displaystyle G(n)}}\n   should return the sum of the   \n\nn\n{\\displaystyle {\\displaystyle n}}\n-th   row.\n\nDemonstrate this function by displaying:   \n\nG\n(\n23\n)\n{\\displaystyle {\\displaystyle G(23)}}\n,   \n\nG\n(\n123\n)\n{\\displaystyle {\\displaystyle G(123)}}\n,   \n\nG\n(\n1234\n)\n{\\displaystyle {\\displaystyle G(1234)}}\n,   and   \n\nG\n(\n12345\n)\n{\\displaystyle {\\displaystyle G(12345)}}\n.\n\nOptionally note that the sum of the   \n\nn\n{\\displaystyle {\\displaystyle n}}\n-th   row   \n\nP\n(\nn\n)\n{\\displaystyle {\\displaystyle P(n)}}\n   is the     integer partition function.\n\nDemonstrate this is equivalent to   \n\nG\n(\nn\n)\n{\\displaystyle {\\displaystyle G(n)}}\n   by displaying:   \n\nP\n(\n23\n)\n{\\displaystyle {\\displaystyle P(23)}}\n,   \n\nP\n(\n123\n)\n{\\displaystyle {\\displaystyle P(123)}}\n,   \n\nP\n(\n1234\n)\n{\\displaystyle {\\displaystyle P(1234)}}\n,   and   \n\nP\n(\n12345\n)\n{\\displaystyle {\\displaystyle P(12345)}}\n.\n\nExtra credit\n\nIf your environment is able, plot   \n\nP\n(\nn\n)\n{\\displaystyle {\\displaystyle P(n)}}\n   against   \n\nn\n{\\displaystyle {\\displaystyle n}}\n   for   \n\nn\n=\n1\n…\n999\n{\\displaystyle {\\displaystyle n=1\\ldots 999}}\n.\n\nRelated tasks\n\n* Partition function P"}, {"role": "assistant", "content": "(formerly Perl 6)\nTo save a bunch of memory, this algorithm throws away all the numbers that it knows it's not going to use again, on the assumption that the function will only be called with increasing values of $n. (It could easily be made to recalculate if it notices a regression.)\n\n```\nmy @todo = $[1];\nmy @sums = 0;\nsub nextrow($n) {\n    for +@todo .. $n -> $l {\n        my $r = [];\n        for reverse ^$l -> $x {\n            my @x := @todo[$x];\n            if @x {\n                $r.push: @sums[$x] += @x.shift;\n            }\n            else {\n                $r.push: @sums[$x];\n            }\n        }\n        @todo.push($r);\n    }\n    @todo[$n];\n}\n\nsay \"rows:\";\nsay .fmt('%2d'), \": \", nextrow($_)[] for 1..25;\n\n\nmy @names-of-God = 1, { partition-sum ++$ } … *;\nmy @names-of-God-adder = lazy [\\+] flat 1, ( (1 .. *) Z (1 .. *).map: * × 2 + 1 );\nsub partition-sum ($n) {\n    sum @names-of-God[$n X- @names-of-God-adder[^(@names-of-God-adder.first: * > $n, :k)]]\n        Z× (flat (1, 1, -1, -1) xx *)\n}\n\nsay \"\\nsums:\";\nfor 23, 123, 1234, 12345 {\n    put $_, \"\\t\",  @names-of-God[$_];\n}\n\n```\n\nOutput:\n\n```\nrows:\n 1: [1]\n 2: [1 1]\n 3: [1 1 1]\n 4: [1 2 1 1]\n 5: [1 2 2 1 1]\n 6: [1 3 3 2 1 1]\n 7: [1 3 4 3 2 1 1]\n 8: [1 4 5 5 3 2 1 1]\n 9: [1 4 7 6 5 3 2 1 1]\n10: [1 5 8 9 7 5 3 2 1 1]\n11: [1 5 10 11 10 7 5 3 2 1 1]\n12: [1 6 12 15 13 11 7 5 3 2 1 1]\n13: [1 6 14 18 18 14 11 7 5 3 2 1 1]\n14: [1 7 16 23 23 20 15 11 7 5 3 2 1 1]\n15: [1 7 19 27 30 26 21 15 11 7 5 3 2 1 1]\n16: [1 8 21 34 37 35 28 22 15 11 7 5 3 2 1 1]\n17: [1 8 24 39 47 44 38 29 22 15 11 7 5 3 2 1 1]\n18: [1 9 27 47 57 58 49 40 30 22 15 11 7 5 3 2 1 1]\n19: [1 9 30 54 70 71 65 52 41 30 22 15 11 7 5 3 2 1 1]\n20: [1 10 33 64 84 90 82 70 54 42 30 22 15 11 7 5 3 2 1 1]\n21: [1 10 37 72 101 110 105 89 73 55 42 30 22 15 11 7 5 3 2 1 1]\n22: [1 11 40 84 119 136 131 116 94 75 56 42 30 22 15 11 7 5 3 2 1 1]\n23: [1 11 44 94 141 163 164 146 123 97 76 56 42 30 22 15 11 7 5 3 2 1 1]\n24: [1 12 48 108 164 199 201 186 157 128 99 77 56 42 30 22 15 11 7 5 3 2 1 1]\n25: [1 12 52 120 192 235 248 230 201 164 131 100 77 56 42 30 22 15 11 7 5 3 2 1 1]\n\nsums:\n23\t1255\n123\t2552338241\n1234\t156978797223733228787865722354959930\n12345\t69420357953926116819562977205209384460667673094671463620270321700806074195845953959951425306140971942519870679768681736\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay the complete lyrics for the song:     **99 Bottles of Beer on the Wall**.\n\nThe beer song\n\nThe lyrics follow this form:\n\n> :   :   :   99 bottles of beer on the wall\n>         :   99 bottles of beer\n>         :   Take one down, pass it around\n>         :   98 bottles of beer on the wall\n>\n> :   :   :   98 bottles of beer on the wall\n>         :   98 bottles of beer\n>         :   Take one down, pass it around\n>         :   97 bottles of beer on the wall\n\n... and so on, until reaching   **0**     (zero).\n\nGrammatical support for   *1 bottle of beer*   is optional.\n\nAs with any puzzle, try to do it in as creative/concise/comical a way\nas possible (simple, obvious solutions allowed, too).\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet\n\nSee also\n\n* http://99-bottles-of-beer.net/\n* Category:99\\_Bottles\\_of\\_Beer\n* Category:Programming language families\n* Wikipedia 99 bottles of beer"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### A Simple Way\n\n```\nmy $b = 99;\n\nrepeat while --$b {\n    say \"{b $b} on the wall\";\n    say \"{b $b}\";\n    say \"Take one down, pass it around\";\n    say \"{b $b-1} on the wall\";\n    say \"\";\n}\n\nsub b($b) {\n    \"$b bottle{'s' if $b != 1} of beer\";\n}\n```\n\n### A Clearer Way\n\nSimilar to \"A Simple Way\", but with proper variable and subroutine naming, declarator documentation, strongly-typed function definition, better code reuse, and external ternary logic.\n\n```\nfor 99...1 -> $bottles {\n    sing $bottles, :wall;\n    sing $bottles;\n    say  \"Take one down, pass it around\";\n    sing $bottles - 1, :wall;\n    say  \"\";\n}\n\n#| Prints a verse about a certain number of beers, possibly on a wall.\nsub sing(\n    Int $number, #= Number of bottles of beer.\n    Bool :$wall, #= Mention that the beers are on a wall?\n) {\n    my $quantity = $number == 0 ?? \"No more\"      !! $number;\n    my $plural   = $number == 1 ?? \"\"             !! \"s\";\n    my $location = $wall        ?? \" on the wall\" !! \"\";\n    say \"$quantity bottle$plural of beer$location\"\n}\n```\n\n### A More Extravagant Way\n\n**Works with**: Rakudo version 2015.09\n\n```\nmy @quantities = flat (99 ... 1), 'No more', 99;\nmy @bottles = flat 'bottles' xx 98, 'bottle', 'bottles' xx 2;\nmy @actions = flat 'Take one down, pass it around' xx 99,\n              'Go to the store, buy some more';\n\nfor @quantities Z @bottles Z @actions Z\n    @quantities[1 .. *] Z @bottles[1 .. *]\n    -> ($a, $b, $c, $d, $e) {\n    say \"$a $b of beer on the wall\";\n    say \"$a $b of beer\";\n    say $c;\n    say \"$d $e of beer on the wall\\n\";\n}\n```"}]}
{"messages": [{"role": "user", "content": "The A\\* search algorithm is an extension of Dijkstra's algorithm useful for finding the lowest cost path between two nodes (aka vertices) of a graph. The path may traverse any number of nodes connected by edges (aka arcs) with each edge having an associated cost. The algorithm uses a heuristic which associates an estimate of the lowest cost path from this node to the goal node, such that this estimate is never greater than the actual cost.\n\nThe algorithm should not assume that all edge costs are the same. It should be possible to start and finish on any node, including ones identified as a barrier in the task.\n\nTask\n\nConsider the problem of finding a route across the diagonal of a chess board-like 8x8 grid. The rows are numbered from 0 to 7. The columns are also numbered 0 to 7. The start position is (0, 0) and the end position is (7, 7). Movement is allow by one square in any direction including diagonals, similar to a king in chess. The standard movement cost is 1. To make things slightly harder, there is a barrier that occupy certain positions of the grid. Moving into any of the barrier positions has a cost of 100.\n\nThe barrier occupies the positions (2,4), (2,5), (2,6), (3,6), (4,6), (5,6), (5,5), (5,4), (5,3), (5,2), (4,2) and (3,2).\n\nA route with the lowest cost should be found using the A\\* search algorithm (there are multiple optimal solutions with the same total cost).\n\nPrint the optimal route in text format, as well as the total cost of the route.\n\nOptionally, draw the optimal route and the barrier positions.\n\nNote: using a heuristic score of zero is equivalent to Dijkstra's algorithm and that's kind of cheating/not really A\\*!\n\n*Extra Credit*\n\nUse this algorithm to solve an 8 puzzle. Each node of the input graph will represent an arrangement of the tiles. The nodes will be connected by 4 edges representing swapping the blank tile up, down, left, or right. The cost of each edge is 1. The heuristic will be the sum of the manhatten distance of each numbered tile from its goal position. An 8 puzzle graph will have 9!/2 (181,440) nodes. The 15 puzzle has over 10 trillion nodes. This algorithm may solve simple 15 puzzles (but there are not many of those).\n\nSee also\n\n* Wikipedia webpage:   A\\* search algorithm.\n* An introduction to: Breadth First Search |> Dijkstra’s Algorithm |> A\\*\n\nRelated tasks\n\n* 15 puzzle solver\n* Dijkstra's algorithm\n* Knapsack problem/0-1"}, {"role": "assistant", "content": "**Translation of**: Sidef\n\n```\n# 20200427 Raku programming solution\n\nclass AStarGraph {\n\n   has @.barriers =\n      <2 4>,<2 5>,<2 6>,<3 6>,<4 6>,<5 6>,<5 5>,<5 4>,<5 3>,<5 2>,<4 2>,<3 2>;\n\n   method heuristic(\\start, \\goal) {\n      my (\\D1,\\D2) = 1, 1;\n      my (\\dx,\\dy) = ( start.list »-« goal.list )».abs;\n      return  (D1 * (dx + dy)) + (D2 - 2*D1) * min dx, dy\n   }\n\n   method get_vertex_neighbours(\\pos) {\n      gather {\n         for <1 0>,<-1 0>,<0 1>,<0 -1>,<1 1>,<-1 1>,<1 -1>,<-1 -1> -> \\d {\n            my (\\x2,\\y2) = pos.list »+« d.list;\n            (x2 < 0 || x2 > 7 || y2 < 0 || y2 > 7) && next;\n            take x2, y2;\n         }\n      }\n   }\n\n   method move_cost(\\a,\\b) { (b ~~ any self.barriers) ?? 100 !! 1 }\n}\n\nsub AStarSearch(\\start, \\end, \\graph) {\n\n   my (%G,%F);\n\n   %G{start.Str} = 0;\n   %F{start.Str} = graph.heuristic(start, end);\n\n   my @closedVertices = [];\n   my @openVertices = [].push(start);\n   my %cameFrom;\n\n   while (@openVertices.Bool) {\n      my $current = Nil; my $currentFscore = Inf;\n\n      for @openVertices -> \\pos {\n         if (%F{pos.Str} < $currentFscore) {\n            $currentFscore = %F{pos.Str};\n            $current = pos\n         }\n      }\n\n      if $current ~~ end {\n         my @path = [].push($current);\n         while %cameFrom{$current.Str}:exists {\n            $current = %cameFrom{$current.Str};\n            @path.push($current)\n         }\n         return @path.reverse, %F{end.Str}\n      }\n\n      @openVertices .=  grep: * !eqv $current;\n      @closedVertices.push($current);\n\n      for (graph.get_vertex_neighbours($current)) -> \\neighbour {\n         next if neighbour ~~ any @closedVertices;\n         my \\candidateG = %G{$current.Str}+graph.move_cost($current,neighbour);\n\n         if !(neighbour ~~ any @openVertices) {\n            @openVertices.push(neighbour)\n         } elsif (candidateG ≥ %G{neighbour.Str}) {\n            next\n         }\n\n         %cameFrom{neighbour.Str} = $current;\n         %G{neighbour.Str} = candidateG;\n         my \\H = graph.heuristic(neighbour, end);\n         %F{neighbour.Str} = %G{neighbour.Str} + H;\n      }\n   }\n   die \"A* failed to find a solution\"\n}\n\nmy \\graph = AStarGraph.new;\nmy (\\route, \\cost) = AStarSearch(<0 0>, <7 7>, graph);\n\nmy \\w = my \\h = 10;\n\nmy @grid = [ ['.' xx w ] xx h ];\nfor ^h -> \\y { @grid[y;0] = \"█\"; @grid[y;*-1] = \"█\" }\nfor ^w -> \\x { @grid[0;x] = \"█\"; @grid[*-1;x] = \"█\" }\n\nfor (graph.barriers) -> \\d { @grid[d[0]+1][d[1]+1] = \"█\" }\nfor @(route)         -> \\d { @grid[d[0]+1][d[1]+1] = \"x\" }\n\n.join.say for @grid ;\n\nsay \"Path cost : \", cost, \" and route : \", route;\n\n```\n\nOutput:\n\n```\n██████████\n\n█x.......█\n█.x......█\n█..x.███.█\n█.x█...█.█\n█.x█...█.█\n█.x█████.█\n█..xxxxx.█\n█.......x█\n██████████\n\nPath cost : 11 and route : ((0 0) (1 1) (2 2) (3 1) (4 1) (5 1) (6 2) (6 3) (6 4) (6 5) (6 6) (7 7))\n```"}]}
{"messages": [{"role": "user", "content": "**A+B**   ─── a classic problem in programming contests,   it's given so contestants can gain familiarity with the online judging system being used.\n\nTask\n\nGiven two integers,   **A** and **B**.\n\nTheir sum needs to be calculated.\n\nInput data\n\nTwo integers are written in the input stream, separated by space(s):\n\n:   (\n    −\n    1000\n    ≤\n    A\n    ,\n    B\n    ≤\n    +\n    1000\n    )\n    {\\displaystyle {\\displaystyle (-1000\\leq A,B\\leq +1000)}}\n\nOutput data\n\nThe required output is one integer:   the sum of **A** and **B**.\n\nExample\n\n:   :   | input | output |\n        | --- | --- |\n        | 2 2 | 4 |\n        | 3 2 | 5 |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015.12\n\nShort version with very little \"line noise\":\n\n```\nget.words.sum.say;\n```\n\nReduction operator `[+]`, and `say` as a function:\n\n```\nsay [+] get.words;\n```\n\nLong version:\n\n```\nmy ($a, $b) = $*IN.get.split(\" \");\nsay $a + $b;\n```"}]}
{"messages": [{"role": "user", "content": "The use of   abbreviations   (also sometimes called synonyms, nicknames, AKAs, or aliases)   can be an\n  \neasy way to add flexibility when specifying or using commands, sub─commands, options, etc.\n\nIt would make a list of words easier to maintain   (as words are added, changed, and/or deleted)   if\nthe minimum abbreviation length of that list could be automatically (programmatically) determined.\n\nFor this task, use the list (below) of the days-of-the-week names that are expressed in about a hundred languages   (note that there is a blank line in the list).\n\n```\nSunday Monday Tuesday Wednesday Thursday Friday Saturday\nSondag Maandag Dinsdag Woensdag Donderdag Vrydag Saterdag\nE_djelë E_hënë E_martë E_mërkurë E_enjte E_premte E_shtunë\nEhud Segno Maksegno Erob Hamus Arbe Kedame\nAl_Ahad Al_Ithinin Al_Tholatha'a Al_Arbia'a Al_Kamis Al_Gomia'a Al_Sabit\nGuiragui Yergou_shapti Yerek_shapti Tchorek_shapti Hink_shapti Ourpat Shapat\ndomingu llunes martes miércoles xueves vienres sábadu\nBazar_gÜnÜ Birinci_gÜn Çkinci_gÜn ÜçÜncÜ_gÜn DÖrdÜncÜ_gÜn Bes,inci_gÜn Altòncò_gÜn\nIgande Astelehen Astearte Asteazken Ostegun Ostiral Larunbat\nRobi_bar Shom_bar Mongal_bar Budhh_bar BRihashpati_bar Shukro_bar Shoni_bar\nNedjelja Ponedeljak Utorak Srijeda Cxetvrtak Petak Subota\nDisul Dilun Dimeurzh Dimerc'her Diriaou Digwener Disadorn\nnedelia ponedelnik vtornik sriada chetvartak petak sabota\nsing_kei_yaht sing_kei_yat sing_kei_yee sing_kei_saam sing_kei_sie sing_kei_ng sing_kei_luk\nDiumenge Dilluns Dimarts Dimecres Dijous Divendres Dissabte\nDzeenkk-eh Dzeehn_kk-ehreh Dzeehn_kk-ehreh_nah_kay_dzeeneh Tah_neesee_dzeehn_neh Deehn_ghee_dzee-neh Tl-oowey_tts-el_dehlee Dzeentt-ahzee\ndy_Sul dy_Lun dy_Meurth dy_Mergher dy_You dy_Gwener dy_Sadorn\nDimanch Lendi Madi Mèkredi Jedi Vandredi Samdi\nnedjelja ponedjeljak utorak srijeda cxetvrtak petak subota\nnede^le ponde^lí úterÿ str^eda c^tvrtek pátek sobota\nSondee Mondee Tiisiday Walansedee TOOsedee Feraadee Satadee\ns0ndag mandag tirsdag onsdag torsdag fredag l0rdag\nzondag maandag dinsdag woensdag donderdag vrijdag zaterdag\nDiman^co Lundo Mardo Merkredo ^Jaùdo Vendredo Sabato\npÜhapäev esmaspäev teisipäev kolmapäev neljapäev reede laupäev\n\nDiu_prima Diu_sequima Diu_tritima Diu_quartima Diu_quintima Diu_sextima Diu_sabbata\nsunnudagur mánadagur tÿsdaguy mikudagur hósdagur friggjadagur leygardagur\nYek_Sham'beh Do_Sham'beh Seh_Sham'beh Cha'har_Sham'beh Panj_Sham'beh Jom'eh Sham'beh\nsunnuntai maanantai tiistai keskiviiko torsktai perjantai lauantai\ndimanche lundi mardi mercredi jeudi vendredi samedi\nSnein Moandei Tiisdei Woansdei Tonersdei Freed Sneon\nDomingo Segunda_feira Martes Mércores Joves Venres Sábado\nk'vira orshabati samshabati otkhshabati khutshabati p'arask'evi shabati\nSonntag Montag Dienstag Mittwoch Donnerstag Freitag Samstag\nKiriaki' Defte'ra Tri'ti Teta'rti Pe'mpti Paraskebi' Sa'bato\nravivaar somvaar mangalvaar budhvaar guruvaar shukravaar shanivaar\npópule pó`akahi pó`alua pó`akolu pó`ahá pó`alima pó`aono\nYom_rishon Yom_sheni Yom_shlishi Yom_revi'i Yom_chamishi Yom_shishi Shabat\nravivara somavar mangalavar budhavara brahaspativar shukravara shanivar\nvasárnap hétfö kedd szerda csütörtök péntek szombat\nSunnudagur Mánudagur ╞riδjudagur Miδvikudagar Fimmtudagur FÖstudagur Laugardagur\nsundio lundio mardio merkurdio jovdio venerdio saturdio\nMinggu Senin Selasa Rabu Kamis Jumat Sabtu\nDominica Lunedi Martedi Mercuridi Jovedi Venerdi Sabbato\nDé_Domhnaigh Dé_Luain Dé_Máirt Dé_Ceadaoin Dé_ardaoin Dé_hAoine Dé_Sathairn\ndomenica lunedí martedí mercoledí giovedí venerdí sabato\nNichiyou_bi Getzuyou_bi Kayou_bi Suiyou_bi Mokuyou_bi Kin'you_bi Doyou_bi\nIl-yo-il Wol-yo-il Hwa-yo-il Su-yo-il Mok-yo-il Kum-yo-il To-yo-il\nDies_Dominica Dies_Lunæ Dies_Martis Dies_Mercurii Dies_Iovis Dies_Veneris Dies_Saturni\nsve-tdien pirmdien otrdien tresvdien ceturtdien piektdien sestdien\nSekmadienis Pirmadienis Antradienis Trec^iadienis Ketvirtadienis Penktadienis S^es^tadienis\nWangu Kazooba Walumbe Mukasa Kiwanuka Nnagawonye Wamunyi\nxing-_qi-_rì xing-_qi-_yi-. xing-_qi-_èr xing-_qi-_san-. xing-_qi-_sì xing-_qi-_wuv. xing-_qi-_liù\nJedoonee Jelune Jemayrt Jecrean Jardaim Jeheiney Jesam\nJabot Manre Juje Wonje Taije Balaire Jarere\ngeminrongo minòmishi mártes mièrkoles misheushi bèrnashi mishábaro\nAhad Isnin Selasa Rabu Khamis Jumaat Sabtu\nsφndag mandag tirsdag onsdag torsdag fredag lφrdag\nlo_dimenge lo_diluns lo_dimarç lo_dimèrcres lo_dijòus lo_divendres lo_dissabte\ndjadomingo djaluna djamars djarason djaweps djabièrna djasabra\nNiedziela Poniedzial/ek Wtorek S,roda Czwartek Pia,tek Sobota\nDomingo segunda-feire terça-feire quarta-feire quinta-feire sexta-feira såbado\nDomingo Lunes martes Miercoles Jueves Viernes Sabado\nDuminicª Luni Mart'i Miercuri Joi Vineri Sâmbªtª\nvoskresenie ponedelnik vtornik sreda chetverg pyatnitsa subbota\nSunday Di-luain Di-màirt Di-ciadain Di-ardaoin Di-haoine Di-sathurne\nnedjelja ponedjeljak utorak sreda cxetvrtak petak subota\nSontaha Mmantaha Labobedi Laboraro Labone Labohlano Moqebelo\nIridha- Sandhudha- Anga.haruwa-dha- Badha-dha- Brahaspa.thindha- Sikura-dha- Sena.sura-dha-\nnedel^a pondelok utorok streda s^tvrtok piatok sobota\nNedelja Ponedeljek Torek Sreda Cxetrtek Petek Sobota\ndomingo lunes martes miércoles jueves viernes sábado\nsonde mundey tude-wroko dride-wroko fode-wroko freyda Saturday\nJumapili Jumatatu Jumanne Jumatano Alhamisi Ijumaa Jumamosi\nsöndag måndag tisdag onsdag torsdag fredag lordag\nLinggo Lunes Martes Miyerkoles Huwebes Biyernes Sabado\nLé-pài-jít Pài-it Pài-jï Pài-sañ Pài-sì Pài-gÖ. Pài-lák\nwan-ar-tit wan-tjan wan-ang-kaan wan-phoet wan-pha-ru-hat-sa-boh-die wan-sook wan-sao\nTshipi Mosupologo Labobedi Laboraro Labone Labotlhano Matlhatso\nPazar Pazartesi Sali Çar,samba Per,sembe Cuma Cumartesi\nnedilya ponedilok vivtorok sereda chetver pyatnytsya subota\nChu?_Nhâ.t Thú*_Hai Thú*_Ba Thú*_Tu* Thú*_Na'm Thú*_Sáu Thú*_Ba?y\ndydd_Sul dyds_Llun dydd_Mawrth dyds_Mercher dydd_Iau dydd_Gwener dyds_Sadwrn\nDibeer Altine Talaata Allarba Al_xebes Aljuma Gaaw\niCawa uMvulo uLwesibini uLwesithathu uLuwesine uLwesihlanu uMgqibelo\nzuntik montik dinstik mitvokh donershtik fraytik shabes\niSonto uMsombuluko uLwesibili uLwesithathu uLwesine uLwesihlanu uMgqibelo\nDies_Dominica Dies_Lunæ Dies_Martis Dies_Mercurii Dies_Iovis Dies_Veneris Dies_Saturni\nBazar_gÜnÜ Bazar_ærtæsi Çærs,ænbæ_axs,amò Çærs,ænbæ_gÜnÜ CÜmæ_axs,amò CÜmæ_gÜnÜ CÜmæ_Senbæ\nSun Moon Mars Mercury Jove Venus Saturn\nzondag maandag dinsdag woensdag donderdag vrijdag zaterdag\nKoseEraa GyoOraa BenEraa Kuoraa YOwaaraa FeEraa Memenaa\nSonntag Montag Dienstag Mittwoch Donnerstag Freitag Sonnabend\nDomingo Luns Terza_feira Corta_feira Xoves Venres Sábado\nDies_Solis Dies_Lunae Dies_Martis Dies_Mercurii Dies_Iovis Dies_Veneris Dies_Sabbatum\nxing-_qi-_tiàn xing-_qi-_yi-. xing-_qi-_èr xing-_qi-_san-. xing-_qi-_sì xing-_qi-_wuv. xing-_qi-_liù\ndjadomingu djaluna djamars djarason djaweps djabièrnè djasabra\nKillachau Atichau Quoyllurchau Illapachau Chaskachau Kuychichau Intichau\n\n```\n\n*Caveat:   The list (above) most surely contains errors (or, at the least, differences) of what the actual (or true) names for the days-of-the-week.*\n\nTo make this Rosetta Code task page as small as possible, if processing the complete list, read the days-of-the-week from a file (that is created from the above list).\n\nNotes concerning the above list of words\n\n:   :   * each line has a list of days-of-the-week for a language, separated by at least one blank\n        * the words on each line happen to be in order, from Sunday ──► Saturday\n        * most lines have words in mixed case and some have all manner of accented words and other characters\n        * some words were translated to the nearest character that was available to *code page*   **437**\n        * the characters in the words are not restricted except that they may not have imbedded blanks\n        * for this example, the use of an underscore (**\\_**) was used to indicate a blank in a word\n\nTask\n:   :   * The list of words   (days of the week)   needn't be verified/validated.\n        * Write a function to find the (numeric) minimum length abbreviation for each line that would make abbreviations unique.\n        * A blank line   (or a null line)   should return a null string.\n        * Process and show the output for at least the first **five** lines of the file.\n        * Show all output here.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.08\n\nSaving the \"Days of Week, Also Known As\" table to a local file DoWAKA.txt. Lines that have duplicate day names will get ∞ as the minimum number of characters, as there is no amount of characters that can be entered to distinguish the days uniquely. It is somewhat unclear as to what is meant by \"return a null string\". I have chosen to return Nil.\n\nNote that this is using a previous version of the date file that has erroneous duplicate day names (see line 90). Since the effort was already expended to catch such problems, it may as well be demonstrated.\n\n```\nsub auto-abbreviate ( Str $string ) {\n    return Nil unless my @words = $string.words;\n    return $_ if @words».substr(0, $_).Set == @words for 1 .. @words».chars.max;\n    return '∞';\n}\n\n# Testing\n say ++$, ') ', .&auto-abbreviate, '  ', $_ for './DoWAKA.txt'.IO.lines;\n\n```\n\nOutput:\n\n```\n1) 2  Sunday Monday Tuesday Wednesday Thursday Friday Saturday\n2) 2  Sondag Maandag Dinsdag Woensdag Donderdag Vrydag Saterdag\n3) 4  E_djelë E_hënë E_martë E_mërkurë E_enjte E_premte E_shtunë\n4) 2  Ehud Segno Maksegno Erob Hamus Arbe Kedame\n5) 5  Al_Ahad Al_Ithinin Al_Tholatha'a Al_Arbia'a Al_Kamis Al_Gomia'a Al_Sabit\n6) 4  Guiragui Yergou_shapti Yerek_shapti Tchorek_shapti Hink_shapti Ourpat Shapat\n7) 2  domingu llunes martes miércoles xueves vienres sábadu\n8) 2  Bazar_gÜnÜ Birinci_gÜn Çkinci_gÜn ÜçÜncÜ_gÜn DÖrdÜncÜ_gÜn Bes,inci_gÜn Altòncò_gÜn\n9) 6  Igande Astelehen Astearte Asteazken Ostegun Ostiral Larunbat\n10) 4  Robi_bar Shom_bar Mongal_bar Budhh_bar BRihashpati_bar Shukro_bar Shoni_bar\n11) 2  Nedjelja Ponedeljak Utorak Srijeda Cxetvrtak Petak Subota\n12) 5  Disul Dilun Dimeurzh Dimerc'her Diriaou Digwener Disadorn\n13) 2  nedelia ponedelnik vtornik sriada chetvartak petak sabota\n14) 13  sing_kei_yath sing_kei_yat sing_kei_yee sing_kei_saam sing_kei_sie sing_kei_ng sing_kei_luk\n15) 4  Diumenge Dilluns Dimarts Dimecres Dijous Divendres Dissabte\n16) 16  Dzeenkk-eh Dzeehn_kk-ehreh Dzeehn_kk-ehreh_nah_kay_dzeeneh Tah_neesee_dzeehn_neh Deehn_ghee_dzee-neh Tl-oowey_tts-el_dehlee Dzeentt-ahzee\n17) 6  dy_Sul dy_Lun dy_Meurth dy_Mergher dy_You dy_Gwener dy_Sadorn\n18) 2  Dimanch Lendi Madi Mèkredi Jedi Vandredi Samdi\n19) 2  nedjelja ponedjeljak utorak srijeda cxetvrtak petak subota\n20) 2  nede^le ponde^lí úterÿ str^eda c^tvrtek pátek sobota\n21) 2  Sondee Mondee Tiisiday Walansedee TOOsedee Feraadee Satadee\n22) 2  s0ndag mandag tirsdag onsdag torsdag fredag l0rdag\n23) 2  zondag maandag dinsdag woensdag donderdag vrijdag zaterdag\n24) 2  Diman^co Lundo Mardo Merkredo ^Jaùdo Vendredo Sabato\n25) 1  pÜhapäev esmaspäev teisipäev kolmapäev neljapäev reede laupäev\n26) Nil  \n27) 7  Diu_prima Diu_sequima Diu_tritima Diu_quartima Diu_quintima Diu_sextima Diu_sabbata\n28) 2  sunnudagur mánadagur tÿsdaguy mikudagur hósdagur friggjadagur leygardagur\n29) 2  Yek_Sham'beh Do_Sham'beh Seh_Sham'beh Cha'har_Sham'beh Panj_Sham'beh Jom'eh Sham'beh\n30) 2  sunnuntai maanantai tiistai keskiviiko torsktai perjantai lauantai\n31) 2  dimanche lundi mardi mercredi jeudi vendredi samedi\n32) 4  Snein Moandei Tiisdei Woansdei Tonersdei Freed Sneon\n33) 2  Domingo Segunda_feira Martes Mércores Joves Venres Sábado\n34) 2  k'vira orshabati samshabati otkhshabati khutshabati p'arask'evi shabati\n35) 2  Sonntag Montag Dienstag Mittwoch Donnerstag Freitag Samstag\n36) 2  Kiriaki' Defte'ra Tri'ti Teta'rti Pe'mpti Paraskebi' Sa'bato\n37) 3  ravivaar somvaar mangalvaar budhvaar guruvaar shukravaar shanivaar\n38) 6  pópule pó`akahi pó`alua pó`akolu pó`ahá pó`alima pó`aono\n39) 7  Yom_rishon Yom_sheni Yom_shlishi Yom_revi'i Yom_chamishi Yom_shishi Shabat\n40) 3  ravivara somavar mangalavar budhavara brahaspativar shukravara shanivar\n41) 3  vasárnap hétfö kedd szerda csütörtök péntek szombat\n42) 2  Sunnudagur Mánudagur ╞riδjudagur Miδvikudagar Fimmtudagur FÖstudagur Laugardagur\n43) 2  sundio lundio mardio merkurdio jovdio venerdio saturdio\n44) 3  Minggu Senin Selasa Rabu Kamis Jumat Sabtu\n45) 2  Dominica Lunedi Martedi Mercuridi Jovedi Venerdi Sabbato\n46) 4  Dé_Domhnaigh Dé_Luain Dé_Máirt Dé_Ceadaoin Dé_ardaoin Dé_hAoine Dé_Sathairn\n47) 2  domenica lunedí martedí mercoledí giovedí venerdí sabato\n48) 2  Nichiyou_bi Getzuyou_bi Kayou_bi Suiyou_bi Mokuyou_bi Kin'you_bi Doyou_bi\n49) 1  Il-yo-il Wol-yo-il Hwa-yo-il Su-yo-il Mok-yo-il Kum-yo-il To-yo-il\n50) 7  Dies_Dominica Dies_Lunæ Dies_Martis Dies_Mercurii Dies_Iovis Dies_Veneris Dies_Saturni\n51) 3  sve-tdien pirmdien otrdien tresvdien ceturtdien piektdien sestdien\n52) 2  Sekmadienis Pirmadienis Antradienis Trec^iadienis Ketvirtadienis Penktadienis S^es^tadienis\n53) 3  Wangu Kazooba Walumbe Mukasa Kiwanuka Nnagawonye Wamunyi\n54) 12  xing-_qi-_rì xing-_qi-_yi-. xing-_qi-_èr xing-_qi-_san-. xing-_qi-_sì xing-_qi-_wuv. xing-_qi-_liù\n55) 3  Jedoonee Jelune Jemayrt Jecrean Jardaim Jeheiney Jesam\n56) 3  Jabot Manre Juje Wonje Taije Balaire Jarere\n57) 5  geminrongo minòmishi mártes mièrkoles misheushi bèrnashi mishábaro\n58) 2  Ahad Isnin Selasa Rabu Khamis Jumaat Sabtu\n59) 2  sφndag mandag tirsdag onsdag torsdag fredag lφrdag\n60) 7  lo_dimenge lo_diluns lo_dimarç lo_dimèrcres lo_dijòus lo_divendres lo_dissabte\n61) 4  djadomingo djaluna djamars djarason djaweps djabièrna djasabra\n62) 2  Niedziela Poniedzial/ek Wtorek S,roda Czwartek Pia,tek Sobota\n63) 3  Domingo segunda-feire terça-feire quarta-feire quinta-feire sexta-feira såbado\n64) 1  Domingo Lunes martes Miercoles Jueves Viernes Sabado\n65) 2  Duminicª Luni Mart'i Miercuri Joi Vineri Sâmbªtª\n66) 2  voskresenie ponedelnik vtornik sreda chetverg pyatnitsa subbota\n67) 4  Sunday Di-luain Di-màirt Di-ciadain Di-ardaoin Di-haoine Di-sathurne\n68) 2  nedjelja ponedjeljak utorak sreda cxetvrtak petak subota\n69) 5  Sontaha Mmantaha Labobedi Laboraro Labone Labohlano Moqebelo\n70) 2  Iridha- Sandhudha- Anga.haruwa-dha- Badha-dha- Brahaspa.thindha- Sikura-dha- Sena.sura-dha-\n71) 2  nedel^a pondelok utorok streda s^tvrtok piatok sobota\n72) 2  Nedelja Ponedeljek Torek Sreda Cxetrtek Petek Sobota\n73) 2  domingo lunes martes miércoles jueves viernes sábado\n74) 2  sonde mundey tude-wroko dride-wroko fode-wroko freyda Saturday\n75) 7  Jumapili Jumatatu Jumanne Jumatano Alhamisi Ijumaa Jumamosi\n76) 2  söndag måndag tisdag onsdag torsdag fredag lordag\n77) 2  Linggo Lunes Martes Miyerkoles Huwebes Biyernes Sabado\n78) 6  Lé-pài-jít Pài-it Pài-jï Pài-sañ Pài-sì Pài-gÖ. Pài-lák\n79) 7  wan-ar-tit wan-tjan wan-ang-kaan wan-phoet wan-pha-ru-hat-sa-boh-die wan-sook wan-sao\n80) 5  Tshipi Mosupologo Labobedi Laboraro Labone Labotlhano Matlhatso\n81) 6  Pazar Pazartesi Sali Çar,samba Per,sembe Cuma Cumartesi\n82) 2  nedilya ponedilok vivtorok sereda chetver pyatnytsya subota\n83) 8  Chu?_Nhâ.t Thú*_Hai Thú*_Ba Thú*_Tu* Thú*_Na'm Thú*_Sáu Thú*_Ba?y\n84) 6  dydd_Sul dyds_Llun dydd_Mawrth dyds_Mercher dydd_Iau dydd_Gwener dyds_Sadwrn\n85) 3  Dibeer Altine Talaata Allarba Al_xebes Aljuma Gaaw\n86) 7  iCawa uMvulo uLwesibini uLwesithathu uLuwesine uLwesihlanu uMgqibelo\n87) 2  zuntik montik dinstik mitvokh donershtik fraytik shabes\n88) 7  iSonto uMsombuluko uLwesibili uLwesithathu uLwesine uLwesihlanu uMgqibelo\n89) 7  Dies_Dominica Dies_Lunæ Dies_Martis Dies_Mercurii Dies_Iovis Dies_Veneris Dies_Saturni\n90) ∞  Bazar_gÜnÜ Bazar_ærtæsi Çærs,ænbæ_axs,amò Çærs,ænbæ_gÜnÜ CÜmæ_axs,amò CÜmæ_gÜnÜ CÜmæ_gÜnÜ\n91) 2  Sun Moon Mars Mercury Jove Venus Saturn\n92) 2  zondag maandag dinsdag woensdag donderdag vrijdag zaterdag\n93) 2  KoseEraa GyoOraa BenEraa Kuoraa YOwaaraa FeEraa Memenaa\n94) 5  Sonntag Montag Dienstag Mittwoch Donnerstag Freitag Sonnabend\n95) 1  Domingo Luns Terza_feira Corta_feira Xoves Venres Sábado\n96) 7  Dies_Solis Dies_Lunae Dies_Martis Dies_Mercurii Dies_Iovis Dies_Veneris Dies_Sabbatum\n97) 12  xing-_qi-_tiàn xing-_qi-_yi-. xing-_qi-_èr xing-_qi-_san-. xing-_qi-_sì xing-_qi-_wuv. xing-_qi-_liù\n98) 4  djadomingu djaluna djamars djarason djaweps djabièrnè djasabra\n99) 2  Killachau Atichau Quoyllurchau Illapachau Chaskachau Kuychichau Intichau\n\n```"}]}
{"messages": [{"role": "user", "content": "This task is an easier (to code) variant of the Rosetta Code task:    Abbreviations, simple.\n\nFor this task, the following   *command table*   will be used:\n\n```\n   Add ALTer  BAckup Bottom  CAppend Change SCHANGE  CInsert CLAst COMPress COpy\n   COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find\n   NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput\n   Join SPlit SPLTJOIN  LOAD  Locate CLocate  LOWercase UPPercase  LPrefix MACRO\n   MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD  Query  QUIT\n   READ  RECover REFRESH RENum REPeat  Replace CReplace  RESet  RESTore  RGTLEFT\n   RIght LEft  SAVE  SET SHift SI  SORT  SOS  STAck STATus  TOP TRAnsfer Type Up\n\n```\n\nNotes concerning the above   *command table*:\n\n:   :   * it can be thought of as one long literal string   (with blanks at end-of-lines)\n        * it may have superfluous blanks\n        * it may be in any case (lower/upper/mixed)\n        * the order of the words in the   *command table*   must be preserved as shown\n        * the user input(s) may be in any case (upper/lower/mixed)\n        * commands will be restricted to the Latin alphabet   (A ──► Z,   a ──► z)\n        * A valid abbreviation is a word that has:\n\n        :   * at least the minimum length of the number of capital letters of the word in the *command table*\n            * compares equal (regardless of case) to the leading characters of the word in the *command table*\n            * a length not longer than the word in the *command table*\n\n            :   * **ALT**,   **aLt**,   **ALTE**,   and   **ALTER**   are all abbreviations of   **ALTer**\n                * **AL**,   **ALF**,   **ALTERS**,   **TER**,   and   **A**   aren't valid abbreviations of   **ALTer**\n                * The number of capital letters in   **ALTer**   indicates that any abbreviation for   **ALTer**   must be at least three letters\n                * Any word longer than five characters can't be an abbreviation for   **ALTer**\n                * **o**,   **ov**,   **oVe**,   **over**,   **overL**,   **overla**   are all acceptable abbreviations for   **Overlay**\n\n        * if there isn't any lowercase letters in the word in the *command table*,   then there isn't an abbreviation permitted\n\nTask\n:   :   * The command table needn't be verified/validated.\n        * Write a function to validate if the user \"words\"   (given as input)   are valid   (in the *command table*).\n        * If the word   is   valid,   then return the full uppercase version of that \"word\".\n        * If the word isn't valid,   then return the lowercase string:    **\\*error\\***        (7 characters).\n        * A blank input   (or a null input)   should return a null string.\n        * Show all output here.\n\nAn example test case to be used for this task\n\nFor a user string of:\n\n```\n riG   rePEAT copies  put mo   rest    types   fup.    6       poweRin\n\n```\n\nthe computer program should return the string:\n\n```\n RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.08\n\nDemonstrate that inputting an empty string returns an empty string in addition to the required test input.\n\n```\n<\nAdd ALTer  BAckup Bottom  CAppend Change SCHANGE  CInsert CLAst COMPress COpy\nCOUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find\nNFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput\nJoin SPlit SPLTJOIN  LOAD  Locate CLocate  LOWercase UPPercase  LPrefix MACRO\nMErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD  Query  QUIT\nREAD  RECover REFRESH RENum REPeat  Replace CReplace  RESet  RESTore  RGTLEFT\nRIght LEft  SAVE  SET SHift SI  SORT  SOS  STAck STATus  TOP TRAnsfer Type Up\n> ~~ m:g/ ((<.:Lu>+) <.:Ll>*) /;\n\nmy %abr = '' => '', |$/.map: {\n    my $abbrv = .[0].Str.fc;\n    |map { $abbrv.substr( 0, $_ ) => $abbrv.uc },\n    .[0][0].Str.chars .. $abbrv.chars\n};\n\nsub abbr-easy ( $str ) { %abr{$str.trim.fc} // '*error*' }\n\n# Testing\nfor 'riG   rePEAT copies  put mo   rest    types   fup.    6       poweRin', '' -> $str {\n    put ' Input: ', $str;\n    put 'Output: ', join ' ', $str.words.map: &abbr-easy;\n}\n\n```\n\nOutput:\n\n```\n Input: riG   rePEAT copies  put mo   rest    types   fup.    6       poweRin\nOutput: RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT\n Input: \nOutput: \n```"}]}
{"messages": [{"role": "user", "content": "The use of   abbreviations   (also sometimes called synonyms, nicknames, AKAs, or aliases)   can be an\n  \neasy way to add flexibility when specifying or using commands, sub─commands, options, etc.\n\nFor this task, the following   *command table*   will be used:\n\n```\n   add 1  alter 3  backup 2  bottom 1  Cappend 2  change 1  Schange  Cinsert 2  Clast 3\n   compress 4 copy 2 count 3 Coverlay 3 cursor 3  delete 3 Cdelete 2  down 1  duplicate\n   3 xEdit 1 expand 3 extract 3  find 1 Nfind 2 Nfindup 6 NfUP 3 Cfind 2 findUP 3 fUP 2\n   forward 2  get  help 1 hexType 4  input 1 powerInput 3  join 1 split 2 spltJOIN load\n   locate 1 Clocate 2 lowerCase 3 upperCase 3 Lprefix 2  macro  merge 2 modify 3 move 2\n   msg  next 1 overlay 1 parse preserve 4 purge 3 put putD query 1 quit  read recover 3\n   refresh renum 3 repeat 3 replace 1 Creplace 2 reset 3 restore 4 rgtLEFT right 2 left\n   2  save  set  shift 2  si  sort  sos  stack 3 status 4 top  transfer 3  type 1  up 1\n\n```\n\nNotes concerning the above   *command table*:\n\n:   :   * it can be thought of as one long literal string   (with blanks at end-of-lines)\n        * it may have superfluous blanks\n        * it may be in any case (lower/upper/mixed)\n        * the order of the words in the   *command table*   must be preserved as shown\n        * the user input(s) may be in any case (upper/lower/mixed)\n        * commands will be restricted to the Latin alphabet   (A ──► Z,   a ──► z)\n        * a command is followed by an optional number, which indicates the minimum abbreviation\n        * A valid abbreviation is a word that has:\n\n        :   * at least the minimum length of the word's minimum number in the *command table*\n            * compares equal (regardless of case) to the leading characters of the word in the *command table*\n            * a length not longer than the word in the *command table*\n\n            :   * **ALT**,   **aLt**,   **ALTE**,   and   **ALTER**   are all abbreviations of   **ALTER 3**\n                * **AL**,   **ALF**,   **ALTERS**,   **TER**,   and   **A**   aren't valid abbreviations of   **ALTER 3**\n                * The   **3**   indicates that any abbreviation for   **ALTER**   must be at least three characters\n                * Any word longer than five characters can't be an abbreviation for   **ALTER**\n                * **o**,   **ov**,   **oVe**,   **over**,   **overL**,   **overla**   are all acceptable abbreviations for   **overlay 1**\n\n        * if there isn't a number after the command,   then there isn't an abbreviation permitted\n\nTask\n:   :   * The command table needn't be verified/validated.\n        * Write a function to validate if the user \"words\"   (given as input)   are valid   (in the *command table*).\n        * If the word   is   valid,   then return the full uppercase version of that \"word\".\n        * If the word isn't valid,   then return the lowercase string:    **\\*error\\***        (7 characters).\n        * A blank input   (or a null input)   should return a null string.\n        * Show all output here.\n\nAn example test case to be used for this task\n\nFor a user string of:\n\n```\n riG   rePEAT copies  put mo   rest    types   fup.    6       poweRin\n\n```\n\nthe computer program should return the string:\n\n```\n RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.08\n\nDemonstrate that inputting an empty string returns an empty string in addition to the required test input.\n\n```\n<\nadd 1  alter 3  backup 2  bottom 1  Cappend 2  change 1  Schange  Cinsert 2  Clast 3\ncompress 4 copy 2 count 3 Coverlay 3 cursor 3  delete 3 Cdelete 2  down 1  duplicate\n3 xEdit 1 expand 3 extract 3  find 1 Nfind 2 Nfindup 6 NfUP 3 Cfind 2 findUP 3 fUP 2\nforward 2  get  help 1 hexType 4  input 1 powerInput 3  join 1 split 2 spltJOIN load\nlocate 1 Clocate 2 lowerCase 3 upperCase 3 Lprefix 2  macro  merge 2 modify 3 move 2\nmsg  next 1 overlay 1 parse preserve 4 purge 3 put putD query 1 quit  read recover 3\nrefresh renum 3 repeat 3 replace 1 Creplace 2 reset 3 restore 4 rgtLEFT right 2 left\n2  save  set  shift 2  si  sort  sos  stack 3 status 4 top  transfer 3  type 1  up 1\n> ~~ m:g/ (<.alpha>+) \\s* (\\d*) /;\n\nmy %abr = '' => '', |$/.map: {\n    my $abbrv = .[0].Str.fc;\n    |map { $abbrv.substr( 0, $_ ) => $abbrv.uc },\n    +(.[1].Str || .[0].Str.chars) .. .[0].Str.chars;\n};\n\nsub abbr-simple ( $str ) { %abr{$str.trim.fc} // '*error*' }\n\n# Testing\nfor 'riG   rePEAT copies  put mo   rest    types   fup.    6       poweRin', '' -> $str {\n    put ' Input: ', $str;\n    put 'Output: ', join ' ', $str.words.map: &abbr-simple;\n}\n\n```\n\nOutput:\n\n```\n Input: riG   rePEAT copies  put mo   rest    types   fup.    6       poweRin\nOutput: RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT\n Input: \nOutput: \n```"}]}
{"messages": [{"role": "user", "content": "Taken from this video at the time stamp of 9:02\n\n**Task:**\n\nGet a string input and store it into a variable or something and compare the number of occurrences of the letters \"a\", \"b\" and \"c\".\nAll other characters MUST be ignored. If the \"a\"'s, \"b\"'s and \"c\"'s occur with exactly equal frequency, return true; otherwise return false."}, {"role": "assistant", "content": "I've elected to do 'or something' as specified in the task instructions. Rather than just feeding a few words in to check if there are equal counts of 'a', 'b', and 'c'; instead, reads in the words\\_alpha.txt word list and returns the words that have equal counts of 'a', 'b', and 'c', and, (to make things a little less verbose,) **have more than one of each**.\n\n```\n.say for 'words_alpha.txt'.IO.lines.race.grep({+(my \\b = .comb.Bag)<a> > 1 and [==] b<a b c>}) X~ \" True\";\n\n```\n\nOutput:\n\n```\nabboccato True\nbambocciade True\nbeccabunga True\nblackback True\nbombacaceous True\nbrachiocubital True\nbuccolabial True\ncabbalistic True\nsubbrachycephaly True\nsubcarbonaceous True\n\n```"}]}
{"messages": [{"role": "user", "content": "Write a routine (function, subroutine, procedure, whatever it may be called in your language,) that when given a set of three letters, (a, b, c) for instance, will identify words that contain each of those letters, in differing amounts, and where each count differs from another by exactly 1. Ignore any characters that are not in the given search group.\n\nFor example: using the letters (a, b, c) the \"word\" 'abbccc' would be valid (1(a), 2(b) & 3(c)), as would 'acodablaccab' (2(b), 3(c) & 4(a)).\n\nDo not hard code the letters to search for. Do not create three different single purpose search routines. Instead, create a generic routine that uses a given set of letters as its search criteria. Include some mechanism to limit the minimum count for the least common letter.\n\nYou may assume that the words are all lower case, or may choose to regularize the case of the words. In either case assume upper and lower case are the same. (The test files contain all and only lower case.)\n\nTask\n\nWrite a general purpose routine to identify incremental letter count words following the above description.\n\nUsing the unixdict.txt from http://wiki.puzzlers.org, find and display the words that are identified as incremental count words, or <none> if no words are found that match.\n\n:   * Search for words containing (a b c) with a minimum count of 1\n    * Search for words containing (t h e) with a minimum count of 1\n    * Search for words containing (c i o) with a minimum count of 2\n\nShow the output here, on this page.\n\nStretch\n\nUse the same routine to search the words\\_alpha.txt file from https://github.com/dwyl/english-words using the same letter groups, but with a minimum 1 higher.\n\n:   * Search for words containing (a b c) with a minimum count of 2\n    * Search for words containing (t h e) with a minimum count of 2\n    * Search for words containing (c i o) with a minimum count of 3\n\nRelated\n\nABC correlation"}, {"role": "assistant", "content": "```\nsay \"\\nUsing \", my $dict = 'unixdict.txt';\nmy @tests = <a b c>, 1, <t h e>, 1, <c i o>, 2;\nfilter $dict.IO.words;\n\nsay \"\\n\\nUsing \", $dict = 'words_alpha.txt';\n@tests[1,3,5]».++;\nfilter $dict.IO.words;\n\nsub filter (@words) {\n    for @tests -> ($a, $b, $c), $min {\n        say \"\\nLetters: ($a $b $c) -- Minimum count $min\\n\",\n          @words.race.grep(&incremental).sort.join(\"\\n\") || '<none>';\n\n        sub incremental ($word) {\n            my @v = $word.comb.Bag{$a,$b,$c}.values.sort;\n            (@v[0] >= $min) && (@v[0]+1 == @v[1]) && (@v[0]+2 == @v[2])\n        }\n    }\n}\n\n```\n\nOutput:\n\n```\nUsing unixdict.txt\n\nLetters: (a b c) -- Minimum count 1\nbaccarat\ncanvasback\nsabbatical\n\nLetters: (t h e) -- Minimum count 1\naesthete\nafterthought\nauthenticate\nbethlehem\ncheesecloth\ndiethylstilbestrol\neratosthenes\nheathenish\nletterhead\nliechtenstein\nmephistopheles\nnineteenth\northophosphate\nseventieth\nsweetheart\nteethe\nteethed\nthereafter\ntheretofore\nthirtieth\ntriphenylphosphine\ntwentieth\nwestchester\nwholehearted\n\nLetters: (c i o) -- Minimum count 2\nsocioeconomic\n\n\nUsing words_alpha.txt\n\nLetters: (a b c) -- Minimum count 2\n<none>\n\nLetters: (t h e) -- Minimum count 2\ndemethylchlortetracycline\ndichlorodiphenyltrichloroethane\nhyperthermesthesia\ntetrachloroethylene\nthermohyperesthesia\ntrinitrophenylmethylnitramine\n\nLetters: (c i o) -- Minimum count 3\nscleroticochorioiditis\n\n```"}]}
{"messages": [{"role": "user", "content": "You are given a collection of ABC blocks   (maybe like the ones you had when you were a kid).\n\nThere are twenty blocks with two letters on each block.\n\nA complete alphabet is guaranteed amongst all sides of the blocks.\n\nThe sample collection of blocks:\n\n```\n (B O)\n (X K)\n (D Q)\n (C P)\n (N A)\n (G T)\n (R E)\n (T G)\n (Q D)\n (F S)\n (J W)\n (H U)\n (V I)\n (A N)\n (O B)\n (E R)\n (F S)\n (L Y)\n (P C)\n (Z M)\n\n```\n\nTask\n\nWrite a function that takes a string (word) and determines whether the word can be spelled with the given collection of blocks.\n\nThe rules are simple:\n\n:   :   1. Once a letter on a block is used that block cannot be used again\n        2. The function should be case-insensitive\n        3. Show the output on this page for the following 7 words in the following example\n\nExample\n\n```\n    >>> can_make_word(\"A\")\n    True\n    >>> can_make_word(\"BARK\")\n    True\n    >>> can_make_word(\"BOOK\")\n    False\n    >>> can_make_word(\"TREAT\")\n    True\n    >>> can_make_word(\"COMMON\")\n    False\n    >>> can_make_word(\"SQUAD\")\n    True\n    >>> can_make_word(\"CONFUSE\")\n    True\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 6.0.c\n\nBlocks are stored as precompiled regexes. We do an initial pass on the blockset to include in the list only those regexes that match somewhere in the current word. Conveniently, regexes scan the word for us.\n\n```\nmulti can-spell-word(Str $word, @blocks) {\n    my @regex = @blocks.map({ my @c = .comb; rx/<@c>/ }).grep: { .ACCEPTS($word.uc) }\n    can-spell-word $word.uc.comb.list, @regex;\n}\n \nmulti can-spell-word([$head,*@tail], @regex) {\n    for @regex -> $re {\n        if $head ~~ $re {\n            return True unless @tail;\n            return False if @regex == 1;\n            return True if can-spell-word @tail, list @regex.grep: * !=== $re;\n        }\n    }\n    False;\n}\n \nmy @b = <BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM>;\n \nfor <A BaRK BOoK tREaT COmMOn SqUAD CoNfuSE> {\n    say \"$_     &can-spell-word($_, @b)\";\n}\n```\n\nOutput:\n\n```\nA\tTrue\nBaRK\tTrue\nBOoK\tFalse\ntREaT\tTrue\nCOmMOn\tFalse\nSqUAD\tTrue\nCoNfuSE\tTrue\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nA word is an   *ABC word*   if the letters  \"**a**\",  \"**b**\"  and  \"**c**\"  appear in the word in alphabetical order.\n\nIf any or all of these letters occur more than once in a word, then only the first occurrence of each letter should be used to determine whether a word is an  *ABC word*  or not.\n\nTask\n\nShow here   (on this page)   every  *ABC word*  in unixdict.txt.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nput display 'unixdict.txt'.IO.words».fc.grep({ (.index('a')//next) < (.index('b')//next) < (.index('c')//next) }),\n     :11cols, :fmt('%-12s');\n\nsub display ($list, :$cols = 10, :$fmt = '%6d', :$title = \"{+$list} matching:\\n\" )   {\n    cache $list;\n    $title ~ $list.batch($cols)».fmt($fmt).join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\n55 matching:\naback        abacus       abc          abdicate     abduct       abeyance     abject       abreact      abscess      abscissa     abscissae   \nabsence      abstract     abstracter   abstractor   adiabatic    aerobacter   aerobic      albacore     alberich     albrecht     algebraic   \nalphabetic   ambiance     ambuscade    aminobenzoic anaerobic    arabic       athabascan   auerbach     diabetic     diabolic     drawback    \nfabric       fabricate    flashback    halfback     iambic       lampblack    leatherback  metabolic    nabisco      paperback    parabolic   \nplayback     prefabricate quarterback  razorback    roadblock    sabbatical   snapback     strabismic   syllabic     tabernacle   tablecloth \n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Abelian sandpile model. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nImplement the **Abelian sandpile model** also known as **Bak–Tang–Wiesenfeld model**. Its history, mathematical definition and properties can be found under its wikipedia article.\n\nThe task requires the creation of a 2D grid of arbitrary size on which \"piles of sand\" can be placed. Any \"pile\" that has 4 or more sand particles on it *collapses*, resulting in **four particles being subtracted from the pile** and **distributed among its neighbors.**\n\nIt is recommended to display the output in some kind of image format, as terminal emulators are usually too small to display images larger than a few dozen characters tall. As an example of how to accomplish this, see the Bitmap/Write a PPM file task.  \nExamples up to 2^30, wow!  \njavascript running on web  \n**Examples:**\n\n```\n0 0 0 0 0    0 0 0 0 0\n0 0 0 0 0    0 0 1 0 0\n0 0 4 0 0 -> 0 1 0 1 0\n0 0 0 0 0    0 0 1 0 0\n0 0 0 0 0    0 0 0 0 0\n\n0 0 0 0 0    0 0 0 0 0\n0 0 0 0 0    0 0 1 0 0\n0 0 6 0 0 -> 0 1 2 1 0\n0 0 0 0 0    0 0 1 0 0\n0 0 0 0 0    0 0 0 0 0\n\n0  0 0  0  0    0 0 1 0 0\n0  0 0  0  0    0 2 1 2 0\n0  0 16 0  0 -> 1 1 0 1 1\n0  0 0  0  0    0 2 1 2 0\n0  0 0  0  0    0 0 1 0 0\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Terminal based\n\n**Works with**: Rakudo version 2019.07.1\n\nDefaults to a stack of 1000 and showing progress. Pass in a custom stack size if desired and -hide-progress to run without displaying progress (much faster.)\n\n```\nsub cleanup { print \"\\e[0m\\e[?25h\\n\"; exit(0) }\n\nsignal(SIGINT).tap: { cleanup(); exit(0) }\n\nunit sub MAIN ($stack = 1000, :$hide-progress = False );\n\nmy @color = \"\\e[38;2;0;0;0m█\",\n            \"\\e[38;2;255;0;0m█\",\n            \"\\e[38;2;255;255;0m█\",\n            \"\\e[38;2;0;0;255m█\",\n            \"\\e[38;2;255;255;255m█\"\n            ;\n\nmy ($h, $w) = qx/stty size/.words».Int;\nmy $buf = $w * $h;\nmy @buffer = 0 xx $buf;\nmy $done;\n\n@buffer[$w * ($h div 2) + ($w div 2) - 1] = $stack;\n\nprint \"\\e[?25l\\e[48;5;232m\";\n\nrepeat {\n    $done = True;\n    loop (my int $row; $row < $h; $row = $row + 1) {\n        my int $rs = $row * $w; # row start\n        my int $re = $rs  + $w; # row end\n        loop (my int $idx = $rs; $idx < $re; $idx = $idx + 1) {\n            if @buffer[$idx] >= 4 {\n                my $grains = @buffer[$idx] div 4;\n                @buffer[ $idx - $w ] += $grains if $row > 0;\n                @buffer[ $idx - 1  ] += $grains if $idx - 1 >= $rs;\n                @buffer[ $idx + $w ] += $grains if $row < $h - 1;\n                @buffer[ $idx + 1  ] += $grains if $idx + 1 < $re;\n                @buffer[ $idx ] %= 4;\n                $done = False;\n            }\n        }\n    }\n    unless $hide-progress {\n        print \"\\e[1;1H\", @buffer.map( { @color[$_ min 4] }).join;\n    }\n} until $done;\n\nprint \"\\e[1;1H\", @buffer.map( { @color[$_ min 4] }).join;\n\ncleanup;\n\n```\n\nPassing in 2048 as a stack size results in: Abelian-sandpile-model-perl6.png (offsite .png image)\n\n### SDL2 Animation\n\n```\nuse NativeCall;\nuse SDL2::Raw;\n\nmy ($width, $height) = 900, 900;\n\nunit sub MAIN ($stack = 10000);\n\nmy int ($w, $h) = 160, 160;\n\nmy $buf = $w * $h;\nmy @buffer = 0 xx $buf;\n\n@buffer[$w * ($h div 2) + ($w div 2) - 1] = $stack;\n\n\nSDL_Init(VIDEO);\n\nmy SDL_Window $window = SDL_CreateWindow(\n    \"Abelian sandpile - Raku\",\n    SDL_WINDOWPOS_CENTERED_MASK, SDL_WINDOWPOS_CENTERED_MASK,\n    $width, $height,\n    RESIZABLE\n);\n\nmy SDL_Renderer $renderer = SDL_CreateRenderer( $window, -1, ACCELERATED +| TARGETTEXTURE );\n\nmy $asp_texture = SDL_CreateTexture($renderer, %PIXELFORMAT<RGB332>, STREAMING, $w, $h);\n\nmy $pixdatabuf = CArray[int64].new(0, $w, $h, $w);\n\nmy @color = 0x00, 0xDE, 0x14, 0xAA, 0xFF;\n\nsub render {\n    my int $pitch;\n    my int $cursor;\n\n    # work-around to pass the pointer-pointer.\n    my $pixdata = nativecast(Pointer[int64], $pixdatabuf);\n    SDL_LockTexture($asp_texture, SDL_Rect, $pixdata, $pitch);\n\n    $pixdata = nativecast(CArray[int8], Pointer.new($pixdatabuf[0]));\n\n    loop (my int $row; $row < $h; $row = $row + 1) {\n        my int $rs = $row * $w; # row start\n        my int $re = $rs  + $w; # row end\n        loop (my int $idx = $rs; $idx < $re; $idx = $idx + 1) {\n            $pixdata[$idx] =  @buffer[$idx] < 4 ?? @color[@buffer[$idx]] !! @color[4];\n            if @buffer[$idx] >= 4 {\n                my $grains = floor @buffer[$idx] / 4;\n                @buffer[ $idx - $w ] += $grains if $row > 0;\n                @buffer[ $idx - 1  ] += $grains if $idx - 1 >= $rs;\n                @buffer[ $idx + $w ] += $grains if $row < $h - 1;\n                @buffer[ $idx + 1  ] += $grains if $idx + 1 < $re;\n                @buffer[ $idx ] %= 4;\n            }\n        }\n    }\n\n    SDL_UnlockTexture($asp_texture);\n\n    SDL_RenderCopy($renderer, $asp_texture, SDL_Rect, SDL_Rect.new(:x(0), :y(0), :w($width), :h($height)));\n    SDL_RenderPresent($renderer);\n}\n\nmy $event = SDL_Event.new;\n\nmain: loop {\n\n    while SDL_PollEvent($event) {\n        my $casted_event = SDL_CastEvent($event);\n\n        given $casted_event {\n            when *.type == QUIT {\n                last main;\n            }\n        }\n    }\n\n    render();\n    print fps;\n}\n\nsay '';\n\nsub fps {\n    state $fps-frames = 0;\n    state $fps-now    = now;\n    state $fps        = '';\n    $fps-frames++;\n    if now - $fps-now >= 1 {\n        $fps = [~] \"\\b\" x 40, ' ' x 20, \"\\b\" x 20 ,\n            sprintf \"FPS: %5.2f  \", ($fps-frames / (now - $fps-now)).round(.01);\n        $fps-frames = 0;\n        $fps-now = now;\n    }\n    $fps\n}\n\n```\n\nPassing in a stack size of 20000 results in: Abelian-sandpile-sdl2.png (offsite .png image)"}]}
{"messages": [{"role": "user", "content": "Our sandpiles are based on a 3 by 3 rectangular grid giving nine areas that\ncontain a number from 0 to 3 inclusive. (The numbers are said to represent\ngrains of sand in each area of the sandpile).\n\nE.g. `s1` =\n\n```\n    \n    1 2 0\n    2 1 1\n    0 1 3\n\n```\n\nand `s2` =\n\n```\n    2 1 3\n    1 0 1\n    0 1 0\n\n```\n\nAddition on sandpiles is done by adding numbers in corresponding grid areas,\nso for the above:\n\n```\n              1 2 0     2 1 3     3 3 3\n    s1 + s2 = 2 1 1  +  1 0 1  =  3 1 2\n              0 1 3     0 1 0     0 2 3\n\n```\n\nIf the addition would result in more than 3 \"grains of sand\" in any area then\nthose areas cause the whole sandpile to become \"unstable\" and the sandpile\nareas are \"toppled\" in an \"avalanche\" until the \"stable\" result is obtained.\n\nAny unstable area (with a number >= 4), is \"toppled\" by loosing one grain of\nsand to each of its four horizontal or vertical neighbours. Grains are lost\nat the edge of the grid, but otherwise increase the number in neighbouring\ncells by one, whilst decreasing the count in the toppled cell by four in each\ntoppling.\n\nA toppling may give an adjacent area more than four grains of sand leading to\na chain of topplings called an \"avalanche\".\nE.g.\n\n```\n    \n    4 3 3     0 4 3     1 0 4     1 1 0     2 1 0\n    3 1 2 ==> 4 1 2 ==> 4 2 2 ==> 4 2 3 ==> 0 3 3\n    0 2 3     0 2 3     0 2 3     0 2 3     1 2 3\n\n```\n\nThe final result is the stable sandpile on the right.\n\n**Note:** The order in which cells are toppled does not affect the final result.\n\nTask\n\n* Create a class or datastructure and functions to represent and operate on sandpiles.\n* Confirm the result of the avalanche of topplings shown above\n* Confirm that s1 + s2 == s2 + s1 # Show the stable results\n* If s3 is the sandpile with number 3 in every grid area, and s3\\_id is the following sandpile:\n\n```\n    2 1 2  \n    1 0 1  \n    2 1 2\n\n```\n\n* Show that `s3 + s3_id == s3`\n* Show that `s3_id + s3_id == s3_id`\n\nShow confirming output here, with your examples.\n\nReferences\n\n* https://www.youtube.com/watch?v=1MtEUErz7Gg\n* https://en.wikipedia.org/wiki/Abelian\\_sandpile\\_model"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.05\n\nMost of the logic is lifted straight from the Abelian sandpile model task.\n\n```\nclass ASP {\n    has $.h = 3;\n    has $.w = 3;\n    has @.pile = 0 xx $!w * $!h;\n\n    method topple {\n        my $buf = $!w * $!h;\n        my $done;\n        repeat {\n            $done = True;\n            loop (my int $row; $row < $!h; $row = $row + 1) {\n                my int $rs = $row * $!w; # row start\n                my int $re = $rs  + $!w; # row end\n                loop (my int $idx = $rs; $idx < $re; $idx = $idx + 1) {\n                    if self.pile[$idx] >= 4 {\n                        my $grain = self.pile[$idx] div 4;\n                        self.pile[ $idx - $!w ] += $grain if $row > 0;\n                        self.pile[ $idx - 1  ]  += $grain if $idx - 1 >= $rs;\n                        self.pile[ $idx + $!w ] += $grain if $row < $!h - 1;\n                        self.pile[ $idx + 1  ]  += $grain if $idx + 1 < $re;\n                        self.pile[ $idx ] %= 4;\n                        $done = False;\n                    }\n                }\n            }\n        } until $done;\n        self.pile;\n    }\n}\n\n# some handy display layout modules\nuse Terminal::Boxer:ver<0.2+>;\nuse Text::Center;\n\nfor 3, (4,3,3,3,1,2,0,2,3), (2,1,2,1,0,1,2,1,2), # 3 square task example\n    3, (2,1,2,1,0,1,2,1,2), (2,1,2,1,0,1,2,1,2), # 3 square identity\n    5, (4,1,0,5,1,9,3,6,1,0,8,1,2,5,3,3,0,1,7,5,4,2,2,4,0), (2,3,2,3,2,3,2,1,2,3,2,1,0,1,2,3,2,1,2,3,2,3,2,3,2) # 5 square test\n  -> $size, $pile, $identity {\n\n    my $asp = ASP.new(:h($size), :w($size));\n\n    $asp.pile = |$pile;\n\n    my @display;\n\n    my %p = :col($size), :3cw, :indent(\"\\t\");\n\n    @display.push: rs-box |%p, |$identity;\n\n    @display.push: rs-box |%p, $asp.pile;\n\n    @display.push: rs-box |%p, $asp.topple;\n\n    $asp.pile Z+= $identity.list;\n\n    @display.push: rs-box |%p, $asp.pile;\n\n    @display.push: rs-box |%p, $asp.topple;\n\n    put %p<indent> ~ qww<identity 'test pile' toppled 'plus identity' toppled>».&center($size * 4 + 1).join: %p<indent>;\n\n    .put for [Z~] @display».lines;\n\n    put '';\n}\n\n```\n\nOutput:\n\n```\n\t   identity  \t  test pile  \t   toppled   \tplus identity\t   toppled   \n\t╭───┬───┬───╮\t╭───┬───┬───╮\t╭───┬───┬───╮\t╭───┬───┬───╮\t╭───┬───┬───╮\n\t│ 2 │ 1 │ 2 │\t│ 4 │ 3 │ 3 │\t│ 2 │ 1 │ 0 │\t│ 4 │ 2 │ 2 │\t│ 2 │ 1 │ 0 │\n\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\n\t│ 1 │ 0 │ 1 │\t│ 3 │ 1 │ 2 │\t│ 0 │ 3 │ 3 │\t│ 1 │ 3 │ 4 │\t│ 0 │ 3 │ 3 │\n\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\n\t│ 2 │ 1 │ 2 │\t│ 0 │ 2 │ 3 │\t│ 1 │ 2 │ 3 │\t│ 3 │ 3 │ 5 │\t│ 1 │ 2 │ 3 │\n\t╰───┴───┴───╯\t╰───┴───┴───╯\t╰───┴───┴───╯\t╰───┴───┴───╯\t╰───┴───┴───╯\n\n\t   identity  \t  test pile  \t   toppled   \tplus identity\t   toppled   \n\t╭───┬───┬───╮\t╭───┬───┬───╮\t╭───┬───┬───╮\t╭───┬───┬───╮\t╭───┬───┬───╮\n\t│ 2 │ 1 │ 2 │\t│ 2 │ 1 │ 2 │\t│ 2 │ 1 │ 2 │\t│ 4 │ 2 │ 4 │\t│ 2 │ 1 │ 2 │\n\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\n\t│ 1 │ 0 │ 1 │\t│ 1 │ 0 │ 1 │\t│ 1 │ 0 │ 1 │\t│ 2 │ 0 │ 2 │\t│ 1 │ 0 │ 1 │\n\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\t├───┼───┼───┤\n\t│ 2 │ 1 │ 2 │\t│ 2 │ 1 │ 2 │\t│ 2 │ 1 │ 2 │\t│ 4 │ 2 │ 4 │\t│ 2 │ 1 │ 2 │\n\t╰───┴───┴───╯\t╰───┴───┴───╯\t╰───┴───┴───╯\t╰───┴───┴───╯\t╰───┴───┴───╯\n\n\t       identity      \t      test pile      \t       toppled       \t    plus identity    \t       toppled       \n\t╭───┬───┬───┬───┬───╮\t╭───┬───┬───┬───┬───╮\t╭───┬───┬───┬───┬───╮\t╭───┬───┬───┬───┬───╮\t╭───┬───┬───┬───┬───╮\n\t│ 2 │ 3 │ 2 │ 3 │ 2 │\t│ 4 │ 1 │ 0 │ 5 │ 1 │\t│ 1 │ 3 │ 2 │ 1 │ 0 │\t│ 3 │ 6 │ 4 │ 4 │ 2 │\t│ 1 │ 3 │ 2 │ 1 │ 0 │\n\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\n\t│ 3 │ 2 │ 1 │ 2 │ 3 │\t│ 9 │ 3 │ 6 │ 1 │ 0 │\t│ 2 │ 2 │ 3 │ 3 │ 1 │\t│ 5 │ 4 │ 4 │ 5 │ 4 │\t│ 2 │ 2 │ 3 │ 3 │ 1 │\n\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\n\t│ 2 │ 1 │ 0 │ 1 │ 2 │\t│ 8 │ 1 │ 2 │ 5 │ 3 │\t│ 1 │ 1 │ 2 │ 0 │ 3 │\t│ 3 │ 2 │ 2 │ 1 │ 5 │\t│ 1 │ 1 │ 2 │ 0 │ 3 │\n\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\n\t│ 3 │ 2 │ 1 │ 2 │ 3 │\t│ 3 │ 0 │ 1 │ 7 │ 5 │\t│ 2 │ 0 │ 3 │ 2 │ 0 │\t│ 5 │ 2 │ 4 │ 4 │ 3 │\t│ 2 │ 0 │ 3 │ 2 │ 0 │\n\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\t├───┼───┼───┼───┼───┤\n\t│ 2 │ 3 │ 2 │ 3 │ 2 │\t│ 4 │ 2 │ 2 │ 4 │ 0 │\t│ 3 │ 2 │ 3 │ 2 │ 1 │\t│ 5 │ 5 │ 5 │ 5 │ 3 │\t│ 3 │ 2 │ 3 │ 2 │ 1 │\n\t╰───┴───┴───┴───┴───╯\t╰───┴───┴───┴───┴───╯\t╰───┴───┴───┴───┴───╯\t╰───┴───┴───┴───┴───╯\t╰───┴───┴───┴───┴───╯\n\n```"}]}
{"messages": [{"role": "user", "content": "**Abstract type** is a type without instances or without definition.\n\nFor example in object-oriented programming using some languages, abstract types can be partial implementations of other types, which are to be derived there-from. An abstract type may provide implementation of some operations and/or components. Abstract types without any implementation are called **interfaces**. In the languages that do not support multiple inheritance (Ada, Java), classes can, nonetheless, inherit from multiple interfaces. The languages with multiple inheritance (like C++) usually make no distinction between partially implementable abstract types and interfaces. Because the abstract type's implementation is incomplete, OO languages normally prevent instantiation from them (instantiation must derived from one of their descendant classes).\n\nThe term **abstract datatype** also may denote a type, with an implementation provided by the programmer rather than directly by the language (a **built-in** or an inferred type). Here the word *abstract* means that the implementation is abstracted away, irrelevant for the user of the type. Such implementation can and should be hidden if the language supports separation of implementation and specification. This hides complexity while allowing the implementation to change without repercussions on the usage. The corresponding software design practice is said to follow the information hiding principle.\n\nIt is important not to confuse this *abstractness* (of implementation) with one of the **abstract type**. The latter is abstract in the sense that the set of its values is empty. In the sense of implementation abstracted away, all user-defined types are abstract.\n\nIn some languages, like for example in Objective Caml which is strongly statically typed, it is also possible to have **abstract types** that are not OO related and are not an abstractness too. These are *pure abstract types* without any definition even in the implementation and can be used for example for the type algebra, or for some consistence of the type inference. For example in this area, an abstract type can be used as a phantom type to augment another type as its parameter.\n\n**Task**: show how an abstract type can be declared in the language. If the language makes a distinction between interfaces and partially implemented types illustrate both."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015.12\n\nRaku supports roles, which are a bit like interfaces, but unlike interfaces in Java they can also contain some implementation.\n\n```\nuse v6;\n\nrole A {\n    # must be filled in by the class it is composed into\n    method abstract() { ... };\n\n    # can be overridden in the class, but that's not mandatory\n    method concrete() { say '# 42' };\n}\n\nclass SomeClass does A {\n    method abstract() {\n        say \"# made concrete in class\"\n    }\n}\n\nmy $obj = SomeClass.new;\n$obj.abstract();\n$obj.concrete();\n\n# output:\n# made concrete in class\n# 42\n\n```"}]}
{"messages": [{"role": "user", "content": "An Abundant number is a number **n** for which the   *sum of divisors*   **σ\n(\nn\n)\n>\n2\nn\n{\\displaystyle {\\displaystyle \\sigma (n)>2n}}**,\n  \nor,   equivalently,   the   *sum of proper divisors*   (or aliquot sum)       **s\n(\nn\n)\n>\nn\n{\\displaystyle {\\displaystyle s(n)>n}}**.\n\nE.G.\n\n**12**   is abundant, it has the proper divisors     **1, 2, 3, 4 & 6**     which sum to   **16**   ( > **12** or **n**);\n  \n       or alternately,   has the sigma sum of   **1, 2, 3, 4, 6 & 12**   which sum to   **28**   ( > **24** or **2n**).\n\nAbundant numbers are common, though **even** abundant numbers seem to be much more common than **odd** abundant numbers.\n\nTo make things more interesting, this task is specifically about finding   *odd abundant numbers*.\n\nTask\n\n* Find and display here: at least the first 25 abundant odd numbers and either their proper divisor sum or sigma sum.\n* Find and display here: the one thousandth abundant odd number and either its proper divisor sum or sigma sum.\n* Find and display here: the first abundant odd number greater than one billion (\n\n  10\n\n  9\n  {\\displaystyle {\\displaystyle 10^{9}}}\n  ) and either its proper divisor sum or sigma sum.\n\nReferences\n:   * OEIS:A005231: Odd abundant numbers (odd numbers n whose sum of divisors exceeds 2n)\n    * American Journal of Mathematics, Vol. 35, No. 4 (Oct., 1913), pp. 413-422 - Finiteness of the Odd Perfect and Primitive Abundant Numbers with n Distinct Prime Factors (LE Dickson)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\n```\nsub odd-abundant (\\x) {\n    my @l = x.is-prime ?? 1 !! flat\n    1, (3 .. x.sqrt.floor).map: -> \\d {\n         next unless d +& 1;\n         my \\y = x div d;\n         next if y * d !== x;\n         d !== y ?? (d, y) !! d\n    };\n    @l.sum > x ?? @l.sort !! Empty;\n}\n\nsub odd-abundants (Int :$start-at is copy) {\n    $start-at = ( $start-at + 2 ) div 3;\n    $start-at += $start-at %% 2;\n    $start-at *= 3;\n    ($start-at, *+6 ... *).hyper.map: {\n        next unless my $oa = cache .&odd-abundant;\n        sprintf \"%6d: divisor sum: {$oa.join: ' + '} = {$oa.sum}\", $_\n    }\n}\n\nput 'First 25 abundant odd numbers:';\n.put for odd-abundants( :start-at(1) )[^25];\n\nput \"\\nOne thousandth abundant odd number:\\n\" ~ odd-abundants( :start-at(1) )[999] ~\n\n\"\\n\\nFirst abundant odd number above one billion:\\n\" ~ odd-abundants( :start-at(1_000_000_000) ).head;\n\n```\n\nOutput:\n\n```\nFirst 25 abundant odd numbers:\n   945: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 27 + 35 + 45 + 63 + 105 + 135 + 189 + 315 = 975\n  1575: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 25 + 35 + 45 + 63 + 75 + 105 + 175 + 225 + 315 + 525 = 1649\n  2205: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 35 + 45 + 49 + 63 + 105 + 147 + 245 + 315 + 441 + 735 = 2241\n  2835: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 27 + 35 + 45 + 63 + 81 + 105 + 135 + 189 + 315 + 405 + 567 + 945 = 2973\n  3465: divisor sum: 1 + 3 + 5 + 7 + 9 + 11 + 15 + 21 + 33 + 35 + 45 + 55 + 63 + 77 + 99 + 105 + 165 + 231 + 315 + 385 + 495 + 693 + 1155 = 4023\n  4095: divisor sum: 1 + 3 + 5 + 7 + 9 + 13 + 15 + 21 + 35 + 39 + 45 + 63 + 65 + 91 + 105 + 117 + 195 + 273 + 315 + 455 + 585 + 819 + 1365 = 4641\n  4725: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 25 + 27 + 35 + 45 + 63 + 75 + 105 + 135 + 175 + 189 + 225 + 315 + 525 + 675 + 945 + 1575 = 5195\n  5355: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 17 + 21 + 35 + 45 + 51 + 63 + 85 + 105 + 119 + 153 + 255 + 315 + 357 + 595 + 765 + 1071 + 1785 = 5877\n  5775: divisor sum: 1 + 3 + 5 + 7 + 11 + 15 + 21 + 25 + 33 + 35 + 55 + 75 + 77 + 105 + 165 + 175 + 231 + 275 + 385 + 525 + 825 + 1155 + 1925 = 6129\n  5985: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 19 + 21 + 35 + 45 + 57 + 63 + 95 + 105 + 133 + 171 + 285 + 315 + 399 + 665 + 855 + 1197 + 1995 = 6495\n  6435: divisor sum: 1 + 3 + 5 + 9 + 11 + 13 + 15 + 33 + 39 + 45 + 55 + 65 + 99 + 117 + 143 + 165 + 195 + 429 + 495 + 585 + 715 + 1287 + 2145 = 6669\n  6615: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 27 + 35 + 45 + 49 + 63 + 105 + 135 + 147 + 189 + 245 + 315 + 441 + 735 + 945 + 1323 + 2205 = 7065\n  6825: divisor sum: 1 + 3 + 5 + 7 + 13 + 15 + 21 + 25 + 35 + 39 + 65 + 75 + 91 + 105 + 175 + 195 + 273 + 325 + 455 + 525 + 975 + 1365 + 2275 = 7063\n  7245: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 23 + 35 + 45 + 63 + 69 + 105 + 115 + 161 + 207 + 315 + 345 + 483 + 805 + 1035 + 1449 + 2415 = 7731\n  7425: divisor sum: 1 + 3 + 5 + 9 + 11 + 15 + 25 + 27 + 33 + 45 + 55 + 75 + 99 + 135 + 165 + 225 + 275 + 297 + 495 + 675 + 825 + 1485 + 2475 = 7455\n  7875: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 25 + 35 + 45 + 63 + 75 + 105 + 125 + 175 + 225 + 315 + 375 + 525 + 875 + 1125 + 1575 + 2625 = 8349\n  8085: divisor sum: 1 + 3 + 5 + 7 + 11 + 15 + 21 + 33 + 35 + 49 + 55 + 77 + 105 + 147 + 165 + 231 + 245 + 385 + 539 + 735 + 1155 + 1617 + 2695 = 8331\n  8415: divisor sum: 1 + 3 + 5 + 9 + 11 + 15 + 17 + 33 + 45 + 51 + 55 + 85 + 99 + 153 + 165 + 187 + 255 + 495 + 561 + 765 + 935 + 1683 + 2805 = 8433\n  8505: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 27 + 35 + 45 + 63 + 81 + 105 + 135 + 189 + 243 + 315 + 405 + 567 + 945 + 1215 + 1701 + 2835 = 8967\n  8925: divisor sum: 1 + 3 + 5 + 7 + 15 + 17 + 21 + 25 + 35 + 51 + 75 + 85 + 105 + 119 + 175 + 255 + 357 + 425 + 525 + 595 + 1275 + 1785 + 2975 = 8931\n  9135: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 29 + 35 + 45 + 63 + 87 + 105 + 145 + 203 + 261 + 315 + 435 + 609 + 1015 + 1305 + 1827 + 3045 = 9585\n  9555: divisor sum: 1 + 3 + 5 + 7 + 13 + 15 + 21 + 35 + 39 + 49 + 65 + 91 + 105 + 147 + 195 + 245 + 273 + 455 + 637 + 735 + 1365 + 1911 + 3185 = 9597\n  9765: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 31 + 35 + 45 + 63 + 93 + 105 + 155 + 217 + 279 + 315 + 465 + 651 + 1085 + 1395 + 1953 + 3255 = 10203\n 10395: divisor sum: 1 + 3 + 5 + 7 + 9 + 11 + 15 + 21 + 27 + 33 + 35 + 45 + 55 + 63 + 77 + 99 + 105 + 135 + 165 + 189 + 231 + 297 + 315 + 385 + 495 + 693 + 945 + 1155 + 1485 + 2079 + 3465 = 12645\n 11025: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 25 + 35 + 45 + 49 + 63 + 75 + 105 + 147 + 175 + 225 + 245 + 315 + 441 + 525 + 735 + 1225 + 1575 + 2205 + 3675 = 11946\n\nOne thousandth abundant odd number:\n492975: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 25 + 35 + 45 + 63 + 75 + 105 + 175 + 225 + 313 + 315 + 525 + 939 + 1565 + 1575 + 2191 + 2817 + 4695 + 6573 + 7825 + 10955 + 14085 + 19719 + 23475 + 32865 + 54775 + 70425 + 98595 + 164325 = 519361\n\nFirst abundant odd number above one billion:\n1000000575: divisor sum: 1 + 3 + 5 + 7 + 9 + 15 + 21 + 25 + 35 + 45 + 49 + 63 + 75 + 105 + 147 + 175 + 225 + 245 + 315 + 441 + 525 + 735 + 1225 + 1575 + 2205 + 3675 + 11025 + 90703 + 272109 + 453515 + 634921 + 816327 + 1360545 + 1904763 + 2267575 + 3174605 + 4081635 + 4444447 + 5714289 + 6802725 + 9523815 + 13333341 + 15873025 + 20408175 + 22222235 + 28571445 + 40000023 + 47619075 + 66666705 + 111111175 + 142857225 + 200000115 + 333333525 = 1083561009\n```"}]}
{"messages": [{"role": "user", "content": "These define three classifications of positive integers based on their   proper divisors.\n\nLet   P(n)   be the sum of the proper divisors of   **n**   where the proper divisors are all positive divisors of   **n**   other than   **n**   itself.\n\n```\n   if    P(n) <  n    then  n  is classed as  deficient  (OEIS A005100).\n   if    P(n) == n    then  n  is classed as  perfect    (OEIS A000396).\n   if    P(n) >  n    then  n  is classed as  abundant   (OEIS A005101).\n\n```\n\nExample\n\n**6**   has proper divisors of   **1**,   **2**,   and   **3**.\n\n**1 + 2 + 3 = 6**,   so   **6**   is classed as a perfect number.\n\nTask\n\nCalculate how many of the integers   **1**   to   **20,000**   (inclusive) are in each of the three classes.\n\nShow the results here.\n\nRelated tasks\n\n* Aliquot sequence classifications.   (The whole series from which this task is a subset.)\n* Proper divisors\n* Amicable pairs"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.12\n\n```\nsub propdivsum (\\x) {\n    my @l = 1 if x > 1;\n    (2 .. x.sqrt.floor).map: -> \\d {\n        unless x % d { @l.push: d; my \\y = x div d; @l.push: y if y != d }\n    }\n    sum @l\n}\n\nsay bag (1..20000).map: { propdivsum($_) <=> $_ }\n\n```\n\nOutput:\n\n```\nBag(Less(15043), More(4953), Same(4))\n```"}]}
{"messages": [{"role": "user", "content": "A problem posed by Paul Graham is that of creating a function that takes a single (numeric) argument and which returns another function that is an accumulator. The returned accumulator function in turn also takes a single numeric argument, and returns the sum of all the numeric values passed in so far to that accumulator (including the initial value passed when the accumulator was created).\n\nRules\n\nThe detailed rules are at http://paulgraham.com/accgensub.html and are reproduced here for simplicity (with additions in *small italic text*).\n\n:   Before you submit an example, make sure the function\n\n:   1. Takes a number n and returns a function (lets call it g), that takes a number i, and returns n incremented by the accumulation of i from every call of function g(i).  \n       Although these exact function and parameter names need not be used\n    2. Works for any numeric type-- i.e. can take both ints and floats and returns functions that can take both ints and floats. (It is not enough simply to convert all input to floats. An accumulator that has only seen integers must return integers.) *(i.e., if the language doesn't allow for numeric polymorphism, you have to use overloading or something like that)*\n    3. Generates functions that return the sum of every number ever passed to them, not just the most recent. *(This requires a piece of state to hold the accumulated value, which in turn means that pure functional languages can't be used for this task.)*\n    4. Returns a real function, meaning something that you can use wherever you could use a function you had defined in the ordinary way in the text of your program. *(Follow your language's conventions here.)*\n    5. Doesn't store the accumulated value or the returned functions in a way that could cause them to be inadvertently modified by other code. *(No global variables or other such things.)*\n:   E.g. if after the example, you added the following code (in a made-up language) *where the factory function is called foo*:\n\n    :   ```\n        x = foo(1); \n        x(5); \n        foo(3);\n        print x(2.3);\n        ```\n:   It should print 8.3. *(There is no need to print the form of the accumulator function returned by foo(3); it's not part of the task at all.)*\n\nTask\n\nCreate a function that implements the described rules.\n\nIt need not handle any special error cases not described above. The simplest way to implement the task as described is typically to use a closure, providing the language supports them.\n\nWhere it is not possible to hold exactly to the constraints above, describe the deviations."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nsub accum ($n is copy) { sub { $n += $^x } }\n\n#Example use:\nmy $a = accum 5;\n$a(4.5);\nsay $a(.5);   # Prints \"10\".\n\n# You can also use the \"&\" sigil to create a function that behaves syntactically\n# like any other function (i.e. no sigil nor parentheses needed to call it):\n\nmy &b = accum 5;\nsay b 3;   # Prints \"8\".\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Achilles number. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nAn **Achilles number** is a number that is powerful but imperfect. *Named after Achilles, a hero of the Trojan war, who was also powerful but imperfect.*\n\nA positive integer **n** is a powerful number if, for every prime factor **p** of **n**, **p2** is also a divisor.\n\nIn other words, every prime factor appears at least squared in the factorization.\n\nAll **Achilles numbers** are powerful. However, not all powerful numbers are **Achilles numbers**: only those that cannot be represented as **mk**, where **m** and **k** are positive integers greater than **1**.\n\nA ***strong* Achilles number** is an **Achilles number** whose **Euler totient (𝜑)** is also an **Achilles number**.\n\nE.G.\n\n**108** is a powerful number. Its prime factorization is **22 × 33**, and thus its prime factors are **2** and **3**. Both **22 = 4** and **32 = 9** are divisors of **108**. However, **108** cannot be represented as **mk**, where **m** and **k** are positive integers greater than **1**, so **108** is an **Achilles number**.\n\n**360** is *not* an **Achilles number** because it is not powerful. One of its prime factors is **5** but **360** is not divisible by **52 = 25**.\n\nFinally, **784** is *not* an **Achilles number**. It is a powerful number, because not only are **2** and **7** its only prime factors, but also **22 = 4** and **72 = 49** are divisors of it. Nonetheless, it is a perfect power; its square root is an even integer, so it is *not* an **Achilles number**.\n\n**500 = 22 × 53** is a ***strong* Achilles number** as its Euler totient, **𝜑(500)**, is **200 = 23 × 52** which is *also* an **Achilles number**.\n\nTask\n\n* Find and show the first 50 **Achilles numbers**.\n* Find and show at least the first 20 ***strong* Achilles numbers**.\n* For at least 2 through 5, show the count of **Achilles numbers** with that many digits.\n\nSee also\n\n* Wikipedia: Achilles number * OEIS:A052486 - Achilles numbers - powerful but imperfect numbers * OEIS:A194085 - Strong Achilles numbers: Achilles numbers m such that phi(m) is also an Achilles number * Related task: Powerful numbers * Related task: Totient function"}, {"role": "assistant", "content": "Timing is going to be system / OS dependent.\n\n```\nuse Prime::Factor;\nuse Math::Root;\n\nsub is-square-free (Int \\n) {\n    constant @p = ^100 .map: { next unless .is-prime; .² };\n    for @p -> \\p { return False if n %% p }\n    True\n}\n\nsub powerful (\\n, \\k = 2) {\n    my @p;\n    p(1, 2*k - 1);\n    sub p (\\m, \\r) {\n        @p.push(m) and return if r < k;\n        for 1 .. (n / m).&root(r) -> \\v {\n            if r > k {\n                next unless is-square-free(v);\n                next unless m gcd v == 1;\n            }\n            p(m * v ** r, r - 1)\n        }\n    }\n    @p\n}\n\nmy $achilles = powerful(10**9).hyper(:500batch).grep( {\n    my $f = .&prime-factors.Bag;\n    (+$f.keys > 1) && (1 == [gcd] $f.values) && (.sqrt.Int² !== $_)\n} ).classify: { .chars }\n\nmy \\𝜑 = 0, |(1..*).hyper.map: -> \\t { t × [×] t.&prime-factors.squish.map: { 1 - 1/$_ } }\n\nmy %as = Set.new: flat $achilles.values».list;\n\nmy $strong = lazy (flat $achilles.sort».value».list».sort).grep: { ?%as{𝜑[$_]} };\n\nput \"First 50 Achilles numbers:\";\nput (flat $achilles.sort».value».list».sort)[^50].batch(10)».fmt(\"%4d\").join(\"\\n\");\n\nput \"\\nFirst 30 strong Achilles numbers:\";\nput   $strong[^30].batch(10)».fmt(\"%5d\").join(\"\\n\");\n\nput \"\\nNumber of Achilles numbers with:\";\nsay \"$_ digits: \" ~ +$achilles{$_} // 0 for 2..9;\n\nprintf \"\\n%.1f total elapsed seconds\\n\", now - INIT now;\n\n```\n\nOutput:\n\n```\nFirst 50 Achilles numbers:\n  72  108  200  288  392  432  500  648  675  800\n 864  968  972 1125 1152 1323 1352 1372 1568 1800\n1944 2000 2312 2592 2700 2888 3087 3200 3267 3456\n3528 3872 3888 4000 4232 4500 4563 4608 5000 5292\n5324 5400 5408 5488 6075 6125 6272 6728 6912 7200\n\nFirst 30 strong Achilles numbers:\n  500   864  1944  2000  2592  3456  5000 10125 10368 12348\n12500 16875 19652 19773 30375 31104 32000 33275 37044 40500\n49392 50000 52488 55296 61731 64827 67500 69984 78608 80000\n\nNumber of Achilles numbers with:\n2 digits: 1\n3 digits: 12\n4 digits: 47\n5 digits: 192\n6 digits: 664\n7 digits: 2242\n8 digits: 7395\n9 digits: 24008\n\n6.1 total elapsed seconds\n```\n\nCould go further but slows to a crawl and starts chewing up memory in short order.\n\n```\n10 digits: 77330\n11 digits: 247449\n12 digits: 788855\n\n410.4 total elapsed seconds\n\n```"}]}
{"messages": [{"role": "user", "content": "The **Ackermann function** is a classic example of a recursive function, notable especially because it is not a primitive recursive function. It grows very quickly in value, as does the size of its call tree.\n\nThe Ackermann function is usually defined as follows:\n\n:   A\n    (\n    m\n    ,\n    n\n    )\n    =\n\n\n    {\n\n    n\n    +\n    1\n\n    if \n    m\n    =\n    0\n\n\n    A\n    (\n    m\n    −\n    1\n    ,\n    1\n    )\n\n    if \n    m\n    >\n    0\n\n\n     and \n    n\n    =\n    0\n\n\n    A\n    (\n    m\n    −\n    1\n    ,\n    A\n    (\n    m\n    ,\n    n\n    −\n    1\n    )\n    )\n\n    if \n    m\n    >\n    0\n\n\n     and \n    n\n    >\n    0.\n\n    {\\displaystyle {\\displaystyle A(m,n)={\\begin{cases}n+1&{\\mbox{if }}m=0\\\\A(m-1,1)&{\\mbox{if }}m>0{\\mbox{ and }}n=0\\\\A(m-1,A(m,n-1))&{\\mbox{if }}m>0{\\mbox{ and }}n>0.\\end{cases}}}}\n\nIts arguments are never negative and it always terminates.\n\nTask\n\nWrite a function which returns the value of \n\nA\n(\nm\n,\nn\n)\n{\\displaystyle {\\displaystyle A(m,n)}}\n. Arbitrary precision is preferred (since the function grows so quickly), but not required.\n\nSee also\n\n* Conway chained arrow notation for the Ackermann function."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nsub A(Int $m, Int $n) {\n    if    $m == 0 { $n + 1 } \n    elsif $n == 0 { A($m - 1, 1) }\n    else          { A($m - 1, A($m, $n - 1)) }\n}\n```\n\nAn implementation using multiple dispatch:\n\n```\nmulti sub A(0,      Int $n) { $n + 1                   }\nmulti sub A(Int $m, 0     ) { A($m - 1, 1)             }\nmulti sub A(Int $m, Int $n) { A($m - 1, A($m, $n - 1)) }\n```\n\nNote that in either case, Int is defined to be arbitrary precision in Raku.\n\nHere's a caching version of that, written in the sigilless style, with liberal use of Unicode, and the extra optimizing terms to make A(4,2) possible:\n\n```\nproto A(Int \\𝑚, Int \\𝑛) { (state @)[𝑚][𝑛] //= {*} }\n\nmulti A(0,      Int \\𝑛) { 𝑛 + 1 }\nmulti A(1,      Int \\𝑛) { 𝑛 + 2 }\nmulti A(2,      Int \\𝑛) { 3 + 2 * 𝑛 }\nmulti A(3,      Int \\𝑛) { 5 + 8 * (2 ** 𝑛 - 1) }\n\nmulti A(Int \\𝑚, 0     ) { A(𝑚 - 1, 1) }\nmulti A(Int \\𝑚, Int \\𝑛) { A(𝑚 - 1, A(𝑚, 𝑛 - 1)) }\n\n# Testing:\nsay A(4,1);\nsay .chars, \" digits starting with \", .substr(0,50), \"...\" given A(4,2);\n```\n\nOutput:\n\n```\n65533\n19729 digits starting with 20035299304068464649790723515602557504478254755697...\n```"}]}
{"messages": [{"role": "user", "content": "The task is to establish a connection to an Active Directory or Lightweight Directory Access Protocol server."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUsing module LMDB - bindings to the openLDAP library. Requires an LDAP instance.\n\n```\nuse LMDB;\n\nmy %DB := LMDB::DB.open(:path<some-dir>, %connection-parameters);\n\n```\n\n%DB may be accessed, read from and written to like a native hash."}]}
{"messages": [{"role": "user", "content": "Make sure you Connect to Active Directory"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# 20190718 Raku programming solution\n# https://github.com/perl6/doc/issues/2898\n# https://www.facebook.com/groups/perl6/permalink/2379873082279037/\n\n# Reference:\n# https://github.com/Altai-man/cro-ldap\n# https://www.forumsys.com/tutorials/integration-how-to/ldap/online-ldap-test-server/\n\nuse v6.d;\nuse Cro::LDAP::Client;\n\nmy $client = await Cro::LDAP::Client.connect('ldap://ldap.forumsys.com');\n\nmy $bind = await $client.bind(\n   name=>'cn=read-only-admin,dc=example,dc=com',password=>'password'\n);\ndie $bind.error-message if $bind.result-code;\n\nmy $resp = $client.search(\n   :dn<dc=example,dc=com>, base=>\"ou=mathematicians\", filter=>'(&(uid=gauss))'\n);\n\nreact {\n   whenever $resp -> $entry {\n      for $entry.attributes.kv -> $k, $v {\n         my $value-str = $v ~~ Blob ?? $v.decode !! $v.map(*.decode);\n         note \"$k -> $value-str\";\n      }\n   }\n}\n\n```\n\nOutput:\n\n```\nobjectClass -> inetOrgPerson organizationalPerson top person\nmail -> gauss@ldap.forumsys.com\nuid -> gauss\ncn -> Carl Friedrich Gauss\nsn -> Gauss\n\n```"}]}
{"messages": [{"role": "user", "content": "In object-oriented programming an object is active when its state depends on clock. Usually an active object encapsulates a task that updates the object's state. To the outer world the object looks like a normal object with methods that can be called from outside. Implementation of such methods must have a certain synchronization mechanism with the encapsulated task in order to prevent object's state corruption.\n\nA typical instance of an active object is an animation widget. The widget state changes with the time, while as an object it has all properties of a normal widget.\n\n**The task**\n\nImplement an active integrator object. The object has an input and output. The input can be set using the method *Input*. The input is a function of time. The output can be queried using the method *Output*. The object integrates its input over the time and the result becomes the object's output. So if the input is *K*(*t*) and the output is *S*, the object state *S* is changed to *S* + (*K*(*t*1) + *K*(*t*0)) \\* (*t*1 - *t*0) / 2, i.e. it integrates *K* using the trapeze method. Initially *K* is constant 0 and *S* is 0.\n\nIn order to test the object:\n\n1. set its input to sin (2π *f t*), where the frequency *f*=0.5Hz. The phase is irrelevant.\n2. wait 2s\n3. set the input to constant 0\n4. wait 0.5s\n\nVerify that now the object's output is approximately 0 (the sine has the period of 2s). The accuracy of the result will depend on the OS scheduler time slicing and the accuracy of the clock."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nThere is some jitter in the timer, but it is typically accurate to within a few thousandths of a second.\n\n```\nclass Integrator {\n    has $.f is rw = sub ($t) { 0 };\n    has $.now is rw;\n    has $.value is rw = 0;\n    has $.integrator is rw;\n\n    method init() {\n        self.value = &(self.f)(0);\n        self.integrator = Thread.new(\n            :code({\n                loop {\n                    my $t1 = now;\n                    self.value += (&(self.f)(self.now) + &(self.f)($t1)) * ($t1 - self.now) / 2;\n                    self.now = $t1;\n                    sleep .001;\n                }\n            }),\n            :app_lifetime(True)\n        ).run\n    }\n\n    method Input (&f-of-t) {\n        self.f = &f-of-t;\n        self.now = now;\n        self.init;\n    }\n\n    method Output { self.value }\n}\n\nmy $a = Integrator.new;\n\n$a.Input( sub ($t) { sin(2 * π * .5 * $t) } );\n\nsay \"Initial value: \", $a.Output;\n\nsleep 2;\n\nsay \"After 2 seconds: \", $a.Output;\n\n$a.Input( sub ($t) { 0 } );\n\nsleep .5;\n\nsay \"f(0): \", $a.Output;\n\n```\n\nTypical output:\n\n```\nInitial value: 0\nAfter 2 seconds: -0.0005555887464620366\nf(0): 0\n```"}]}
{"messages": [{"role": "user", "content": "Demonstrate how to dynamically add variables to an object (a class instance) at runtime.\n\nThis is useful when the methods/variables of an instance are based on a data file that isn't available until runtime. Hal Fulton gives an example of creating an OO CSV parser at An Exercise in Metaprogramming with Ruby. This is referred to as \"monkeypatching\" by Pythonistas and some others."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\nYou can add variables/methods to a class at runtime by composing in a role. The role only affects that instance, though it is inheritable. An object created from an existing object will inherit any roles composed in with values set to those at the time the role was created. If you want to keep changed values in the new object, clone it instead.\n\n```\nclass Bar { }             # an empty class\n\nmy $object = Bar.new;     # new instance\n\nrole a_role {             # role to add a variable: foo,\n   has $.foo is rw = 2;   # with an initial value of 2\n}\n\n$object does a_role;      # compose in the role\n\nsay $object.foo;          # prints: 2\n$object.foo = 5;          # change the variable\nsay $object.foo;          # prints: 5\n\nmy $ohno = Bar.new;       # new Bar object\n#say $ohno.foo;           # runtime error, base Bar class doesn't have the variable foo\n\nmy $this = $object.new;   # instantiate a new Bar derived from $object\nsay $this.foo;            # prints: 2 - original role value\n\nmy $that = $object.clone; # instantiate a new Bar derived from $object copying any variables\nsay $that.foo;            # 5 - value from the cloned object\n\n```\n\nThat's what's going on underneath, but often people just mix in an anonymous role directly using the but operator. Here we'll mix an attribute into a normal integer.\n\n```\nmy $lue = 42 but role { has $.answer = \"Life, the Universe, and Everything\" }\n\nsay $lue;          # 42\nsay $lue.answer;   # Life, the Universe, and Everything\n\n```\n\nOn the other hand, mixins are frowned upon when it is possible to compose roles directly into classes (as with Smalltalk traits), so that you get method collision detection at compile time. If you want to change a class at run time, you can also use monkey patching:\n\n```\nuse MONKEY-TYPING;\naugment class Int {\n    method answer { \"Life, the Universe, and Everything\" }\n}\nsay 42.answer;     # Life, the Universe, and Everything\n\n```\n\nThis practice, though allowed, is considered to be Evil Action at a Distance."}]}
{"messages": [{"role": "user", "content": "An addition chain of length r for n is a sequence 1 = a(0) < a(1) < a(2) ... < a(r) = n , such as a(k) = a(i) + a(j) ( i < k and j < k , i may be = j) . Each member is the sum of two earlier members, not necessarily distincts.\n\nA Brauer chain for n is an addition chain where a(k) = a(k-1) + a(j) with j < k. Each member uses the previous member as a summand.\n\nWe are interested in chains of minimal length L(n).\n\n**Task**\n\nFor each n in {7,14,21,29,32,42,64} display the following : L(n), the count of Brauer chains of length L(n), an example of such a Brauer chain, the count of non-brauer chains of length L(n), an example of such a chain. (NB: counts may be 0 ).\n\nExtra-credit: Same task for n in {47, 79, 191, 382 , 379, 12509}\n\n**References**\n\n* OEIS sequences A079301, A079302. [1]\n* Richard K. Guy - Unsolved problems in Number Theory - C6 - Addition chains.\n\n**Example**\n\n* minimal chain length l(19) = 6\n* brauer-chains(19) : count = 31 Ex: ( 1 2 3 4 8 11 19)\n* non-brauer-chains(19) : count = 2 Ex: ( 1 2 3 6 7 12 19)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Kotlin\n\n```\nmy @Example = ();\n\nsub check-Sequence($pos, @seq, $n, $minLen --> List)  {\n   if ($pos > $minLen or @seq[0] > $n) {\n      return $minLen, 0;\n   } elsif (@seq[0] == $n) {\n      @Example = @seq;\n      return $pos, 1;\n   } elsif ($pos < $minLen) {\n      return try-Permutation 0, $pos, @seq, $n, $minLen;\n   } else {\n      return $minLen, 0;\n   }\n}\n\nmulti sub try-Permutation($i, $pos, @seq, $n, $minLen --> List) {\n   return $minLen, 0 if $i > $pos;\n   my @res1 = check-Sequence $pos+1, (@seq[0]+@seq[$i],@seq).flat, $n, $minLen;\n   my @res2 = try-Permutation $i+1, $pos, @seq, $n, @res1[0];\n   if (@res2[0] < @res1[0]) {\n      return @res2[0], @res2[1];\n   } elsif (@res2[0] == @res1[0]) {\n      return @res2[0], @res1[1]+@res2[1];\n   } else {\n      note \"Error in try-Permutation\";\n      return 0, 0;\n   }\n}\n\nmulti sub try-Permutation($x, $minLen --> List) {\n   return try-Permutation 0, 0, [1], $x, $minLen;\n}\n\nsub find-Brauer($num, $minLen, $nbLimit) {\n   my ($actualMin, $brauer) = try-Permutation $num, $minLen;\n   say \"\\nN = \", $num;\n   say \"Minimum length of chains : L($num) = $actualMin\";\n   say \"Number of minimum length Brauer chains : \", $brauer;\n   say \"Brauer example : \", @Example.reverse if $brauer > 0;\n   @Example = ();\n   if ($num ≤ $nbLimit) {\n      my $nonBrauer = find-Non-Brauer $num, $actualMin+1, $brauer;\n      say \"Number of minimum length non-Brauer chains : \", $nonBrauer;\n      say \"Non-Brauer example : \", @Example if $nonBrauer > 0;\n      @Example = ();\n   } else {\n      say \"Non-Brauer analysis suppressed\";\n   }\n}\n\nsub is-Addition-Chain(@a --> Bool) {\n   for 2 .. @a.end -> $i {\n      return False if @a[$i] > @a[$i-1]*2 ;\n      my $ok = False;\n      for $i-1 … 0 -> $j {\n         for $j … 0 -> $k {\n            { $ok = True; last } if @a[$j]+@a[$k] == @a[$i];\n         }\n      }\n      return False unless $ok;\n   }\n\n   @Example = @a unless @Example or is-Brauer @a;\n   return True;\n}\n\nsub is-Brauer(@a --> Bool) {\n   for 2 .. @a.end -> $i {\n      my $ok = False;\n      for $i-1 … 0 -> $j {\n         { $ok = True; last } if @a[$i-1]+@a[$j] == @a[$i];\n      }\n      return False unless $ok;\n   }\n   return True;\n}\n\nsub find-Non-Brauer($num, $len, $brauer --> Int) {\n   my @seq   = flat 1 .. $len-1, $num;\n   my $count = is-Addition-Chain(@seq) ?? 1 !! 0;\n\n   sub next-Chains($index) {\n      loop {\n         next-Chains $index+1 if $index < $len-1;\n         return if @seq[$index]+$len-1-$index ≥ @seq[$len-1];\n         @seq[$index]++;\n         for $index^..^$len-1 { @seq[$_] = @seq[$_-1] + 1 }\n         $count++ if is-Addition-Chain @seq;\n      }\n   }\n\n   next-Chains 2;\n   return $count - $brauer;\n}\n\nsay \"Searching for Brauer chains up to a minimum length of 12:\";\nfind-Brauer $_, 12, 79 for 7, 14, 21, 29, 32, 42, 64 #, 47, 79, 191, 382, 379, 379, 12509 # un-comment for extra-credit\n\n```\n\nOutput:\n\n```\nSearching for Brauer chains up to a minimum length of 12:\n\nN = 7\nMinimum length of chains : L(7) = 4\nNumber of minimum length Brauer chains : 5\nBrauer example : (1 2 3 4 7)\nNumber of minimum length non-Brauer chains : 0\n\nN = 14\nMinimum length of chains : L(14) = 5\nNumber of minimum length Brauer chains : 14\nBrauer example : (1 2 3 4 7 14)\nNumber of minimum length non-Brauer chains : 0\n\nN = 21\nMinimum length of chains : L(21) = 6\nNumber of minimum length Brauer chains : 26\nBrauer example : (1 2 3 4 7 14 21)\nNumber of minimum length non-Brauer chains : 3\nNon-Brauer example : [1 2 4 5 8 13 21]\n\nN = 29\nMinimum length of chains : L(29) = 7\nNumber of minimum length Brauer chains : 114\nBrauer example : (1 2 3 4 7 11 18 29)\nNumber of minimum length non-Brauer chains : 18\nNon-Brauer example : [1 2 3 6 9 11 18 29]\n\nN = 32\nMinimum length of chains : L(32) = 5\nNumber of minimum length Brauer chains : 1\nBrauer example : (1 2 4 8 16 32)\nNumber of minimum length non-Brauer chains : 0\n\nN = 42\nMinimum length of chains : L(42) = 7\nNumber of minimum length Brauer chains : 78\nBrauer example : (1 2 3 4 7 14 21 42)\nNumber of minimum length non-Brauer chains : 6\nNon-Brauer example : [1 2 4 5 8 13 21 42]\n\nN = 64\nMinimum length of chains : L(64) = 6\nNumber of minimum length Brauer chains : 1\nBrauer example : (1 2 4 8 16 32 64)\nNumber of minimum length non-Brauer chains : 0\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Addition-chain exponentiation. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn cases of special objects (such as with matrices) the operation of multiplication can be excessively expensive. In these cases the operation of multiplication should be avoided or reduced to a minimum.\n\nIn mathematics and computer science, optimal **addition-chain exponentiation** is a method of exponentiation by positive integer powers that requires a minimal number of multiplications. It works by creating a shortest addition chain that generates the desired exponent. Each exponentiation in the chain can be evaluated by multiplying two of the earlier exponentiation results. More generally, *addition-chain exponentiation* may also refer to exponentiation by non-minimal addition chains constructed by a variety of algorithms (since a shortest addition chain is very difficult to find).\n\nThe shortest addition-chain algorithm requires no more multiplications than binary exponentiation and usually less. The first example of where it does better is for \n\na\n\n15\n{\\displaystyle {\\displaystyle a^{15}}}\n, where the binary method needs six multiplies but a shortest addition chain requires only five:\n\n:   a\n\n    15\n    =\n    a\n    ×\n    (\n    a\n    ×\n    [\n    a\n    ×\n\n    a\n\n    2\n\n    ]\n\n    2\n\n    )\n\n    2\n\n    {\\displaystyle {\\displaystyle a^{15}=a\\times (a\\times [a\\times a^{2}]^{2})^{2}\\!}}\n     (binary, 6 multiplications)\n:   a\n\n    15\n    =\n\n    a\n\n    3\n    ×\n    (\n    [\n\n    a\n\n    3\n\n    ]\n\n    2\n\n    )\n\n    2\n\n    {\\displaystyle {\\displaystyle a^{15}=a^{3}\\times ([a^{3}]^{2})^{2}\\!}}\n     (shortest addition chain, 5 multiplications)\n\nOn the other hand, the addition-chain method is much more complicated, since the determination of a shortest addition chain seems quite difficult: no efficient optimal methods are currently known for arbitrary exponents, and the related problem of finding a shortest addition chain for a given set of exponents has been proven NP-complete.\n\nTable demonstrating how to do *Exponentiation* using *Addition Chains*\n\n| Number of Multiplications | Actual Exponentiation | Specific implementation of *Addition Chains* to do Exponentiation |\n| --- | --- | --- |\n| 0 | a1 | a |\n| 1 | a2 | a × a |\n| 2 | a3 | a × a × a |\n| 2 | a4 | (a × a→b) × b |\n| 3 | a5 | (a × a→b) × b × a |\n| 3 | a6 | (a × a→b) × b × b |\n| 4 | a7 | (a × a→b) × b × b × a |\n| 3 | a8 | ((a × a→b) × b→d) × d |\n| 4 | a9 | (a × a × a→c) × c × c |\n| 4 | a10 | ((a × a→b) × b→d) × d × b |\n| 5 | a11 | ((a × a→b) × b→d) × d × b × a |\n| 4 | a12 | ((a × a→b) × b→d) × d × d |\n| 5 | a13 | ((a × a→b) × b→d) × d × d × a |\n| 5 | a14 | ((a × a→b) × b→d) × d × d × b |\n| 5 | a15 | ((a × a→b) × b × a→e) × e × e |\n| 4 | a16 | (((a × a→b) × b→d) × d→h) × h |\n\nThe number of multiplications required follows this sequence:\n0, 1, 2, 2, 3, 3, 4, 3, 4, 4, 5, 4, 5, 5, 5, 4, 5, 5, 6, 5,\n6, 6, 6, 5, 6, 6, 6, 6, 7, 6, 7, 5, 6, 6, 7, 6, 7, 7, 7, 6,\n7, 7, 7, 7, 7, 7, 8, 6, 7, 7, 7, 7, 8, 7, 8, 7, 8, 8, 8, 7,\n8, 8, 8, 6, 7, 7, 8, 7, 8, 8, 9, 7, 8, 8, 8, 8, 8, 8, 9, 7,\n8, 8, 8, 8, 8, 8, 9, 8, 9, 8, 9, 8, 9, 9, 9, 7, 8, 8, 8, 8...\n\nThis sequence can be found at: http://oeis.org/A003313\n\n**Task requirements:**\n\nUsing the following values:\n\nA\n=\n\n\n[\n\n1\n2\n\n0\n\n1\n2\n\n0\n\n0\n\n0\n\n0\n\n1\n2\n\n0\n\n1\n2\n\n0\n\n0\n\n0\n\n1\n2\n\n0\n\n−\n\n1\n2\n\n0\n\n0\n\n−\n\n1\n2\n\n0\n\n1\n2\n\n0\n\n0\n\n0\n\n0\n\n0\n\n0\n\n0\n\n0\n\n1\n\n0\n\n0\n\n0\n\n0\n\n1\n\n0\n\n]\n{\\displaystyle {\\displaystyle A={\\begin{bmatrix}{\\sqrt {\\frac {1}{2}}}&0&{\\sqrt {\\frac {1}{2}}}&0&0&0&\\\\0&{\\sqrt {\\frac {1}{2}}}&0&{\\sqrt {\\frac {1}{2}}}&0&0&\\\\0&{\\sqrt {\\frac {1}{2}}}&0&-{\\sqrt {\\frac {1}{2}}}&0&0&\\\\-{\\sqrt {\\frac {1}{2}}}&0&{\\sqrt {\\frac {1}{2}}}&0&0&0&\\\\0&0&0&0&0&1&\\\\0&0&0&0&1&0&\\\\\\end{bmatrix}}}}\n \n\nm\n=\n31415\n{\\displaystyle {\\displaystyle m=31415}}\n and \n\nn\n=\n27182\n{\\displaystyle {\\displaystyle n=27182}}\n\nRepeat task Matrix-exponentiation operator, except use **addition-chain exponentiation** to better calculate:\n\n:   A\n\n    m\n    {\\displaystyle {\\displaystyle A^{m}}}\n    , \n\n    A\n\n    n\n    {\\displaystyle {\\displaystyle A^{n}}}\n     and \n\n    A\n\n    n\n    ×\n    m\n    {\\displaystyle {\\displaystyle A^{n\\times m}}}\n    .\n\nAs an easier alternative to doing the matrix manipulation above, generate the *addition-chains* for 12509, 31415 and 27182 and use *addition-chain exponentiation* to calculate these two equations:\n\n* 1.0000220644541631415\n* 1.0000255005525127182\n\nAlso: Display a count of how many multiplications were done in each case.\n\nNote: There are two ways to approach this task:\n\n* Brute force - try every permutation possible and pick one with the least number of multiplications. If the brute force is a simpler algorithm, then present it as a subtask under the subtitle \"Brute force\", eg ===Brute Force===.\n* Some clever algorithm - the wikipedia page has some hints, subtitle the code with the name of algorithm.\n\nNote: Binary exponentiation does not usually produce the best solution. Provide only optimal solutions.\n\nKudos (κῦδος) for providing a routine that generate sequence A003313 in the output.\n\nAlso, see the Rosetta Code task:   [http://rosettacode.org/wiki/Knuth%27s\\_power\\_tree\nKnuth's power tree]."}, {"role": "assistant", "content": "**Translation of**: Python\n\n```\n# 20230327 Raku programming solution\n\nuse Math::Matrix;\n\nclass AdditionChains { has ( $.idx, $.pos, @.chains, @.lvl, %.pat ) is rw; \n\n   method add_chain { \n      # method 1: add chains depth then breadth first until done \n      return gather given self { \n         take my $newchain = .chains[.idx].clone.append: \n            .chains[.idx][*-1] + .chains[.idx][.pos];\n\t     .chains.append: $newchain;\n         .pos == +.chains[.idx]-1 ?? ( .idx += 1 && .pos = 0 ) !! .pos += 1;\n      }\n   }\n\n   method find_chain(\\nexp where nexp > 0) {\n   # method 1 interface: search for chain ending with n, adding more as needed\n      return ([1],) if nexp == 1;\n      my @chn = self.chains.grep: *.[*-1] == nexp // [];\n      unless @chn.Bool { \n         repeat { @chn = self.add_chain } until @chn[*-1][*-1] == nexp \n      }\n      return @chn\n   }\n\n   method knuth_path(\\ngoal) {\n      # method 2: knuth method, uses memoization to search for a shorter chain\n      return [] if ngoal < 1; \n      until self.pat{ngoal}:exists {\n         self.lvl[0] = [ gather for self.lvl[0].Array -> \\i {\n            for self.knuth_path(i).Array -> \\j {\n               unless self.pat{i + j}:exists {\n                  self.pat{i + j} = i and take i + j\n               }\n            }\n         } ] \n      }\n      return self.knuth_path(self.pat{ngoal}).append: ngoal\n   }\n\n   multi method cpow(\\xbase, \\chain) {\n#  raise xbase by an addition exponentiation chain for what becomes x**chain[-1]\n      my ($pows, %products) = 0, 1 => xbase;\n\n      %products{0} = xbase ~~ Math::Matrix \n         ?? Math::Matrix.new([ [ 1 xx xbase.size[1] ] xx xbase.size[0] ]) !! 1;\n\n      for chain.Array -> \\i {\n         %products{i} = %products{$pows} * %products{i - $pows};\n         $pows = i\n      }\n      return %products{ chain[*-1] }\n   }\n}\n\nmy $chn =  AdditionChains.new( idx    =>      0, pos =>      0, \n                               chains => ([1],), lvl => ([1],), pat => {1=>0} );\n\nsay 'First one hundred addition chain lengths:';\n.Str.say for ( (1..100).map: { +$chn.find_chain($_)[0] - 1 } ).rotor: 10;\n\nmy %chns = (31415, 27182).map: { $_ => $chn.knuth_path: $_ };\n\nsay \"\\nKnuth chains for addition chains of 31415 and 27182:\";\nsay \"Exponent: $_\\n  Addition Chain: %chns{$_}[0..*-2]\" for %chns.keys;\nsay '1.00002206445416^31415 = ', $chn.cpow(1.00002206445416, %chns{31415});\nsay '1.00002550055251^27182 = ', $chn.cpow(1.00002550055251, %chns{27182});\nsay '(1.000025 + 0.000058i)^27182 = ', $chn.cpow: 1.000025+0.000058i, %chns{27182};\nsay '(1.000022 + 0.000050i)^31415 = ', $chn.cpow: 1.000022+0.000050i, %chns{31415};\n\nmy \\sq05 = 0.5.sqrt;\nmy \\mat  = Math::Matrix.new( [[sq05,    0, sq05,     0, 0, 0], \n                             [    0, sq05,    0,  sq05, 0, 0], \n                             [    0, sq05,    0, -sq05, 0, 0],\n                             [-sq05,    0, sq05,     0, 0, 0], \n                             [    0,    0,    0,     0, 0, 1], \n                             [    0,    0,    0,     0, 1, 0]] );\n\nsay 'matrix A ^ 27182 =';\nsay my $res27182 = $chn.cpow(mat, %chns{27182});\nsay 'matrix A ^ 31415 =';\nsay $chn.cpow(mat, %chns{31415});\nsay '(matrix A ** 27182) ** 31415 =';\nsay $chn.cpow($res27182, %chns{31415});\n\n```\n\nOutput:\n\n```\nFirst one hundred addition chain lengths:\n0 1 2 2 3 3 4 3 4 4\n5 4 5 5 5 4 5 5 6 5\n6 6 6 5 6 6 6 6 7 6\n7 5 6 6 7 6 7 7 7 6\n7 7 7 7 7 7 8 6 7 7\n7 7 8 7 8 7 8 8 8 7\n8 8 8 6 7 7 8 7 8 8\n9 7 8 8 8 8 8 8 9 7\n8 8 8 8 8 8 9 8 9 8\n9 8 9 9 9 7 8 8 8 8\n\nKnuth chains for addition chains of 31415 and 27182:\nExponent: 27182\n  Addition Chain: 1 2 3 5 7 14 21 35 70 140 143 283 566 849 1698 3396 6792 6799 13591\nExponent: 31415\n  Addition Chain: 1 2 3 5 7 14 28 56 61 122 244 488 976 1952 3904 7808 15616 15677 31293\n1.00002206445416^31415 = 1.9999999998924638\n1.00002550055251^27182 = 1.999999999974053\n(1.000025 + 0.000058i)^27182 = -0.01128636963542673+1.9730308496660347i\n(1.000022 + 0.000050i)^31415 = 0.00016144681325535107+1.9960329014194498i\nmatrix A ^ 27182 =\n  0  0  0  0  0  0\n  0  0  0  0  0  0\n  0  0  0  0  0  0\n  0  0  0  0  0  0\n  0  0  0  0  0  1\n  0  0  0  0  1  0\nmatrix A ^ 31415 =\n   0  0  0   0  0  0\n   0  0  0   0  0  0\n   0  0  0  -0  0  0\n  -0  0  0   0  0  0\n   0  0  0   0  0  1\n   0  0  0   0  1  0\n(matrix A ** 27182) ** 31415 =\n  0  0  0  0  0  0\n  0  0  0  0  0  0\n  0  0  0  0  0  0\n  0  0  0  0  0  0\n  0  0  0  0  0  1\n  0  0  0  0  1  0\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nIn mathematics, **additive primes** are prime numbers for which the sum of their decimal digits are also primes.\n\nTask\n\nWrite a program to determine (and show here) all **additive primes** less than **500**.\n\nOptionally, show the **number** of additive primes.\n\nAlso see\n:   * the OEIS entry:   A046704 additive primes.\n    * the prime-numbers entry:   additive primes.\n    * the geeks for geeks entry: additive prime number.\n    * the prime-numbers fandom: additive primes."}, {"role": "assistant", "content": "```\nunit sub MAIN ($limit = 500);\nsay \"{+$_} additive primes < $limit:\\n{$_».fmt(\"%\" ~ $limit.chars ~ \"d\").batch(10).join(\"\\n\")}\",\n    with ^$limit .grep: { .is-prime && .comb.sum.is-prime }\n\n```\n\nOutput:\n\n```\n54 additive primes < 500:\n  2   3   5   7  11  23  29  41  43  47\n 61  67  83  89 101 113 131 137 139 151\n157 173 179 191 193 197 199 223 227 229\n241 263 269 281 283 311 313 317 331 337\n353 359 373 379 397 401 409 421 443 449\n461 463 467 487\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate how to get the address of a variable and how to set the address of a variable."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $x;\nsay $x.WHERE;\n\nmy $y := $x;   # alias\nsay $y.WHERE;  # same address as $x\n\nsay \"Same variable\" if $y =:= $x;\n$x = 42;\nsay $y;  # 42\n\n```\n\nOutput:\n\n```\n7857931379550584425\n```\n\nHow you set the address of a variable (or any other object) is outside the purview of Raku, but the language supports pluggable object representations, and any given representation scheme could conceivably allow an existing address to be treated as an object candidate where that makes sense. Memory-mapped structs are not unreasonable and are likely to be supported on VMs that allow it."}]}
{"messages": [{"role": "user", "content": "Description\n\nThe ADFGVX cipher was a manually applied field cipher used by the German Army during World War I. It was broken in 1918 by the French cryptanalyst Georges Painvin.\n\nThe workings of the cipher are described in the Wikipedia article, linked to above, and so will not be repeated here.\n\nTask\n\nWrite routines, functions etc. in your language to:\n\n1. Encrypt *suitable* plaintext and decrypt the resulting cipher text using the ADFGVX cipher algorithm given a Polybius square (see 2. below) and a *suitable* key. For this purpose *suitable* means text consisting solely of ASCII upper case letters or digits.\n\n2. Create a 6 x 6 Polybius square using a random combination of the letters A to Z and the digits 0 to 9 and then display it.\n\n3. Given the number of letters (between 7 and 12 say) to use, create a key by selecting a *suitable* word at random from unixdict.txt and then display it. The word selected should be such that none of its characters are repeated.\n\nUse these routines to create a Polybius square and a 9 letter key.\n\nThese should then be used to encrypt the plaintext: **ATTACKAT1200AM** and decrypt the resulting cipher text. Display here the results of both operations.\n\nNote\n\nAs it's unclear from the Wikipedia article how to handle a final row with fewer elements than the number of characters in the key, either of the methods mentioned in Columnar transposition may be used. In the case of the second method, it is also acceptable to fill any gaps after shuffling by moving elements to the left which makes decipherment harder."}, {"role": "assistant", "content": "Slightly different results from every other entry so far. See discussion page for reasons. It is impossible to tell from casual observation which column comes first in the Raku example. In every other (so far), the sub group with 4 characters is the first column.\n\n```\nsrand 123456; # For repeatability\n\nmy @header   = < A D F G V X >;\nmy $polybius = (flat 'A'..'Z', 0..9).pick(*).join;\n\nmy $key-length = 9;\nmy $key = uc 'unixdict.txt'.IO.words.grep( { (.chars == $key-length) && (+.comb.Set == +.comb) } ).roll;\n\nmy %cypher   = (@header X~ @header) Z=> $polybius.comb;\n\nmy $message = 'Attack at 1200AM';\n\nuse Terminal::Boxer;\nsay \"Key: $key\\n\";\nsay \"Polybius square:\\n\", ss-box :7col, :3cw, :indent(\"\\t\"), '', |@header, |(@header Z $polybius.comb.batch: 6);\nsay \"Message to encode: $message\";\nsay \"\\nEncoded: \" ~ my $encoded = encode $message;\nsay \"\\nDecoded: \" ~ decode $encoded;\n\nsub encode ($text is copy) {\n    $text = $text.uc.comb(/<[A..Z 0..9]>/).join;\n    my @order = $key.comb.pairs.sort( *.value )».key;\n    my @encode = %cypher.invert.hash{ $text.comb }.join.comb.batch($key-length).map: { [$_] };\n    ((^$key-length).map: { @encode».[@order]».grep( *.defined )».[$_].grep( *.defined ).join }).Str;\n}\n\nsub decode ($text is copy) {\n    my @text = $text.split(' ')».comb;\n    my $chars = @text[0].chars;\n    $_ = flat |$_, ' ' if .chars < $chars for @text;\n    my @order = $key.comb.pairs.sort( *.value )».key.pairs.sort( *.value )».key;\n    %cypher{ ( grep { /\\w/ }, flat [Z] @order.map( { |@text.batch($key-length)».[$_] } ) ).batch(2)».join }.join;\n}\n\n```\n\nOutput:\n\n```\nKey: GHOSTLIKE\n\nPolybius square:\n\t┌───┬───┬───┬───┬───┬───┬───┐\n\t│   │ A │ D │ F │ G │ V │ X │\n\t├───┼───┼───┼───┼───┼───┼───┤\n\t│ A │ H │ O │ S │ 5 │ 7 │ Q │\n\t├───┼───┼───┼───┼───┼───┼───┤\n\t│ D │ 0 │ I │ 6 │ J │ C │ V │\n\t├───┼───┼───┼───┼───┼───┼───┤\n\t│ F │ 4 │ 8 │ R │ X │ G │ A │\n\t├───┼───┼───┼───┼───┼───┼───┤\n\t│ G │ Y │ F │ P │ B │ Z │ 3 │\n\t├───┼───┼───┼───┼───┼───┼───┤\n\t│ V │ M │ W │ 9 │ D │ 1 │ N │\n\t├───┼───┼───┼───┼───┼───┼───┤\n\t│ X │ 2 │ E │ U │ T │ L │ K │\n\t└───┴───┴───┴───┴───┴───┴───┘\n\nMessage to encode: Attack at 1200AM\n\nEncoded: DVVA FVX XXA FGF XVX GXA XXD GFA XXD\n\n```"}]}
{"messages": [{"role": "user", "content": "In astronomy **air mass** is a measure of the amount of atmosphere between the observer and the object being observed. It is a function of the *zenith angle* (the angle between the line of sight an vertical) and the altitude of the observer. It is defined as the integral of the atmospheric density along the line of sight and is usually expressed relative to the air mass at zenith. Thus, looking straight up gives an air mass of one (regardless of observer's altitude) and viewing at any zenith angle greater than zero gives higher values.\n\nYou will need to integrate \n\nρ\n{\\displaystyle {\\displaystyle \\rho }}\n(h(a,z,x)) where \n\nρ\n{\\displaystyle {\\displaystyle \\rho }}\n(h) is the atmospheric density for a given height above sea level, and h(a,z,x) is the height above sea level for a point at distance x along the line of sight. Determining this last function requires some trigonometry.\n\nFor this task you can assume:\n\n:   * The density of Earth's atmosphere is proportional to exp(-a/8500 metres)\n    * The Earth is a perfect sphere of radius 6371 km.\n\nTask\n:   * Write a function that calculates the air mass for an observer at a given altitude    ***a***    above sea level and zenith angle    ***z.***\n    * Show the air mass for zenith angles **0** to **90** in steps of **5** degrees for an observer at sea level.\n    * Do the same for the   NASA SOFIA infrared telescope,   which has a cruising altitude of 13,700 meters   (about 8.3 miles),\n\n    :   it flies in a specially retrofitted Boeing 747 about four flights a week."}, {"role": "assistant", "content": "**Translation of**: FreeBASIC\n\n```\nconstant DEG = pi/180;    # degrees to radians\nconstant RE  = 6371000;   # Earth radius in meters\nconstant dd  = 0.001;     # integrate in this fraction of the distance already covered\nconstant FIN = 10000000;  # integrate only to a height of 10000km, effectively infinity\n\n#| Density of air as a function of height above sea level\nsub rho ( \\a ) { exp( -a / 8500 ) }\n\nsub height ( \\a, \\z, \\d ) {\n    # a = altitude of observer\n    # z = zenith angle (in degrees)\n    # d = distance along line of sight\n    my \\AA = RE + a;\n    sqrt( AA² + d² - 2*d*AA*cos((180-z)*DEG) ) - AA;\n}\n\n#| Integrates density along the line of sight\nsub column_density ( \\a, \\z ) {\n    my $sum = 0;\n    my $d   = 0;\n    while $d < FIN {\n        my \\delta = max(dd, (dd)*$d);  # Adaptive step size to avoid it taking forever\n        $sum += rho(height(a, z, $d + delta/2))*delta;\n        $d   += delta;\n    }\n    $sum;\n}\n\nsub airmass ( \\a, \\z ) {\n    column_density( a, z ) /\n    column_density( a, 0 )\n}\n\nsay 'Angle     0 m              13700 m';\nsay '------------------------------------';\nsay join \"\\n\", (0, 5 ... 90).hyper(:3batch).map: -> \\z {\n    sprintf \"%2d      %11.8f      %11.8f\", z, airmass(    0, z), airmass(13700, z);\n}\n\n```\n\nOutput:\n\n```\nAngle     0 m              13700 m\n------------------------------------\n 0       1.00000000       1.00000000\n 5       1.00380963       1.00380965\n10       1.01538466       1.01538475\n15       1.03517744       1.03517765\n20       1.06399053       1.06399093\n25       1.10305937       1.10306005\n30       1.15418974       1.15419083\n35       1.21998076       1.21998246\n40       1.30418931       1.30419190\n45       1.41234169       1.41234567\n50       1.55280404       1.55281025\n55       1.73875921       1.73876915\n60       1.99212000       1.99213665\n65       2.35199740       2.35202722\n70       2.89531368       2.89537287\n75       3.79582352       3.79596149\n80       5.53885809       5.53928113\n85      10.07896219      10.08115981\n90      34.32981136      34.36666557\n```"}]}
{"messages": [{"role": "user", "content": "The AKS algorithm for testing whether a number is prime is a polynomial-time algorithm based on an elementary theorem about Pascal triangles.\n\nThe theorem on which the test is based can be stated as follows:\n\n* a number   \n\n  p\n  {\\displaystyle {\\displaystyle p}}\n     is prime   if and only if   all the coefficients of the polynomial expansion of\n\n:   :   :   (\n            x\n            −\n            1\n\n            )\n\n            p\n            −\n            (\n\n            x\n\n            p\n            −\n            1\n            )\n            {\\displaystyle {\\displaystyle (x-1)^{p}-(x^{p}-1)}}\n\nare divisible by   \n\np\n{\\displaystyle {\\displaystyle p}}\n.\n\nExample\n\nUsing   \n\np\n=\n3\n{\\displaystyle {\\displaystyle p=3}}\n:\n\n```\n         (x-1)^3 - (x^3 - 1)\n            = (x^3 - 3x^2 + 3x - 1) - (x^3 - 1)\n            = -3x^2 + 3x\n\n```\n\nAnd all the coefficients are divisible by **3**,   so **3** is prime.\n\n|  |\n| --- |\n| **Note:** This task is **not** the AKS primality test.   It is an inefficient exponential time algorithm discovered in the late 1600s and used as an introductory lemma in the AKS derivation. |\n\nTask\n\n1. Create a function/subroutine/method that given   \n\n   p\n   {\\displaystyle {\\displaystyle p}}\n      generates the coefficients of the expanded polynomial representation of   \n\n   (\n   x\n   −\n   1\n\n   )\n\n   p\n   {\\displaystyle {\\displaystyle (x-1)^{p}}}\n   .\n2. Use the function to show here the polynomial expansions of   \n\n   (\n   x\n   −\n   1\n\n   )\n\n   p\n   {\\displaystyle {\\displaystyle (x-1)^{p}}}\n      for   \n\n   p\n   {\\displaystyle {\\displaystyle p}}\n      in the range   **0**   to at least   **7**,   inclusive.\n3. Use the previous function in creating another function that when given   \n\n   p\n   {\\displaystyle {\\displaystyle p}}\n      returns whether   \n\n   p\n   {\\displaystyle {\\displaystyle p}}\n      is prime using the theorem.\n4. Use your test to generate a list of all primes *under*   **35**.\n5. **As a stretch goal**,   generate all primes under   **50**   (needs integers larger than 31-bit).\n\nReferences\n\n* Agrawal-Kayal-Saxena (AKS) primality test (Wikipedia)\n* Fool-Proof Test for Primes - Numberphile (Video). The accuracy of this video is disputed -- at best it is an oversimplification."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015-12\n\nThe expansions are generated similarly to how most FP languages generate sequences that resemble Pascal's triangle, using a zipwith meta-operator (Z) with subtraction, applied between two lists that add a 0 on either end to the prior list. Here we define a constant infinite sequence using the ... sequence operator with a \"whatever\" endpoint. In fact, the second term [1,-1] could have been generated from the first term, but we put it in there for documentation so the reader can see what direction things are going.\n\nThe polyprime function pretty much reads like the original description. Is it \"so\" that the p'th expansion's coefficients are all divisible by p? The .[1 ..^ \\*/2] slice is done simply to weed out divisions by 1 or by factors we've already tested (since the coefficients are symmetrical in terms of divisibility). If we wanted to write polyprime even more idiomatically, we could have made it another infinite constant list that is just a mapping of the first list, but we decided that would just be showing off. :-)\n\n```\nconstant expansions = [1], [1,-1], -> @prior { [|@prior,0 Z- 0,|@prior] } ... *;\n\nsub polyprime($p where 2..*) { so expansions[$p].[1 ..^ */2].all %% $p }\n\n# Showing the expansions:\n\nsay ' p: (x-1)ᵖ';\nsay '-----------';\n\nsub super ($n) {\n    $n.trans: '0123456789'\n           => '⁰¹²³⁴⁵⁶⁷⁸⁹';\n}\n\nfor ^13 -> $d {\n    say $d.fmt('%2i: '), (\n        expansions[$d].kv.map: -> $i, $n {\n            my $p = $d - $i;\n            [~] gather {\n                take < + - >[$n < 0] ~ ' ' unless $p == $d;\n                take $n.abs                unless $p == $d > 0;\n                take 'x'                   if $p > 0;\n                take super $p - $i         if $p > 1;\n            }\n        }\n    )\n}\n\n#  And testing the function:\n\nprint \"\\nPrimes up to 100:\\n  { grep &polyprime, 2..100 }\\n\";\n\n```\n\nOutput:\n\n```\n p: (x-1)ᵖ\n-----------\n 0: 1\n 1: x - 1\n 2: x² - 2x + 1\n 3: x³ - 3x² + 3x - 1\n 4: x⁴ - 4x³ + 6x² - 4x + 1\n 5: x⁵ - 5x⁴ + 10x³ - 10x² + 5x - 1\n 6: x⁶ - 6x⁵ + 15x⁴ - 20x³ + 15x² - 6x + 1\n 7: x⁷ - 7x⁶ + 21x⁵ - 35x⁴ + 35x³ - 21x² + 7x - 1\n 8: x⁸ - 8x⁷ + 28x⁶ - 56x⁵ + 70x⁴ - 56x³ + 28x² - 8x + 1\n 9: x⁹ - 9x⁸ + 36x⁷ - 84x⁶ + 126x⁵ - 126x⁴ + 84x³ - 36x² + 9x - 1\n10: x¹⁰ - 10x⁹ + 45x⁸ - 120x⁷ + 210x⁶ - 252x⁵ + 210x⁴ - 120x³ + 45x² - 10x + 1\n11: x¹¹ - 11x¹⁰ + 55x⁹ - 165x⁸ + 330x⁷ - 462x⁶ + 462x⁵ - 330x⁴ + 165x³ - 55x² + 11x - 1\n12: x¹² - 12x¹¹ + 66x¹⁰ - 220x⁹ + 495x⁸ - 792x⁷ + 924x⁶ - 792x⁵ + 495x⁴ - 220x³ + 66x² - 12x + 1\n\nPrimes up to 100:\n  2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97\n```"}]}
{"messages": [{"role": "user", "content": "Some languages offer direct support for algebraic data types and pattern matching on them. While this of course can always be simulated with manual tagging and conditionals, it allows for terse code which is easy to read, and can represent the algorithm directly.\n\nTask\n\nAs an example, implement insertion in a red-black-tree.\n\nA red-black-tree is a binary tree where each internal node has a color attribute *red* or *black*. Moreover, no red node can have a red child, and every path from the root to an empty node must contain the same number of black nodes. As a consequence, the tree is balanced, and must be re-balanced after an insertion.\n\nReference\n\nRed-Black Trees in a Functional Setting"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.11\n\nRaku doesn't have algebraic data types (yet), but it does have pretty good pattern matching in multi signatures.\n\n```\nenum RedBlack <R B>;\n\nmulti balance(B,[R,[R,$a,$x,$b],$y,$c],$z,$d) { [R,[B,$a,$x,$b],$y,[B,$c,$z,$d]] }\nmulti balance(B,[R,$a,$x,[R,$b,$y,$c]],$z,$d) { [R,[B,$a,$x,$b],$y,[B,$c,$z,$d]] }\nmulti balance(B,$a,$x,[R,[R,$b,$y,$c],$z,$d]) { [R,[B,$a,$x,$b],$y,[B,$c,$z,$d]] }\nmulti balance(B,$a,$x,[R,$b,$y,[R,$c,$z,$d]]) { [R,[B,$a,$x,$b],$y,[B,$c,$z,$d]] }\n\nmulti balance($col, $a, $x, $b) { [$col, $a, $x, $b] }\n \nmulti ins( $x, @s [$col, $a, $y, $b] ) {\n    when $x before $y     { balance $col, ins($x, $a), $y, $b }\n    when $x after $y      { balance $col, $a, $y, ins($x, $b) }\n    default               { @s }\n}\nmulti ins( $x, Any:U ) { [R, Any, $x, Any] }\n\nmulti insert( $x, $s ) {\n    [B, |ins($x,$s)[1..3]];\n}\n\nsub MAIN {\n    my $t = Any;\n    $t = insert($_, $t) for (1..10).pick(*);\n    say $t.gist;\n}\n\n```\n\nThis code uses generic comparison operators before and after, so it should work on any ordered type.\n\nOutput:\n\n```\n[B [B [B (Any) 1 [R (Any) 2 (Any)]] 3 [B (Any) 4 [R (Any) 5 (Any)]]] 6 [B [B (Any) 7 (Any)] 8 [B [R (Any) 9 (Any)] 10 (Any)]]]\n```"}]}
{"messages": [{"role": "user", "content": "Given a text file of many lines, where fields within a line\nare delineated by a single 'dollar' character, write a program\nthat aligns each column of fields by ensuring that words in each\ncolumn are separated by at least one space.\nFurther, allow for each word in a column to be either left\njustified, right justified, or center justified within its column.\n\nUse the following text to test your programs:\n\n```\nGiven$a$text$file$of$many$lines,$where$fields$within$a$line$\nare$delineated$by$a$single$'dollar'$character,$write$a$program\nthat$aligns$each$column$of$fields$by$ensuring$that$words$in$each$\ncolumn$are$separated$by$at$least$one$space.\nFurther,$allow$for$each$word$in$a$column$to$be$either$left$\njustified,$right$justified,$or$center$justified$within$its$column.\n```\n\nNote that:\n\n1. The example input texts lines may, or may not, have trailing dollar characters.\n2. All columns should share the same alignment.\n3. Consecutive space characters produced adjacent to the end of lines are insignificant for the purposes of the task.\n4. Output text will be viewed in a mono-spaced font on a plain text editor or basic terminal.\n5. The minimum space between columns should be computed from the text and not hard-coded.\n6. It is *not* a requirement to add separating characters between or around columns.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nCall with parameter left (default), center or right.\n\n```\nmy @lines = \nq|Given$a$text$file$of$many$lines,$where$fields$within$a$line$\nare$delineated$by$a$single$'dollar'$character,$write$a$program\nthat$aligns$each$column$of$fields$by$ensuring$that$words$in$each$\ncolumn$are$separated$by$at$least$one$space.\nFurther,$allow$for$each$word$in$a$column$to$be$either$left$\njustified,$right$justified,$or$center$justified$within$its$column.\n|.lines;\n\nmy @widths;\n \nfor @lines { for .split('$').kv { @widths[$^key] max= $^word.chars; } }\nfor @lines { say |.split('$').kv.map: { (align @widths[$^key], $^word) ~ \" \"; } }\n \nsub align($column_width, $word, $aligment = @*ARGS[0]) {\n        my $lr = $column_width - $word.chars;\n        my $c  = $lr / 2;\n        given ($aligment) {\n                when \"center\" { \" \" x $c.ceiling ~ $word ~ \" \" x $c.floor }\n                when \"right\"  { \" \" x $lr        ~ $word                  }\n                default       {                    $word ~ \" \" x $lr      }\n        }\n}\n\n```\n\nOr a more functional version, called like `./align.p6 left input.txt`, which however only supports left and right alignment (not center):\n\n```\nsub MAIN ($alignment where 'left'|'right', $file) {\n    my @lines := $file.IO.lines.map(*.split('$').cache).cache;\n    my @widths = roundrobin(|@lines).map(*».chars.max);\n    my $align  = {left=>'-', right=>''}{$alignment};\n    my $format = @widths.map( '%' ~ ++$ ~ '$' ~ $align ~ * ~ 's' ).join(' ') ~ \"\\n\";\n    printf $format, |$_ for @lines;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "An aliquot sequence of a positive integer K is defined recursively as the first member\nbeing K and subsequent members being the sum of the Proper divisors of the previous term.\n\n:   * If the terms eventually reach 0 then the series for K is said to **terminate**.\n\n:   There are several classifications for non termination:\n\n    * If the second term is K then all future terms are also K and so the sequence repeats from the first term with period 1 and K is called **perfect**.\n    * If the third term *would* be repeating K then the sequence repeats with period 2 and K is called **amicable**.\n    * If the Nth term *would* be repeating K for the first time, with N > 3 then the sequence repeats with period N - 1 and K is called **sociable**.\n:   Perfect, amicable and sociable numbers eventually repeat the original number K; there are other repetitions...\n\n    * Some K have a sequence that eventually forms a periodic repetition of period 1 but of a number other than K, for example 95 which forms the sequence `95, 25, 6, 6, 6, ...` such K are called **aspiring**.\n    * K that have a sequence that eventually forms a periodic repetition of period >= 2 but of a number other than K, for example 562 which forms the sequence `562, 284, 220, 284, 220, ...` such K are called **cyclic**.\n\n:   And finally:\n\n    * Some K form aliquot sequences that are not known to be either terminating or periodic; these K are to be called **non-terminating**.   \n      For the purposes of this task, K is to be classed as non-terminating if it has not been otherwise classed after generating **16** terms or if any term of the sequence is greater than 2\\*\\*47 = 140,737,488,355,328.\n\nTask\n\n1. Create routine(s) to generate the aliquot sequence of a positive integer enough to classify it according to the classifications given above.\n2. Use it to display the classification and sequences of the numbers one to ten inclusive.\n3. Use it to show the classification and sequences of the following integers, in order:\n\n:   :   11, 12, 28, 496, 220, 1184, 12496, 1264460, 790, 909, 562, 1064, 1488, and optionally 15355717786080.\n\nShow all output on this page.\n\nRelated tasks\n\n* Abundant, deficient and perfect number classifications. (Classifications from only the first two members of the whole sequence).\n* Proper divisors\n* Amicable pairs\n\nExternal links\n\n* An amazing thing about 276, Numberphile"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.10\n\n```\nsub propdivsum (\\x) {\n    my @l = x > 1;\n    (2 .. x.sqrt.floor).map: -> \\d {\n        unless x % d { my \\y = x div d; y == d ?? @l.push: d !! @l.append: d,y }\n    }\n    sum @l;\n}\n\nmulti quality (0,1)  { 'perfect ' }\nmulti quality (0,2)  { 'amicable' }\nmulti quality (0,$n) { \"sociable-$n\" }\nmulti quality ($,1)  { 'aspiring' }\nmulti quality ($,$n) { \"cyclic-$n\" }\n\nsub aliquotidian ($x) {\n    my %seen;\n    my @seq = $x, &propdivsum ... *;\n    for 0..16 -> $to {\n        my $this = @seq[$to] or return \"$x\\tterminating\\t[@seq[^$to]]\";\n        last if $this > 140737488355328;\n        if %seen{$this}:exists {\n            my $from = %seen{$this};\n            return \"$x\\t&quality($from, $to-$from)\\t[@seq[^$to]]\";\n        }\n        %seen{$this} = $to;\n    }\n    \"$x non-terminating\\t[{@seq}]\";\n}\n\naliquotidian($_).say for flat\n    1..10,\n    11, 12, 28, 496, 220, 1184, 12496, 1264460,\n    790, 909, 562, 1064, 1488,\n    15355717786080;\n\n```\n\nOutput:\n\n```\n1\tterminating\t[1]\n2\tterminating\t[2 1]\n3\tterminating\t[3 1]\n4\tterminating\t[4 3 1]\n5\tterminating\t[5 1]\n6\tperfect \t[6]\n7\tterminating\t[7 1]\n8\tterminating\t[8 7 1]\n9\tterminating\t[9 4 3 1]\n10\tterminating\t[10 8 7 1]\n11\tterminating\t[11 1]\n12\tterminating\t[12 16 15 9 4 3 1]\n28\tperfect \t[28]\n496\tperfect \t[496]\n220\tamicable\t[220 284]\n1184\tamicable\t[1184 1210]\n12496\tsociable-5\t[12496 14288 15472 14536 14264]\n1264460\tsociable-4\t[1264460 1547860 1727636 1305184]\n790\taspiring\t[790 650 652 496]\n909\taspiring\t[909 417 143 25 6]\n562\tcyclic-2\t[562 284 220]\n1064\tcyclic-2\t[1064 1336 1184 1210]\n1488 non-terminating\t[1488 2480 3472 4464 8432 9424 10416 21328 22320 55056 95728 96720 236592 459792 881392 882384 1474608 ...]\n15355717786080 non-terminating\t[15355717786080 44534663601120 144940087464480 ...]\n\n```"}]}
{"messages": [{"role": "user", "content": "The Almkvist-Giullera formula for calculating \n\n1\n\nπ\n\n2\n{\\displaystyle {\\displaystyle {\\frac {1}{\\pi ^{2}}}}}\n is based on the Calabi-Yau\ndifferential equations of order 4 and 5,   which were originally used to describe certain manifolds\nin string theory.\n\nThe formula is:\n\n:   1\n\n    π\n\n    2\n    =\n    32\n\n    ∑\n\n    n\n    =\n    0\n\n    ∞\n\n    (\n    6\n    n\n    )\n    !\n\n    3\n    ⋅\n    n\n\n    !\n\n    6\n    (\n    532\n\n    n\n\n    2\n    +\n    126\n    n\n    +\n    9\n    )\n\n\n    1\n\n    10\n\n    6\n    n\n    +\n    3\n    {\\displaystyle {\\displaystyle {\\frac {1}{\\pi ^{2}}}=32\\sum \\_{n=0}^{\\infty }{\\frac {(6n)!}{3\\cdot n!^{6}}}(532n^{2}+126n+9){\\frac {1}{10^{6n+3}}}}}\n\nThis formula can be used to calculate the constant \n\n1\n\nπ\n\n2\n{\\displaystyle {\\displaystyle {\\frac {1}{\\pi ^{2}}}}}\n,   and thus to calculate \n\nπ\n{\\displaystyle {\\displaystyle \\pi }}\n.\n\nNote that, because the product of all terms but the power of 1000 can be calculated as an integer,\nthe terms in the series can be separated into a large integer term:\n\n:   32\n    (\n    6\n    n\n    )\n    !\n\n    3\n    ⋅\n    n\n\n    !\n\n    6\n    (\n    532\n\n    n\n\n    2\n    +\n    126\n    n\n    +\n    9\n    )\n    {\\displaystyle {\\displaystyle {\\frac {32(6n)!}{3\\cdot n!^{6}}}(532n^{2}+126n+9)}}\n\nmultiplied by a negative integer power of 10:\n\n:   10\n\n    −\n    (\n    6\n    n\n    +\n    3\n    )\n    {\\displaystyle {\\displaystyle 10^{-(6n+3)}}}\n\nTask\n:   * Print the integer portions (the starred formula, which is without the power of 1000 divisor) of the first 10 terms of the series.\n    * Use the complete formula to calculate and print \n\n      π\n      {\\displaystyle {\\displaystyle \\pi }}\n       to 70 decimal digits of precision.\n\nReference\n:   * Gert Almkvist and Jesús Guillera, Ramanujan-like series for 1/π2 and string theory, Experimental Mathematics, 21 (2012), page 2, formula 1."}, {"role": "assistant", "content": "```\n# 20201013 Raku programming solution\n\nuse BigRoot;\nuse Rat::Precise;\nuse experimental :cached;\n\nBigRoot.precision = 75 ;\nmy $Precision     = 70 ;\nmy $AGcache       =  0 ;\n\nsub postfix:<!>(Int $n --> Int) is cached { [*] 1 .. $n }\n\nsub Integral(Int $n --> Int) is cached {\n   (2⁵*(6*$n)! * (532*$n² + 126*$n + 9)) div (3*($n!)⁶)\n}\n\nsub A-G(Int $n --> FatRat) is cached { # Almkvist-Giullera\n   Integral($n).FatRat / (10**(6*$n + 3)).FatRat\n}\n\nsub Pi(Int $n --> Str) {\n   (1/(BigRoot.newton's-sqrt: $AGcache += A-G $n)).precise($Precision)\n}\n\nsay \"First 10 integer portions : \";\nsay $_, \"\\t\", Integral $_ for ^10;\n\nmy $target = Pi my $Nth = 0;\n\nloop { $target eq ( my $next = Pi ++$Nth ) ?? ( last ) !! $target = $next }\n\nsay \"π to $Precision decimal places is :\\n$target\"\n\n```\n\nOutput:\n\n```\nFirst 10 integer portions :\n0       96\n1       5122560\n2       190722470400\n3       7574824857600000\n4       312546150372456000000\n5       13207874703225491420651520\n6       567273919793089083292259942400\n7       24650600248172987140112763715584000\n8       1080657854354639453670407474439566400000\n9       47701779391594966287470570490839978880000000\nπ to 70 decimal places is :\n3.1415926535897932384626433832795028841971693993751058209749445923078164\n```"}]}
{"messages": [{"role": "user", "content": "A   k-Almost-prime   is a natural number   \n\nn\n{\\displaystyle {\\displaystyle n}}\n   that is the product of   \n\nk\n{\\displaystyle {\\displaystyle k}}\n   (possibly identical) primes.\n\nExample\n\n1-almost-primes,   where   \n\nk\n=\n1\n{\\displaystyle {\\displaystyle k=1}}\n,   are the prime numbers themselves.\n  \n2-almost-primes,   where   \n\nk\n=\n2\n{\\displaystyle {\\displaystyle k=2}}\n,   are the   semiprimes.\n\nTask\n\nWrite a function/method/subroutine/... that generates k-almost primes and use it to create a table here of the first ten members of k-Almost primes for   \n\n1\n≤\nK\n≤\n5\n{\\displaystyle {\\displaystyle 1\\leq K\\leq 5}}\n.\n\nRelated tasks\n\n* Semiprime\n* Category:Prime Numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: C\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub is-k-almost-prime($n is copy, $k) returns Bool {\n    loop (my ($p, $f) = 2, 0; $f < $k && $p*$p <= $n; $p++) {\n        $n /= $p, $f++ while $n %% $p;\n    }\n    $f + ($n > 1) == $k;\n}\n\nfor 1 .. 5 -> $k {\n    say ~.[^10]\n        given grep { is-k-almost-prime($_, $k) }, 2 .. *\n}\n\n```\n\nOutput:\n\n```\n2 3 5 7 11 13 17 19 23 29\n4 6 9 10 14 15 21 22 25 26\n8 12 18 20 27 28 30 42 44 45\n16 24 36 40 54 56 60 81 84 88\n32 48 72 80 108 112 120 162 168 176\n```\n\nHere is a solution with identical output based on the factors routine from Count\\_in\\_factors#Raku (to be included manually until we decide where in the distribution to put it).\n\n```\nconstant @primes = 2, |(3, 5, 7 ... *).grep: *.is-prime;\n\nmulti sub factors(1) { 1 }\nmulti sub factors(Int $remainder is copy) {\n    gather for @primes -> $factor {\n        # if remainder < factor², we're done\n        if $factor * $factor > $remainder {\n            take $remainder if $remainder > 1;\n            last;\n        }\n        # How many times can we divide by this prime?\n        while $remainder %% $factor {\n            take $factor;\n            last if ($remainder div= $factor) === 1;\n        }\n    }\n}\n\nconstant @factory = lazy 0..* Z=> flat (0, 0, map { +factors($_) }, 2..*);\n\nsub almost($n) { map *.key, grep *.value == $n, @factory }\n\nput almost($_)[^10] for 1..5;\n\n```"}]}
{"messages": [{"role": "user", "content": "An alternade is a word whose alternating letters themselves form two words.\n\nExample\n\nThe word **lounge** contains the word **lug** (**l**o**u**n**g**e) and the word **one** (l**o**u**n**g**e**).\n\nFor a word to be an alternade, all its letters must be used.\n\nThe two words that form an alternade don't need to be the same length; for example, the word **board** is an alternade made up of the words **bad** (**b**o**a**r**d**) and **or** (b**o**a**r**d).\n\nTask\n\nPrint out every alternade in unixdict.txt whose length is **6** or greater, also showing both the words that make up the alternade.\n\nSee also\n:   * Wikipedia entry:   Alternade\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nunit sub MAIN ($file = 'unixdict.txt', :$min = 6);\n\nmy %words = $file.IO.slurp.words.map: * => 1;\n\nmy @alternades;\n\nfor %words {\n    next if .key.chars < $min;\n    my @letters = .key.comb;\n    my @alts = @letters[0,2 … *].join, @letters[1,3 … *].join;\n    @alternades.push(.key => @alts) if %words{@alts[0]} && %words{@alts[1]};\n}\n\n@alternades.=sort;\n\nsay \"{+@alternades} alternades longer than {$min-1} characters found in $file:\";\n\n.say for @alternades > 10\n  ?? (flat @alternades.head(5), '...', @alternades.tail(5))\n  !! @alternades;\n\n```\n\nOutput:\n\n```\n58 alternades longer than 5 characters found in unixdict.txt:\naccost => [acs cot]\naccuse => [acs cue]\nafield => [ail fed]\nagleam => [ala gem]\nalcott => [act lot]\n...\ntriode => [tid roe]\ntriune => [tin rue]\ntroupe => [top rue]\ntruant => [tun rat]\ntwirly => [til wry]\n```"}]}
{"messages": [{"role": "user", "content": "Define and give an example of the Amb operator.\n\nThe Amb operator (short for \"ambiguous\") expresses nondeterminism. This doesn't refer to randomness (as in \"nondeterministic universe\") but is closely related to the term as it is used in automata theory (\"non-deterministic finite automaton\").\n\nThe Amb operator takes a variable number of expressions (or values if that's simpler in the language) and yields a correct one which will satisfy a constraint in some future computation, thereby avoiding failure.\n\nProblems whose solution the Amb operator naturally expresses can be approached with other tools, such as explicit nested iterations over data sets, or with pattern matching. By contrast, the Amb operator appears integrated into the language. Invocations of Amb are not wrapped in any visible loops or other search patterns; they appear to be independent.\n\nEssentially Amb(x, y, z) splits the computation into three possible futures: a future in which the value x is yielded, a future in which the value y is yielded and a future in which the value z is yielded. The future which leads to a successful subsequent computation is chosen. The other \"parallel universes\" somehow go away. Amb called with no arguments fails.\n\nFor simplicity, one of the domain values usable with Amb may denote failure, if that is convenient. For instance, it is convenient if a Boolean false denotes failure, so that Amb(false) fails, and thus constraints can be expressed using Boolean expressions like Amb(x \\* y == 8) which unless x and y add to four.\n\nA pseudo-code program which satisfies this constraint might look like:\n\n```\nlet x = Amb(1, 2, 3)\nlet y = Amb(7, 6, 4, 5)\nAmb(x * y = 8)\nprint x, y\n```\n\nThe output is `2 4` because `Amb(1, 2, 3)` correctly chooses the future in which `x` has value `2`, `Amb(7, 6, 4, 5)` chooses `4` and consequently `Amb(x * y = 8)` produces a success.\n\nAlternatively, failure could be represented using strictly `Amb()`:\n\n```\nunless x * y = 8 do Amb()\n```\n\nOr else Amb could take the form of two operators or functions: one for producing values and one for enforcing constraints:\n\n```\nlet x = Ambsel(1, 2, 3)\nlet y = Ambsel(4, 5, 6)\nAmbassert(x * y = 8)\nprint x, y\n```\n\nwhere `Ambassert` behaves like `Amb()` if the Boolean expression is false, otherwise it allows the future computation to take place, without yielding any value.\n\nThe task is to somehow implement Amb, and demonstrate it with a program which chooses one word from each of the following four sets of character strings to generate a four-word sentence:\n\n1. `\"the\" \"that\" \"a\"`\n2. `\"frog\" \"elephant\" \"thing\"`\n3. `\"walked\" \"treaded\" \"grows\"`\n4. `\"slowly\" \"quickly\"`\n\nThe constraint to be satisfied is that the last character of each word (other than the last) is the same as the first character of its successor.\n\nThe only successful sentence is `\"that thing grows slowly\"`; other combinations do not satisfy the constraint and thus fail.\n\nThe goal of this task isn't to simply process the four lists of words with explicit, deterministic program flow such as nested iteration, to trivially demonstrate the correct output. The goal is to implement the Amb operator, or a facsimile thereof that is possible within the language limitations."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Using Junctions\n\nJunctions are a construct that behave similarly to the wanted Amb operator. The only difference is, that they don't preserve the state that was True inside any control structure (like an if).\n\nThere is currently a trick, how you only get the \"true\" values from a Junction for any test: return from a subroutine. Because of DeMorgans Law, you'll have to switch and and or, since you want to return on falseness. Just look at 'all' in combination with the sub(){return unless test} as the amb operator.\n\n```\n#| an array of four words, that have more possible values. \n#| Normally we would want `any' to signify we want any of the values, but well negate later and thus we need `all'\nmy @a =\n(all «the that a»),\n(all «frog elephant thing»),\n(all «walked treaded grows»),\n(all «slowly quickly»);\n\nsub test (Str $l, Str $r) {\n    $l.ends-with($r.substr(0,1))\n}\n\n(sub ($w1, $w2, $w3, $w4){\n  # return if the values are false\n  return unless [and] test($w1, $w2), test($w2, $w3),test($w3, $w4);\n  # say the results. If there is one more Container layer around them this doesn't work, this is why we need the arguments here.\n  say \"$w1 $w2 $w3 $w4\"\n})(|@a); # supply the array as argumetns\n\n```\n\n### Using the Regex Engine\n\nBy using a reduction metaoperator to calculate all possible combinations, we can Amb any number of sets with no arbitrary limits. A simple regex pattern can find out if a certain combination is correct or not.\n\n```\n# The Task #\nmy @firstSet  = «the that a»;\nmy @secondSet = «frog elephant thing»;\nmy @thirdSet  = «walked treaded grows»;\nmy @fourthSet = «slowly quickly»;\n\n.say for doAmb [@firstSet, @secondSet, @thirdSet, @fourthSet];\n\n\nsub doAmb( @lol ) {\t# Takes out the correct sentences.\n\tmy @sentences = map *.join(\" \"), [X] @lol;\n\tgrep &isAmb, @sentences;\n}\n\nsub isAmb( $sentence ) {\t# Checks `$sentence` for correctness.\n\t$sentence !~~ / (.) \" \" (.)\t<!{$0 eq $1}> /\t# <https://docs.raku.org/language/regexes#Regex_boolean_condition_check>\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Two integers \n\nN\n{\\displaystyle {\\displaystyle N}}\n and \n\nM\n{\\displaystyle {\\displaystyle M}}\n are said to be amicable pairs if \n\nN\n≠\nM\n{\\displaystyle {\\displaystyle N\\neq M}}\n and the sum of the proper divisors of \n\nN\n{\\displaystyle {\\displaystyle N}}\n (\n\ns\nu\nm\n(\n\np\nr\no\np\nD\ni\nv\ns\n(\nN\n)\n)\n{\\displaystyle {\\displaystyle \\mathrm {sum} (\\mathrm {propDivs} (N))}}\n) \n\n=\nM\n{\\displaystyle {\\displaystyle =M}}\n as well as \n\ns\nu\nm\n(\n\np\nr\no\np\nD\ni\nv\ns\n(\nM\n)\n)\n=\nN\n{\\displaystyle {\\displaystyle \\mathrm {sum} (\\mathrm {propDivs} (M))=N}}\n.\n\nExample\n\n**1184** and **1210** are an amicable pair, with proper divisors:\n\n* 1, 2, 4, 8, 16, 32, 37, 74, 148, 296, 592   and\n* 1, 2, 5, 10, 11, 22, 55, 110, 121, 242, 605   respectively.\n\nTask\n\nCalculate and show here the Amicable pairs below 20,000; (there are eight).\n\nRelated tasks\n\n* Proper divisors\n* Abundant, deficient and perfect number classifications\n* Aliquot sequence classifications and its amicable *classification*."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03.1\n\n```\nsub propdivsum (\\x) {\n    my @l = 1 if x > 1;\n    (2 .. x.sqrt.floor).map: -> \\d {\n        unless x % d { @l.push: d; my \\y = x div d; @l.push: y if y != d }\n    }\n    sum @l\n}\n\n(1..20000).race.map: -> $i {\n    my $j = propdivsum($i);\n    say \"$i $j\" if $j > $i and $i == propdivsum($j);\n}\n\n```\n\nOutput:\n\n```\n220 284\n1184 1210\n2620 2924\n5020 5564\n6232 6368\n10744 10856\n12285 14595\n17296 18416\n```"}]}
{"messages": [{"role": "user", "content": "An anadrome is similar to a palindrome except, rather than spelling the *same* word or phrase when reversed, it spells a *different* word or phrase. An anadrome is a special case of an anagram.\n\n*Anadrome is a portmanteau of the words anagram and palindrome.*\n\nFor instance, **regal** and **lager** are anadromes.\n\nTask\n\nUsing the words.txt file from https://github.com/dwyl/english-words, find and display all of the anadrome pairs with more than 6 characters.\n\nEach word pair should only show up one time in the list.\n\nAlternate download location."}, {"role": "assistant", "content": "```\nmy @words = 'words.txt'.IO.slurp.words.grep: *.chars > 6;\n\nmy %words = @words.pairs.invert;\n\nput join \"\\n\", @words.map: { %words{$_}:delete and sprintf \"%10s ↔ %s\", $_, .flip if ($_ ne .flip) && %words{.flip} }\n\n```\n\nOutput:\n\n```\n   amaroid ↔ diorama\n   degener ↔ reneged\n   deifier ↔ reified\n   deliver ↔ reviled\n   dessert ↔ tressed\n  desserts ↔ stressed\n   deviler ↔ relived\n  dioramas ↔ samaroid\n   gateman ↔ nametag\n   leveler ↔ relevel\n   pat-pat ↔ tap-tap\n  redrawer ↔ rewarder\n   reknits ↔ stinker\n   relever ↔ reveler\n   reliver ↔ reviler\n   revotes ↔ setover\n   sallets ↔ stellas\n```"}]}
{"messages": [{"role": "user", "content": "There are already other tasks relating to *finding* **existing** anagrams. This one is about **creating** them.\n\nWrite a (set of) routine(s) that, when given a word list to work from, and word or phrase as a seed, generates anagrams of that word or phrase. Feel free to ignore letter case, white-space, punctuation and symbols. Probably best to avoid numerics too, but feel free to include them if that floats your boat.\n\nIt is not necessary to (only) generate anagrams that make sense. That is a hard problem, much more difficult than can realistically be done in a small program; though again, if you feel the need, you are invited to amaze your peers.\n\nIn general, try to form phrases made up of longer words. Feel free to manually reorder output words or add punctuation and/or case changes to get a better meaning.\n\nTask\n\nWrite an anagram generator program.\n\nUse a publicly and freely available word file as its word list.\n\n:   unixdict.txt from http://wiki.puzzlers.org is a popular, though somewhat limited choice.\n:   A much larger word list: words\\_alpha.txt file from https://github.com/dwyl/english-words. May be better as far as coverage but may return unreasonably large results.\n\nUse your program to generate anagrams of some words / phrases / names of your choice. No need to show **all** the output. It is likely to be very large. Just pick out one or two of the best results and show the seed word/phrase and anagram.\n\nFor example, show the seed and one or two of the best anagrams:\n\n:   **Purefox -> Fur expo**\n:   **Petelomax -> Metal expo**\n\n*.oO(hmmm. Seem to be detecting something of a trend here...)*"}, {"role": "assistant", "content": "Using the unixdict.txt word file by default.\n\n```\nunit sub MAIN ($in is copy = '', :$dict = 'unixdict.txt');\n\nsay 'Enter a word or phrase to be anagramed. (Loading dictionary)' unless $in.chars;\n\n# Load the words into a word / Bag hash\nmy %words = $dict.IO.slurp.lc.words.race.map: { .comb(/\\w/).join => .comb(/\\w/).Bag };\n\n# Declare some globals\nmy ($phrase, $count, $bag);\n\nloop {\n    ($phrase, $count, $bag) = get-phrase;\n    find-anagram Hash.new: %words.grep: { .value ⊆ $bag };\n}\n\nsub get-phrase {\n    my $prompt = $in.chars ?? $in !! prompt \"\\nword or phrase? (press Enter to quit) \";\n    $in = '';\n    exit unless $prompt;\n    $prompt,\n    +$prompt.comb(/\\w/),\n    $prompt.lc.comb(/\\w/).Bag;\n}\n\nsub find-anagram (%subset, $phrase is copy = '', $last = Inf) {\n    my $remain = $bag ∖ $phrase.comb(/\\w/).Bag;        # Find the remaining letters\n    my %filtered = %subset.grep: { .value ⊆ $remain }; # Find words using the remaining letters\n    my $sofar = +$phrase.comb(/\\w/);                   # Get the count of the letters used so far\n    for %filtered.sort: { -.key.chars, ~.key } {       # Sort by length then alphabetically then iterate\n        my $maybe = +.key.comb(/\\w/);                  # Get the letter count of the maybe addition\n        next if $maybe > $last;                        # Next if it is longer than last - only consider descending length words\n        next if $maybe == 1 and $last == 1;            # Only allow one one character word\n        next if $count - $sofar - $maybe > $maybe;     # Try to balance word lengths\n        if $sofar + $maybe == $count {                 # It's an anagram\n            say $phrase ~ ' ' ~ .key and next;         # Display it and move on\n        } else {                                       # Not yet a full anagram, recurse\n            find-anagram %filtered, $phrase ~ ' ' ~ .key, $maybe;\n        }\n    }\n}\n\n```\n\nTruncated to only show the best few as subjectively determined by me:\n\n*Punctuation, capitalization and (in some cases) word order manually massaged.*\n\n```\nEnter a word or phrase to be anagramed. (Loading dictionary)\n\nword or phrase? (press Enter to quit) Rosettacode\ndoctor tease\n\nword or phrase? (press Enter to quit) thundergnat\ndragnet hunt\nGent? Nah, turd.\n\nword or phrase? (press Enter to quit) Clint Eastwood\ndowncast eliot\nI contest waldo\nnose to wildcat\n```"}]}
{"messages": [{"role": "user", "content": "When two or more words are composed of the same characters, but in a different order, they are called anagrams.\n\nTask\n\nUsing the word list at   http://wiki.puzzlers.org/pub/wordlists/unixdict.txt,\n  \nfind the sets of words that share the same characters that contain the most words in them.\n\nRelated tasks\n\n* |  |  |  |  |  |  |\n  | --- | --- | --- | --- | --- | --- |\n  | | Word plays | | | --- | --- | |  | | Ordered words  Palindrome detection  Semordnilap  Anagrams  Anagrams/Deranged anagrams | | |\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.08\n\n```\nmy @anagrams = 'unixdict.txt'.IO.words.classify(*.comb.sort.join).values;\n \nmy $max = @anagrams».elems.max;\n\n.put for @anagrams.grep(*.elems == $max);\n```\n\nOutput:\n\n```\ncaret carte cater crate trace\nangel angle galen glean lange\nalger glare lager large regal\nelan lane lean lena neal\nevil levi live veil vile\nabel able bale bela elba\n\n```\n\nJust for the fun of it, here's a one-liner that uses no temporaries. Since it would be rather long, we've oriented it vertically:\n\n**Works with**: Rakudo version 2016.08\n\n```\n.put for                         # print each element of the array made this way:\n    'unixdict.txt'.IO.words      # load words from file\n    .classify(*.comb.sort.join)  # group by common anagram\n    .classify(*.value.elems)     # group by number of anagrams in a group\n    .max(*.key).value            # get the group with highest number of anagrams\n    .map(*.value)                # get all groups of anagrams in the group just selected\n```"}]}
{"messages": [{"role": "user", "content": "Two or more words are said to be anagrams if they have the same characters, but in a different order.\n\nBy analogy with derangements we define a *deranged anagram* as two words with the same characters, but in which the same character does *not* appear in the same position in both words.\n\nTask\n\nUse the word list at unixdict to find and display the longest deranged anagram.\n\nRelated\n\n* Permutations/Derangements\n* Best shuffle\n\n* |  |  |  |  |  |  |\n  | --- | --- | --- | --- | --- | --- |\n  | | Word plays | | | --- | --- | |  | | Ordered words  Palindrome detection  Semordnilap  Anagrams  Anagrams/Deranged anagrams | | |\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.08\n\n```\nmy @anagrams = 'unixdict.txt'.IO.words\n    .map(*.comb.cache)             # explode words into lists of characters\n    .classify(*.sort.join).values  # group words with the same characters\n    .grep(* > 1)                   # only take groups with more than one word\n    .sort(-*[0])                   # sort by length of the first word\n;\n\nfor @anagrams -> @group {\n    for @group.combinations(2) -> [@a, @b] {\n        if none @a Zeq @b {\n            say \"{@a.join}   {@b.join}\";\n            exit;\n        }\n    }\n}\n\n```\n\nOutput:\n\n```\nexcitation   intoxicate\n```"}]}
{"messages": [{"role": "user", "content": "Anaprimes are prime numbers that are anagrams of each other, i.e. they use exactly the same digits with the same frequency but in a different order.\n\nAnaprimes are *very* common. To illustrate this, we will investigate the sizes of the equivalence classes defined by the \"is an anagram of\" relation.\n\nFor example, the equivalence class of 149 has four anaprimes: {149, 419, 491, 941}. It turns out that there is no larger equivalence class of 3-digit anaprimes.\n\nTask\n\n* Find prime numbers that are anagrams of each other.\n* Find the **largest** anagram group of prime numbers and display the count, and minimum and maximum members for prime numbers:\n  + up to three digits long (before 1,000)\n  + up to four digits long (before 10,000)\n  + up to five digits long (before 100,000)\n  + up to six digits long (before 1,000,000)\n\nStretch\n\n* Find the **largest** anagram group and display the count, and smallest and largest members for prime numbers:\n  + up to seven digits long (before 10,000,000)\n  + up to eight digits long (before 100,000,000)\n  + up to nine digits long (before 1,000,000,000)\n  + ???!\n\nRelated tasks\n\n* Circular primes * Ormiston pairs * Emirp primes"}, {"role": "assistant", "content": "9 digit is slooow. I didn't have the patience for 10.\n\n```\nuse Lingua::EN::Numbers;\nuse Math::Primesieve;\nuse List::Allmax;\n\nmy $p = Math::Primesieve.new;\n\nfor 3 .. 9 {\n    my @largest = $p.primes(10**($_-1), 10**$_).classify(*.comb.sort.join).List.&all-max(:by(+*.value)).values;\n\n    put \"\\nLargest group of anaprimes before {cardinal 10 ** $_}: {+@largest[0].value} members.\";\n    put 'First: ', ' Last: ' Z~ .value[0, *-1] for sort @largest;\n}\n\n```\n\nOutput:\n\n```\nLargest group of anaprimes before one thousand: 4 members.\nFirst: 149  Last: 941\nFirst: 179  Last: 971\nFirst: 379  Last: 937\n\nLargest group of anaprimes before ten thousand: 11 members.\nFirst: 1237  Last: 7321\nFirst: 1279  Last: 9721\n\nLargest group of anaprimes before one hundred thousand: 39 members.\nFirst: 13789  Last: 98731\n\nLargest group of anaprimes before one million: 148 members.\nFirst: 123479  Last: 974213\n\nLargest group of anaprimes before ten million: 731 members.\nFirst: 1235789  Last: 9875321\n\nLargest group of anaprimes before one hundred million: 4,333 members.\nFirst: 12345769  Last: 97654321\n\nLargest group of anaprimes before one billion: 26,519 members.\nFirst: 102345697  Last: 976542103\n```"}]}
{"messages": [{"role": "user", "content": "Finding the angle between two bearings is often confusing.[1]\n\nTask\n\nFind the angle which is the result of the subtraction **b2 - b1**, where **b1** and **b2** are the bearings.\n\nInput bearings are expressed in the range   **-180**   to   **+180**   degrees.\n  \nThe  result  is also expressed in the range   **-180**   to   **+180**   degrees.\n\nCompute the angle for the following pairs:\n\n* 20 degrees (**b1**) and 45 degrees (**b2**)\n* -45 and 45\n* -85 and 90\n* -95 and 90\n* -45 and 125\n* -45 and 145\n* 29.4803 and -88.6381\n* -78.3251 and -159.036\n\nOptional extra\n\nAllow the input bearings to be any (finite) value.\n\nTest cases\n\n* -70099.74233810938 and 29840.67437876723\n* -165313.6666297357 and 33693.9894517456\n* 1174.8380510598456 and -154146.66490124757\n* 60175.77306795546 and 42213.07192354373"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.11\n\n```\nsub infix:<∠> (Real $b1, Real $b2) {\n   (my $b = ($b2 - $b1 + 720) % 360) > 180 ?? $b - 360 !! $b;\n}\n\nfor 20, 45,\n   -45, 45,\n   -85, 90,\n   -95, 90,\n   -45, 125,\n   -45, 145,\n   29.4803, -88.6381,\n   -78.3251, -159.036,\n   -70099.74233810938, 29840.67437876723,\n   -165313.6666297357, 33693.9894517456,\n   1174.8380510598456, -154146.66490124757,\n   60175.77306795546, 42213.07192354373\n\n  -> $b1, $b2 { printf \"%10.2f %10.2f = %8.2f\\n\", $b1, $b2, $b1 ∠ $b2 }\n\n```\n\nOutput:\n\n```\n     20.00      45.00 =    25.00\n    -45.00      45.00 =    90.00\n    -85.00      90.00 =   175.00\n    -95.00      90.00 =  -175.00\n    -45.00     125.00 =   170.00\n    -45.00     145.00 =  -170.00\n     29.48     -88.64 =  -118.12\n    -78.33    -159.04 =   -80.71\n -70099.74   29840.67 =  -139.58\n-165313.67   33693.99 =   -72.34\n   1174.84 -154146.66 =  -161.50\n  60175.77   42213.07 =    37.30\n```"}]}
{"messages": [{"role": "user", "content": "This task is about the normalization and/or conversion of (geometric) angles using\nsome common scales.\n\nThe angular scales that will be used in this task are:\n\n:   :   * degree\n        * gradian\n        * mil\n        * radian\n\nDefinitions\n\nThe angular scales used or referenced here:\n\n:   :   * **turn**   is a full turn or 360 degrees, also shown as 360º\n        * **degree**   is   **1/360**   of a turn\n        * **gradian**   is   **1/400**   of a turn\n        * **mil**   is   **1/6400**   of a turn\n        * **radian**   is   **1/2\n\n          π\n          {\\displaystyle {\\displaystyle \\pi }}**   of a turn   (or   **0.5/π\n          {\\displaystyle {\\displaystyle \\pi }}**   of a turn)\n\nOr, to put it another way,   for a full circle:\n\n:   :   * there are   **360**   degrees\n        * there are   **400**   gradians\n        * there are   **6,400**   mils\n        * there are   **2\n\n          π\n          {\\displaystyle {\\displaystyle \\pi }}**   radians   (roughly equal to **6.283+**)\n\nA   **mil**   is approximately equal to a   *milliradian*   (which is   **1/1000**   of a radian).\n\nThere is another definition of a   **mil**   which\nis   **1/1000**   of a radian   ─── this\ndefinition won't be used in this Rosetta Code task.\n\n**Turns**   are sometimes known or shown as:\n\n:   :   :   * turn(s)\n            * 360 degrees\n            * unit circle\n            * a (full) circle\n\n**Degrees**   are sometimes known or shown as:\n\n:   :   :   * degree(s)\n            * deg\n            * º       (a symbol)\n            * °       (another symbol)\n\n**Gradians**   are sometimes known or shown as:\n\n:   :   :   * gradian(s)\n            * grad(s)\n            * grade(s)\n            * gon(s)\n            * metric degree(s)\n            * (Note that   **centigrade**   was used for 1/100th of a grade, see the note below.)\n\n**Mils**   are sometimes known or shown as:\n\n:   :   :   * mil(s)\n            * NATO mil(s)\n\n**Radians**   are sometimes known or shown as:\n\n:   :   :   * radian(s)\n            * rad(s)\n\nNotes\n\nIn continental Europe, the French term   **centigrade**   was used\nfor   **1/100**   of a grad (grade);   this was\none reason for the adoption of the term   **Celsius**   to\nreplace   **centigrade**   as the name of a temperature scale.\n\nGradians were commonly used in civil engineering.\n\nMils were normally used for artillery   (elevations of the gun barrel for ranging).\n\nPositive and negative angles\n\nAlthough the definition of the measurement of an angle doesn't support the\nconcept of a negative angle,   it's frequently useful to impose a convention that\nallows positive and negative angular values to represent orientations and/or rotations\nin opposite directions relative to some reference.   It is this reason that\nnegative angles will keep their sign and not be normalized to positive angles.\n\nNormalization\n\nNormalization   (for this Rosetta Code task)   will keep the same\nsign,   but it will reduce the magnitude to less than a full circle;   in\nother words, less than 360º.\n\nNormalization   shouldn't   change   **-45º**   to   **315º**,\n\nAn angle of   **0º**,   **+0º**,   **0.000000**,   or   **-0º**   should be\nshown as   **0º**.\n\nTask\n:   :   * write a function (or equivalent) to do the normalization for each scale\n\n        :   :   :   * Suggested names:\n                    * **d2d**,   **g2g**,   **m2m**,   and  **r2r**\n\n        * write a function (or equivalent) to convert one scale to another\n\n        :   :   :   * Suggested names for comparison of different computer language function names:\n                    * **d2g**,   **d2m**,   and   **d2r**   for degrees\n                    * **g2d**,   **g2m**,   and   **g2r**   for gradians\n                    * **m2d**,   **m2g**,   and   **m2r**   for mils\n                    * **r2d**,   **r2g**,   and   **r2m**   for radians\n\n        * normalize all angles used   (except for the \"original\" or \"base\" angle)\n        * show the angles in every scale and convert them to all other scales\n        * show all output here on this page\n\nFor the (above) conversions,   use these dozen numbers   (in the order shown):\n\n:   * **-2   -1   0   1   2   6.2831853   16   57.2957795   359   399   6399   1000000**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @units =\n    { code => 'd', name => 'degrees' , number =>  360 },\n    { code => 'g', name => 'gradians', number =>  400 },\n    { code => 'm', name => 'mills'   , number => 6400 },\n    { code => 'r', name => 'radians' , number =>  tau },\n;\n\nmy Code %cvt = (@units X @units).map: -> ($a, $b) {\n    \"{$a.<code>}2{$b.<code>}\" => sub ($angle) {\n        my $norm = $angle % $a.<number>\n                 - ( $a.<number> if $angle < 0 );\n        $norm * $b.<number> / $a.<number>\n    }\n}\n\nsay '     Angle Unit     ', @units».<name>».tc.fmt('%11s');\n\nfor -2, -1, 0, 1, 2, tau, 16, 360/tau, 360-1, 400-1, 6400-1, 1_000_000 -> $angle {\n    say '';\n    for @units -> $from {\n        my @sub_keys = @units.map: { \"{$from.<code>}2{.<code>}\" };\n\n        my @results = %cvt{@sub_keys}».($angle);\n\n        say join ' ', $angle      .fmt('%10g'),\n                      $from.<name>.fmt('%-8s'),\n                      @results    .fmt('%11g');\n    }\n}\n\n```\n\nOutput:\n\n```\n     Angle Unit         Degrees    Gradians       Mills     Radians\n\n        -2 degrees           -2    -2.22222    -35.5556  -0.0349066\n        -2 gradians        -1.8          -2         -32  -0.0314159\n        -2 mills        -0.1125      -0.125          -2  -0.0019635\n        -2 radians     -114.592    -127.324    -2037.18          -2\n\n        -1 degrees           -1    -1.11111    -17.7778  -0.0174533\n        -1 gradians        -0.9          -1         -16   -0.015708\n        -1 mills       -0.05625     -0.0625          -1 -0.000981748\n        -1 radians     -57.2958     -63.662    -1018.59          -1\n\n         0 degrees            0           0           0           0\n         0 gradians           0           0           0           0\n         0 mills              0           0           0           0\n         0 radians            0           0           0           0\n\n         1 degrees            1     1.11111     17.7778   0.0174533\n         1 gradians         0.9           1          16    0.015708\n         1 mills        0.05625      0.0625           1 0.000981748\n         1 radians      57.2958      63.662     1018.59           1\n\n         2 degrees            2     2.22222     35.5556   0.0349066\n         2 gradians         1.8           2          32   0.0314159\n         2 mills         0.1125       0.125           2   0.0019635\n         2 radians      114.592     127.324     2037.18           2\n\n   6.28319 degrees      6.28319     6.98132     111.701    0.109662\n   6.28319 gradians     5.65487     6.28319     100.531    0.098696\n   6.28319 mills       0.353429    0.392699     6.28319   0.0061685\n   6.28319 radians            0           0           0           0\n\n        16 degrees           16     17.7778     284.444    0.279253\n        16 gradians        14.4          16         256    0.251327\n        16 mills            0.9           1          16    0.015708\n        16 radians      196.732     218.592     3497.47     3.43363\n\n   57.2958 degrees      57.2958      63.662     1018.59           1\n   57.2958 gradians     51.5662     57.2958     916.732         0.9\n   57.2958 mills        3.22289     3.58099     57.2958     0.05625\n   57.2958 radians      42.8064     47.5626     761.002    0.747112\n\n       359 degrees          359     398.889     6382.22     6.26573\n       359 gradians       323.1         359        5744     5.63916\n       359 mills        20.1938     22.4375         359    0.352447\n       359 radians      49.1848     54.6498     874.397    0.858437\n\n       399 degrees           39     43.3333     693.333    0.680678\n       399 gradians       359.1         399        6384     6.26748\n       399 mills        22.4438     24.9375         399    0.391717\n       399 radians      181.016     201.129     3218.06     3.15933\n\n      6399 degrees          279         310        4960     4.86947\n      6399 gradians       359.1         399        6384     6.26748\n      6399 mills        359.944     399.938        6399      6.2822\n      6399 radians      155.693     172.992     2767.88     2.71736\n\n   1000000 degrees          280     311.111     4977.78     4.88692\n   1000000 gradians           0           0           0           0\n   1000000 mills             90         100        1600      1.5708\n   1000000 radians      339.513     377.237     6035.79     5.92562\n```\n\nAlternately, implemented as a series of postfix operators:\n\n*(Much of the complexity is due to the requirement that negative angles must normalize to a negative number.)*\n\n```\nsub postfix:<t>( $t ) { my $a = $t % 1 * τ;           $t >=0 ?? $a !! $a - τ }\nsub postfix:<d>( $d ) { my $a = $d % 360 * τ / 360;   $d >=0 ?? $a !! $a - τ }\nsub postfix:<g>( $g ) { my $a = $g % 400 * τ / 400;   $g >=0 ?? $a !! $a - τ }\nsub postfix:<m>( $m ) { my $a = $m % 6400 * τ / 6400; $m >=0 ?? $a !! $a - τ }\nsub postfix:<r>( $r ) { my $a = $r % τ;               $r >=0 ?? $a !! $a - τ }\n\nsub postfix:«->t» ($angle) { my $a = $angle / τ;        ($angle < 0 and $a == -1)    ?? -0 !! $a }\nsub postfix:«->d» ($angle) { my $a = $angle / τ * 360;  ($angle < 0 and $a == -360)  ?? -0 !! $a }\nsub postfix:«->g» ($angle) { my $a = $angle / τ * 400;  ($angle < 0 and $a == -400)  ?? -0 !! $a }\nsub postfix:«->m» ($angle) { my $a = $angle / τ * 6400; ($angle < 0 and $a == -6400) ?? -0 !! $a }\nsub postfix:«->r» ($angle) { my $a = $angle;            ($angle < 0 and $a == -τ)    ?? -0 !! $a }\n\nfor <-2 -1 0 1 2 6.2831853 16 57.2957795 359 399 6399 1000000> -> $a {\n    say '';\n    say '  Quantity  Unit      ', <turns degrees gradians mils radians>.fmt('%15s');\n    for 'turns', &postfix:«t», 'degrees', &postfix:«d», 'gradians', &postfix:«g»,\n        'mils',  &postfix:«m», 'radians', &postfix:«r»\n      -> $unit, &f {\n            printf \"%10s %-10s %15s %15s %15s %15s %15s\\n\", $a, $unit,\n            |($a.&f->t, $a.&f->d, $a.&f->g, $a.&f->m, $a.&f->r)».round(.00000001);\n    }\n}\n\n```\n\n```\n Quantity  Unit                turns         degrees        gradians            mils         radians\n        -2 turns                    0               0               0               0               0\n        -2 degrees        -0.00555556              -2     -2.22222222    -35.55555556     -0.03490659\n        -2 gradians            -0.005            -1.8              -2             -32     -0.03141593\n        -2 mils             -0.000313         -0.1125          -0.125              -2      -0.0019635\n        -2 radians        -0.31830989   -114.59155903   -127.32395447  -2037.18327158              -2\n\n  Quantity  Unit                turns         degrees        gradians            mils         radians\n        -1 turns                    0               0               0               0               0\n        -1 degrees        -0.00277778              -1     -1.11111111    -17.77777778     -0.01745329\n        -1 gradians           -0.0025            -0.9              -1             -16     -0.01570796\n        -1 mils             -0.000156        -0.05625         -0.0625              -1     -0.00098175\n        -1 radians        -0.15915494    -57.29577951    -63.66197724  -1018.59163579              -1\n\n  Quantity  Unit                turns         degrees        gradians            mils         radians\n         0 turns                    0               0               0               0               0\n         0 degrees                  0               0               0               0               0\n         0 gradians                 0               0               0               0               0\n         0 mils                     0               0               0               0               0\n         0 radians                  0               0               0               0               0\n\n  Quantity  Unit                turns         degrees        gradians            mils         radians\n         1 turns                    0               0               0               0               0\n         1 degrees         0.00277778               1      1.11111111     17.77777778      0.01745329\n         1 gradians            0.0025             0.9               1              16      0.01570796\n         1 mils              0.000156         0.05625          0.0625               1      0.00098175\n         1 radians         0.15915494     57.29577951     63.66197724   1018.59163579               1\n\n  Quantity  Unit                turns         degrees        gradians            mils         radians\n         2 turns                    0               0               0               0               0\n         2 degrees         0.00555556               2      2.22222222     35.55555556      0.03490659\n         2 gradians             0.005             1.8               2              32      0.03141593\n         2 mils              0.000313          0.1125           0.125               2       0.0019635\n         2 radians         0.31830989    114.59155903    127.32395447   2037.18327158               2\n\n  Quantity  Unit                turns         degrees        gradians            mils         radians\n 6.2831853 turns            0.2831853      101.946708       113.27412      1812.38592      1.77930572\n 6.2831853 degrees         0.01745329       6.2831853        6.981317      111.701072      0.10966227\n 6.2831853 gradians        0.01570796      5.65486677       6.2831853     100.5309648      0.09869604\n 6.2831853 mils            0.00098175      0.35342917      0.39269908       6.2831853       0.0061685\n 6.2831853 radians                  1    359.99999959    399.99999954   6399.99999269       6.2831853\n\n  Quantity  Unit                turns         degrees        gradians            mils         radians\n        16 turns                    0               0               0               0               0\n        16 degrees         0.04444444              16     17.77777778    284.44444444      0.27925268\n        16 gradians              0.04            14.4              16             256      0.25132741\n        16 mils                0.0025             0.9               1              16      0.01570796\n        16 radians         0.54647909    196.73247221    218.59163579   3497.46617261      3.43362939\n\n  Quantity  Unit                turns         degrees        gradians            mils         radians\n57.2957795 turns            0.2957795       106.48062        118.3118       1892.9888      1.85843741\n57.2957795 degrees         0.15915494      57.2957795     63.66197722   1018.59163556               1\n57.2957795 gradians        0.14323945     51.56620155      57.2957795      916.732472             0.9\n57.2957795 mils            0.00895247       3.2228876      3.58098622      57.2957795         0.05625\n57.2957795 radians         0.11890653     42.80634926     47.56261029    761.00176466      0.74711174\n\n  Quantity  Unit                turns         degrees        gradians            mils         radians\n       359 turns                    0               0               0               0               0\n       359 degrees         0.99722222             359    398.88888889   6382.22222222      6.26573201\n       359 gradians            0.8975           323.1             359            5744      5.63915881\n       359 mils              0.056094        20.19375         22.4375             359      0.35244743\n       359 radians         0.13662457      49.1848452       54.649828    874.39724794      0.85843749\n\n  Quantity  Unit                turns         degrees        gradians            mils         radians\n       399 turns                    0               0               0               0               0\n       399 degrees         0.10833333              39     43.33333333    693.33333333      0.68067841\n       399 gradians            0.9975           359.1             399            6384      6.26747734\n       399 mils              0.062344        22.44375         24.9375             399      0.39171733\n       399 radians         0.50282229    181.01602572    201.12891747   3218.06267946      3.15932565\n\n  Quantity  Unit                turns         degrees        gradians            mils         radians\n      6399 turns                    0               0               0               0               0\n      6399 degrees              0.775             279             310            4960      4.86946861\n      6399 gradians            0.9975           359.1             399            6384      6.26747734\n      6399 mils              0.999844       359.94375        399.9375            6399      6.28220356\n      6399 radians         0.43248085    155.69310421    172.99233802   2767.87740825      2.71735729\n\n  Quantity  Unit                turns         degrees        gradians            mils         radians\n   1000000 turns                    0               0               0               0               0\n   1000000 degrees         0.77777778             280    311.11111111   4977.77777778      4.88692191\n   1000000 gradians                 0               0               0               0               0\n   1000000 mils                  0.25              90             100            1600      1.57079633\n   1000000 radians          0.9430919    339.51308233    377.23675814   6035.78813022      5.92562114\n```"}]}
{"messages": [{"role": "user", "content": "Capture of the Oz version.\n\nOne good way of making an animation is by simulating a physical system and illustrating the variables in that system using a dynamically changing graphical display.\n\nThe classic such physical system is a simple gravity pendulum.\n\nTask\n\nCreate a simple physical model of a pendulum and animate it."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\nHandles window resizing, modifies pendulum length and period as window height changes. May need to tweek $ppi scaling to get good looking animation.\n\n```\nuse SDL2::Raw;\nuse Cairo;\n\nmy $width = 1000;\nmy $height = 400;\n\nSDL_Init(VIDEO);\n\nmy $window = SDL_CreateWindow(\n    'Pendulum - Raku',\n    SDL_WINDOWPOS_CENTERED_MASK,\n    SDL_WINDOWPOS_CENTERED_MASK,\n    $width, $height, RESIZABLE\n);\n\nmy $render = SDL_CreateRenderer($window, -1, ACCELERATED +| PRESENTVSYNC);\n\nmy $bob = Cairo::Image.create( Cairo::FORMAT_ARGB32, 32, 32 );\ngiven Cairo::Context.new($bob) {\n     my Cairo::Pattern::Gradient::Radial $sphere .=\n        create(13.3, 12.8, 3.2, 12.8, 12.8, 32);\n     $sphere.add_color_stop_rgba(0, 1, 1, .698, 1);\n     $sphere.add_color_stop_rgba(1, .623, .669, .144, 1);\n     .pattern($sphere);\n     .arc(16, 16, 15, 0, 2 * pi);\n     .fill;\n     $sphere.destroy;\n}\n\nmy $bob_texture = SDL_CreateTexture(\n    $render, %PIXELFORMAT<ARGB8888>,\n    STATIC, 32, 32\n);\n\nSDL_UpdateTexture(\n    $bob_texture,\n    SDL_Rect.new(:x(0), :y(0), :w(32), :h(32)),\n    $bob.data, $bob.stride // 32\n);\n\nSDL_SetTextureBlendMode($bob_texture, 1);\n\nSDL_SetRenderDrawBlendMode($render, 1);\n\nmy $event = SDL_Event.new;\n\nmy $now = now;   # time\nmy $Θ   = -π/3;  # start angle\nmy $ppi = 500;   # scale\nmy $g   = -9.81; # accelaration of gravity\nmy $ax  = $width/2; # anchor x\nmy $ay  = 25;       # anchor y\nmy $len = $height - 75; # 'rope' length\nmy $vel; # velocity\nmy $dt;  # delta time\n\nmain: loop {\n    while SDL_PollEvent($event) {\n        my $casted_event = SDL_CastEvent($event);\n        given $casted_event {\n            when *.type == QUIT    { last main }\n            when *.type == WINDOWEVENT {\n                if .event == 5 {\n                    $width  = .data1;\n                    $height = .data2;\n                    $ax = $width/2;\n                    $len = $height - 75;\n                }\n            }\n        }\n    }\n\n    $dt = now - $now;\n    $now = now;\n    $vel += $g / $len * sin($Θ) * $ppi * $dt;\n    $Θ   += $vel * $dt;\n    my $bx = $ax + sin($Θ) * $len;\n    my $by = $ay + cos($Θ) * $len;\n\n    SDL_SetRenderDrawColor($render, 255, 255, 255, 255);\n    SDL_RenderDrawLine($render, |($ax, $ay, $bx, $by)».round);\n    SDL_RenderCopy( $render, $bob_texture, Nil,\n      SDL_Rect.new($bx - 16, $by - 16, 32, 32)\n    );\n    SDL_RenderPresent($render);\n    SDL_SetRenderDrawColor($render, 0, 0, 0, 0);\n    SDL_RenderClear($render);\n}\n\nSDL_Quit();\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate and display five spinners.\nOne spinner in the middle and four spinners surrounding it.\nEach spinner is created by drawing radius lines around a center axis and then looping through the drawing to simulate a moving clock hand.\nWhen the loop is sped up, the illusion of a spinner is created.\nNOTE: The animated GIF example is actually slower than what you should be able to create. A fast animation will fill in more radial lines with a pleasing appearance.\n\nStretch goal\n\nExtra credit for offsetting the spinners with mouse movement.\n\n|  |  |  |\n| --- | --- | --- |\n| Slow Spinners | Fast Spinners | Spinners offset with mouse movement |"}, {"role": "assistant", "content": "```\n# 20250206 Raku programming solution\n\nuse NativeCall;\n\nclass Window is repr('CPointer') {}\nclass Monitor is repr('CPointer') {}\n\nconstant $lib   = ('glfw', v3);\nconstant $gllib = 'GL';\n\nsub glfwInit(--> int32) is native($lib) {*}\nsub glfwCreateWindow(int32, int32, Str, Monitor, Window --> Window) is native($lib) {*}\nsub glfwTerminate() is native($lib) {*}\nsub glfwMakeContextCurrent(Window) is native($lib) {*}\nsub glfwWindowShouldClose(Window --> int32) is native($lib) {*}\nsub glfwSwapBuffers(Window) is native($lib) {*}\nsub glfwSwapInterval(int32) is native($lib) {*}\nsub glfwPollEvents() is native($lib) {*}\n\nsub glClear(int32) is native($gllib) {*}\nsub glLoadIdentity() is native($gllib) {*}\nsub glTranslatef(num32, num32, num32) is native($gllib) {*}\nsub glRotatef(num32, num32, num32, num32) is native($gllib) {*}\nsub glColor4f(num32, num32, num32, num32) is native($gllib) {*}\nsub glBegin(int32) is native($gllib) {*}\nsub glVertex2f(num32, num32) is native($gllib) {*}\nsub glEnd() is native($gllib) {*}\nsub glPushMatrix() is native($gllib) {*}\nsub glPopMatrix() is native($gllib) {*}\n\nenum PrimitiveMode( GL_LINES => 0x0001 );\nconstant GL_COLOR_BUFFER_BIT = 0x00004000;\n\nmy (\\NUM_LINES,\\INNER_RADIUS,\\OUTER_RADIUS,\\ROTATION_SPEED) = 1, 0.0, 0.5, 2.0; \n\nsub drawLine($angle, $opacity, $centerX, $centerY) {\n   glPushMatrix();\n   glTranslatef($centerX, $centerY, 0e0);\n   glRotatef($angle, 0e0, 0e0, 1e0);\n   glColor4f(1e0, 1e0, 1e0, $opacity);\n\n   glBegin(GL_LINES);\n      (INNER_RADIUS, OUTER_RADIUS)>>.Num.map: { glVertex2f($_, 0e0) };\n   glEnd();\n\n   glPopMatrix();\n}\n\ndie 'Failed to initialize GLFW' unless glfwInit().so;\n\nmy $w = glfwCreateWindow(640, 480, \"Spinners\", Nil, Nil);\nwithout $w { glfwTerminate(); die 'Failed to create window' }\n\nglfwMakeContextCurrent($w);\nglfwSwapInterval(1);\n\nmy @angles    = 0.0 xx 5; \nmy @positions = (<0 0>, <-.5 .5>, <.5 .5>, <-.5 -.5>, <.5 -.5>).map: *>>.Num;\n\nuntil glfwWindowShouldClose($w) {\n   glClear(GL_COLOR_BUFFER_BIT);\n   glLoadIdentity();\n\n   for 0 ..^ NUM_LINES -> $i {\n      my $opacity = 1.0e0 - ($i / NUM_LINES);\n      for @positions.kv -> $index, $pos {\n         drawLine((@angles[$index] + 360 / NUM_LINES * $i).Num, $opacity, $pos[0], $pos[1]);\n      }\n   }\n\n   glfwSwapBuffers($w);\n   glfwPollEvents();\n\n   for 0 ..^ 5 -> $i {\n      @angles[$i] += (ROTATION_SPEED * (1 / 60).Num);\n      @angles[$i] -= 360 if @angles[$i] >= 360;\n   }\n}\n\nglfwTerminate();\n\n```"}]}
{"messages": [{"role": "user", "content": "**Animation** is integral to many parts of GUIs, including both the fancy effects when things change used in window managers, and of course games.   The core of any animation system is a scheme for periodically changing the display while still remaining responsive to the user.   This task demonstrates this.\n\nTask\n\nCreate a window containing the string \"`Hello World!` \" (the trailing space is significant).\n\nMake the text appear to be rotating right by periodically removing one letter from the end of the string and attaching it to the front.\n\nWhen the user clicks on the (windowed) text, it should reverse its direction."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\n```\nuse GTK::Simple;\nuse GTK::Simple::App;\n\nmy $app    = GTK::Simple::App.new(:title<Animation>);\nmy $button = GTK::Simple::Button.new(label => 'Hello World! ');\nmy $vbox   = GTK::Simple::VBox.new($button);\n\nmy $repeat = $app.g-timeout(100); # milliseconds\n\nmy $dir = 1;\n$button.clicked.tap({ $dir *= -1 });\n\n$repeat.tap( &{$button.label = $button.label.comb.List.rotate($dir).join} );\n\n$app.set-content($vbox);\n\n$app.run;\n\n```"}]}
{"messages": [{"role": "user", "content": "While implementing a recursive function, it often happens that we must resort to a separate   *helper function*   to handle the actual recursion.\n\nThis is usually the case when directly calling the current function would waste too many resources (stack space, execution time), causing unwanted side-effects,   and/or the function doesn't have the right arguments and/or return values.\n\nSo we end up inventing some silly name like   **foo2**   or   **foo\\_helper**.   I have always found it painful to come up with a proper name, and see some disadvantages:\n\n:   :   * You have to think up a name, which then pollutes the namespace\n        * Function is created which is called from nowhere else\n        * The program flow in the source code is interrupted\n\nSome languages allow you to embed recursion directly in-place.   This might work via a label, a local *gosub* instruction, or some special keyword.\n\nAnonymous recursion can also be accomplished using the   Y combinator.\n\nTask\n\nIf possible, demonstrate this by writing the recursive version of the fibonacci function   (see Fibonacci sequence)   which checks for a negative argument before doing the actual recursion.\n\nRelated tasks\n:   * Y combinator"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\nIn addition to the methods in the Perl entry above, and the Y-combinator described in Y\\_combinator, you may also refer to an anonymous block or function from the inside:\n\n```\nsub fib($n) {\n    die \"Naughty fib\" if $n < 0;\n    return {\n        $_ < 2\n            ?? $_\n            !!  &?BLOCK($_-1) + &?BLOCK($_-2);\n    }($n);\n}\n\nsay fib(10);\n```\n\nHowever, using any of these methods is insane, when Raku provides a sort of inside-out combinator that lets you define lazy infinite constants, where the demand for a particular value is divorced from dependencies on more primitive values. This operator, known as the sequence operator, does in a sense provide anonymous recursion to a closure that refers to more primitive values.\n\n```\nconstant @fib = 0, 1, *+* ... *;\nsay @fib[10];\n```\n\nHere the closure, \\*+\\*, is just a quick way to write a lambda, -> $a, $b { $a + $b }. The sequence operator implicitly maps the two arguments to the -2nd and -1st elements of the sequence. So the sequence operator certainly applies an anonymous lambda, but whether it's recursion or not depends on whether you view a sequence as iteration or as simply a convenient way of memoizing a recursion. Either view is justifiable.\n\nAt this point someone may complain that the solution is doesn't fit the specified task because the sequence operator doesn't do the check for negative. True, but the sequence operator is not the whole of the solution; this check is supplied by the subscripting operator itself when you ask for @fib[-1]. Instead of scattering all kinds of arbitrary boundary conditions throughout your functions, the sequence operator maps them quite naturally to the boundary of definedness at the start of a list."}]}
{"messages": [{"role": "user", "content": "The anti-primes\n(or highly composite numbers, sequence A002182 in the OEIS)\nare the natural numbers with more factors than any smaller than itself.\n\nTask\n\nGenerate and show here, the first twenty anti-primes.\n\nRelated tasks\n:   * Factors of an integer\n    * Sieve of Eratosthenes"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.11\n\nAt its heart, this task is almost exactly the same as Proper\\_Divisors, it is just asking for slightly different results. Much of this code is lifted straight from there.\n\nImplemented as an auto-extending lazy list. Displaying the count of anti-primes less than 5e5 also because... why not.\n\n```\nsub propdiv (\\x) {\n    my @l = 1 if x > 1;\n    (2 .. x.sqrt.floor).map: -> \\d {\n        unless x % d { @l.push: d; my \\y = x div d; @l.push: y if y != d }\n    }\n    @l\n}\n\nmy $last = 0;\n\nmy @anti-primes = lazy 1, |(|(2..59), 60, *+60 … *).grep: -> $c {\n    my \\mx = +propdiv($c);\n    next if mx <= $last;\n    $last = mx;\n    $c\n}\n\nmy $upto = 5e5;\n\nput \"First 20 anti-primes:\\n{ @anti-primes[^20] }\";\n\nput \"\\nCount of anti-primes <= $upto: {+@anti-primes[^(@anti-primes.first: * > $upto, :k)]}\";\n\n```\n\nOutput:\n\n```\nFirst 20 anti-primes:\n1 2 4 6 12 24 36 48 60 120 180 240 360 720 840 1260 1680 2520 5040 7560\n\nCount of anti-primes <= 500000: 35\n```"}]}
{"messages": [{"role": "user", "content": "Many systems offer the ability to open a file for writing, such that any data written will be appended to the end of the file. Further, the file operations will always adjust the position pointer to guarantee the end of the file, even in a multitasking environment.\n\nThis feature is most useful in the case of log files, where many jobs may be appending to the log file at the same time, or where care *must* be taken to avoid concurrently overwriting the same record from another job.\n\nTask\n\nGiven a two record sample for a mythical \"passwd\" file:\n\n* Write these records out in the typical system format.\n  + Ideally these records will have named fields of various types.\n* Close the file, then reopen the file for append.\n  + **Append** a new record to the file and close the file again.\n  + Take appropriate care to avoid concurrently overwrites from another job.\n* Open the file and demonstrate the new record has indeed written to the end.\n\nSource record field types and contents.\n\n| account | password | UID | GID | fullname,office,extension,homephone,email | directory | shell |\n| --- | --- | --- | --- | --- | --- | --- |\n| string | string | int | int | struct(string,string,string,string,string) | string | string |\n| jsmith | x | 1001 | 1000 | Joe Smith,Room 1007,(234)555-8917,(234)555-0077,jsmith@rosettacode.org | /home/jsmith | /bin/bash |\n| jdoe | x | 1002 | 1000 | Jane Doe,Room 1004,(234)555-8914,(234)555-0044,jdoe@rosettacode.org | /home/jdoe | /bin/bash |\n\nRecord to be appended.\n\n| account | password | UID | GID | fullname,office,extension,homephone,email | directory | shell |\n| --- | --- | --- | --- | --- | --- | --- |\n| string | string | int | int | struct(string,string,string,string,string) | string | string |\n| xyz | x | 1003 | 1000 | X Yz,Room 1003,(234)555-8913,(234)555-0033,xyz@rosettacode.org | /home/xyz | /bin/bash |\n\n**Resulting file format:** should mimic Linux's /etc/passwd file format with particular attention to the \",\" separator used in the GECOS field. But if the specific language has a particular or unique format of storing records in text file, then this format should be named and demonstrated with an additional example.\n\n**Expected output:**\n\n```\nAppended record: xyz:x:1003:1000:X Yz,Room 1003,(234)555-8913,(234)555-0033,xyz@rosettacode.org:/home/xyz:/bin/bash\n\n```\n\n**Finally:** Provide a summary of the language's \"append record\" capabilities in a table. eg.\n\nAppend Capabilities.\n\n| Data Representation | | IO Library | Append Possible | Automatic Append | Multi-tasking Safe |\n| --- | --- | --- | --- | --- | --- |\n| In core | On disk |\n| C struct | CSV text file | glibc/stdio | ☑ | ☑ | ☑ (Not all, eg NFS) |\n\nAlternatively: If the language's appends can not guarantee its writes will **always** append, then note this restriction in the table. If possible, provide an actual code example (possibly using file/record locking) to guarantee correct concurrent appends."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nThis is kind of silly as it takes a string, converts it to a record, and then instantly converts it back to a string to write out to a file. Most of the \"record handling\" code is just demonstrating a possible way to store records in memory. It really has nothing to do with appending a string to a file.\n\n```\nclass record {\n    has $.name;\n    has $.password;\n    has $.UID;\n    has $.GID;\n    has $.fullname;\n    has $.office;\n    has $.extension;\n    has $.homephone;\n    has $.email;\n    has $.directory;\n    has $.shell;\n\n    method gecos { join ',', $.fullname, $.office, $.extension, $.homephone, $.email }\n\n    method gist {\n        join ':',\n        $.name,\n        $.password,\n        $.UID,\n        $.GID,\n        self.gecos,\n        $.directory,\n        $.shell;\n    }\n};\n\nmy $fname = 'foo.fil';\n\ngiven $fname.IO.open(:w) { .close }; # clear file\n\nsub append ($file, $line){\n    my $fh = $file.IO.open(:a) or fail \"Unable to open $file\";\n    given $fh {\n        # Get a lock on the file, waits until lock is active\n        .lock;\n        # seek to the end in case some other process wrote to\n        # the file while we were waiting for the lock\n        .seek(0, SeekType::SeekFromEnd);\n        # write the record\n        .say: $line;\n        .close;\n    }\n}\n\nsub str-to-record ($str) {\n    my %rec = <name password UID GID fullname office extension\n      homephone email directory shell> Z=> $str.split(/<[:,]>/);\n    my $user = record.new(|%rec);\n}\n\nfor\n  'jsmith:x:1001:1000:Joe Smith,Room 1007,(234)555-8917,(234)555-0077,jsmith@rosettacode.org:/home/jsmith:/bin/bash',\n  'jdoe:x:1002:1000:Jane Doe,Room 1004,(234)555-8914,(234)555-0044,jdoe@rosettacode.org:/home/jdoe:/bin/bash'\n-> $line {\n        my $thisuser = str-to-record $line;\n       $fname.&append: $thisuser.gist;\n}\n\nput \"Last line of $fname before append:\";\nput $fname.IO.lines.tail;\n\n$fname.&append: str-to-record('xyz:x:1003:1000:X Yz,Room 1003,(234)555-8913,(234)555-0033,xyz@rosettacode.org:/home/xyz:/bin/bash').gist;\n\nput \"Last line of $fname after append:\";\nput $fname.IO.lines.tail;\n\n```\n\nOutput:\n\n```\nLast line of foo.fil before append:\njdoe:x:1002:1000:Jane Doe,Room 1004,(234)555-8914,(234)555-0044,jdoe@rosettacode.org:/home/jdoe:/bin/bash\nLast line of foo.fil after append:\nxyz:x:1003:1000:X Yz,Room 1003,(234)555-8913,(234)555-0033,xyz@rosettacode.org:/home/xyz:/bin/bash\n```\n\nAppend Capabilities.\n\n| Data Representation | | IO Library | Append Possible | Automatic Append | Multi-tasking Safe |\n| --- | --- | --- | --- | --- | --- |\n| In core | On disk |\n| Class | Text file | Whichever is provided by the underlying VM | ☑ | ☑ | ☑ Advisory lock Depends on OS and VM |\n\nNote that advisory locks do not prevent some other program (if it doesn't use flock) from unexpectedly writing to the file."}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven three lists:\n  \nlist1 = [1,2,3,4,5,6,7,8,9]\n  \nlist2 = [10,11,12,13,14,15,16,17,18]\n  \nlist3 = [19,20,21,22,23,24,25,26,27]\n  \nAt each index, turn the numbers into strings and concatenate them.\n  \nThe result should be:\n  \nlist = [11019,21120,31221,41322,51423,61524,71625,81726,91827]"}, {"role": "assistant", "content": "Various manipulations.\n\n```\nmy @lists = 1..9, 10..18, 19..27;\nput [Z~] @lists;         # the task\nput [Z~] @lists».flip;   # each component reversed\nput [RZ~] @lists;        # in reversed order\nput ([Z~] @lists)».flip; # reversed components in reverse order\n\n```\n\nOutput:\n\n```\n11019 21120 31221 41322 51423 61524 71625 81726 91827\n10191 21102 32112 43122 54132 65142 76152 87162 98172\n19101 20112 21123 22134 23145 24156 25167 26178 27189\n91011 02112 12213 22314 32415 42516 52617 62718 72819\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nTake a combined set of elements and apply a function to each element."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.10-11\n\n```\nsub function { 2 * $^x + 3 };\nmy @array = 1 .. 5;\n\n# via map function\n.say for map &function, @array;\n\n# via map method\n.say for @array.map(&function);\n\n# via for loop\nfor @array {\n    say function($_);\n}\n\n# via the \"hyper\" metaoperator and method indirection\nsay @array».&function;\n\n# we neither need a variable for the array nor for the function\nsay [1,2,3]>>.&({ $^x + 1});\n```"}]}
{"messages": [{"role": "user", "content": "Digital filters are used to apply a mathematical operation to a sampled signal. One of the common formulations is the \"direct form II transposed\" which can represent both infinite impulse response (IIR) and finite impulse response (FIR) filters, as well as being more numerically stable than other forms. [1]\n\nTask\n\nFilter a signal using an order 3 low-pass Butterworth filter. The coefficients for the filter are a=[1.00000000, -2.77555756e-16, 3.33333333e-01, -1.85037171e-17] and b = [0.16666667, 0.5, 0.5, 0.16666667]\n\nThe signal that needs filtering is the following vector: [-0.917843918645, 0.141984778794, 1.20536903482, 0.190286794412, -0.662370894973, -1.00700480494, -0.404707073677 ,0.800482325044, 0.743500089861, 1.01090520172, 0.741527555207, 0.277841675195, 0.400833448236, -0.2085993586, -0.172842103641, -0.134316096293, 0.0259303398477, 0.490105989562, 0.549391221511, 0.9047198589]\n\nSee also\n\n[Wikipedia on Butterworth filters]"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.11\n\n**Translation of**: zkl\n\n```\nsub TDF-II-filter ( @signal, @a, @b ) {\n    my @out = 0 xx @signal;\n    for ^@signal -> $i {\n        my $this;\n        $this += @b[$_] * @signal[$i-$_] if $i-$_ >= 0 for ^@b;\n        $this -= @a[$_] *    @out[$i-$_] if $i-$_ >= 0 for ^@a;\n        @out[$i] = $this / @a[0];\n    }\n    @out\n}\n\nmy @signal = [\n    -0.917843918645,  0.141984778794, 1.20536903482,   0.190286794412,\n    -0.662370894973, -1.00700480494, -0.404707073677,  0.800482325044,\n     0.743500089861,  1.01090520172,  0.741527555207,  0.277841675195,\n     0.400833448236, -0.2085993586,  -0.172842103641, -0.134316096293,\n     0.0259303398477, 0.490105989562, 0.549391221511,  0.9047198589\n];\nmy @a = [ 1.00000000, -2.77555756e-16, 3.33333333e-01, -1.85037171e-17 ];\nmy @b = [ 0.16666667,  0.5,            0.5,             0.16666667     ];\n\nsay TDF-II-filter(@signal, @a, @b)».fmt(\"% 0.8f\")\n    Z~ flat (', ' xx 4, \",\\n\") xx *;\n\n```\n\nOutput:\n\n```\n(-0.15297399,  -0.43525783,  -0.13604340,   0.69750333,   0.65644469,\n -0.43548245,  -1.08923946,  -0.53767655,   0.51704999,   1.05224975,\n  0.96185430,   0.69569009,   0.42435630,   0.19626223,  -0.02783512,\n -0.21172192,  -0.17474556,   0.06925841,   0.38544587,   0.65177084,\n)\n```"}]}
{"messages": [{"role": "user", "content": "Sometimes, when testing whether the solution to a task (for example, here on Rosetta Code) is correct, the\ndifference in floating point calculations between different language implementations becomes significant.\n\nFor example, a difference between **32** bit and **64** bit floating point calculations may appear by\nabout the 8th significant digit in base 10 arithmetic.\n\nTask\n\nCreate a function which returns true if two floating point numbers are approximately equal.\n\nThe function should allow for differences in the magnitude of numbers, so that, for example,\n  \n**100000000000000.01**   may be approximately equal to   **100000000000000.011**,\n  \neven though   **100.01**   is not approximately equal to   **100.011**.\n\nIf the language has such a feature in its standard library, this may be used instead of a custom function.\n\nShow the function results with comparisons on the following pairs of values:\n\n:   1. 100000000000000.01,   100000000000000.011     (note: should return *true*)\n    2. 100.01,   100.011                                                     (note: should return *false*)\n    3. 10000000000000.001 / 10000.0,   1000000000.0000001000\n    4. 0.001,   0.0010000001\n    5. 0.000000000000000000000101,   0.0\n    6. sqrt(2) \\* sqrt(2),    2.0\n    7. -sqrt(2) \\* sqrt(2),   -2.0\n    8. 3.14159265358979323846,   3.14159265358979324\n\nAnswers should be true for the first example and false in the second, so that just rounding the numbers to a fixed number of decimals should not be enough. Otherwise answers may vary and still be correct. See the Python code for one type of solution."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nIs approximately equal to is a built-in operator in Raku. Unicode ≅, or the ASCII equivalent: =~=. By default it uses a tolerance of 1e-15 times the order of magnitude of the larger comparand, though that is adjustable by setting the dynamic variable $\\*TOLERANCE to the desired value. Probably a good idea to localize the changed $\\*TOLERANCE as it will affect all comparisons within its scope.\n\nMost of the following tests are somewhat pointless in Raku. To a large extent, when dealing with Rational values, you don't really need to worry about \"approximately equal to\", and all of the test values below, with the exception of `sqrt(2)`, are Rats by default, and exact. You would have to specifically coerce them to Nums (floating point) to lose the precision.\n\nFor example, in Raku, the sum of .1, .2, .3, & .4 is *identically* equal to 1.\n\n```\nsay 0.1 + 0.2 + 0.3 + 0.4 === 1.0000000000000000000000000000000000000000000000000000000000000000000000000; # True\n\n```\n\nIt's also *approximately* equal to 1 but... ¯\\\\_(ツ)\\_/¯\n\n```\nfor\n    100000000000000.01, 100000000000000.011,\n    100.01, 100.011,\n    10000000000000.001 / 10000.0, 1000000000.0000001000,\n    0.001, 0.0010000001,\n    0.000000000000000000000101, 0.0,\n    sqrt(2) * sqrt(2), 2.0,\n    -sqrt(2) * sqrt(2), -2.0,\n    100000000000000003.0, 100000000000000004.0,\n    3.14159265358979323846, 3.14159265358979324\n\n  -> $a, $b {\n    say \"$a ≅ $b: \", $a ≅ $b;\n}\n\nsay \"\\nTolerance may be adjusted.\";\n\nsay 22/7, \" ≅ \", π, \": \", 22/7 ≅ π;\n{ # Localize the tolerance to only this block\n  my $*TOLERANCE = .001;\n  say 22/7, \" ≅ \", π, \": \", 22/7 ≅ π;\n}\n\n```\n\nOutput:\n\n```\n100000000000000.01 ≅ 100000000000000.011: True\n100.01 ≅ 100.011: False\n1000000000.0000001 ≅ 1000000000.0000001: True\n0.001 ≅ 0.0010000001: False\n0.000000000000000000000101 ≅ 0: True\n2.0000000000000004 ≅ 2: True\n-2.0000000000000004 ≅ -2: True\n100000000000000003 ≅ 100000000000000004: True\n3.141592653589793226752 ≅ 3.14159265358979324: True\n\nTolerance may be adjusted.\n3.142857 ≅ 3.141592653589793: False\n3.142857 ≅ 3.141592653589793: True\n```"}]}
{"messages": [{"role": "user", "content": "Apéry's constant is the sum of the reciprocals of the positive cubes.\n\nThat is, it is defined as the number \n\nζ\n(\n3\n)\n=\n\n∑\n\nk\n=\n1\n\n∞\n\n\n1\n\nk\n\n3\n,\n{\\displaystyle {\\displaystyle \\zeta (3)=\\sum \\_{k=1}^{\\infty }{\\frac {1}{k^{3}}},}}\n *where ζ is the Riemann zeta function*.\n\nApproximately equal to:\n\n:   **1.2020569031595942853997381615114499907649862923404988817922715553418382057863130901864558736093352581**\n\nThis constant was known and studied by many early mathematicians, but was not named until 1978, after Roger Apéry, who was first to prove it was an irrational number.\n\nζ\n(\n3\n)\n{\\displaystyle {\\displaystyle \\zeta (3)}}\n by summing reciprocal cubes is easy to calculate, but converges very slowly. The first 1000 terms are only accurate to 6 decimal places.\n\nThere have been many fast convergence representations developed / discovered that generate correct digits much more quickly.\n\nOne of the earliest, discovered in the late 1800s by A. Markov and later widely published by Apéry is:\n\n:   ζ\n    (\n    3\n    )\n    =\n\n\n    5\n    2\n\n    ∑\n\n    k\n    =\n    1\n\n    ∞\n    (\n    −\n    1\n\n    )\n\n    k\n    −\n    1\n\n    k\n\n    !\n\n    2\n\n    (\n    2\n    k\n    )\n    !\n\n    k\n\n    3\n    .\n    {\\displaystyle {\\displaystyle \\zeta (3)={\\frac {5}{2}}\\sum \\_{k=1}^{\\infty }(-1)^{k-1}{\\frac {k!^{2}}{(2k)!k^{3}}}.}}\n\nMuch better than direct calculation of \n\nζ\n(\n3\n)\n{\\displaystyle {\\displaystyle \\zeta (3)}}\n, but still only yielding about .63 correct digits per iteration.\n\nSeveral even faster converging representions are available. The fastest known to date, yielding about 5.04 correct digits per term, is by Sebastian Wedeniwski.\n\n:   ζ\n    (\n    3\n    )\n    =\n\n\n    1\n    24\n\n    ∑\n\n    k\n    =\n    0\n\n    ∞\n    (\n    −\n    1\n\n    )\n\n    k\n\n    (\n    2\n    k\n    +\n    1\n    )\n\n    !\n\n    3\n    (\n    2\n    k\n    )\n\n    !\n\n    3\n    k\n\n    !\n\n    3\n    (\n    126392\n\n    k\n\n    5\n    +\n    412708\n\n    k\n\n    4\n    +\n    531578\n\n    k\n\n    3\n    +\n    336367\n\n    k\n\n    2\n    +\n    104000\n    k\n    +\n    12463\n    )\n\n    (\n    3\n    k\n    +\n    2\n    )\n    !\n    (\n    4\n    k\n    +\n    3\n    )\n\n    !\n\n    3\n    .\n    {\\displaystyle {\\displaystyle \\zeta (3)={\\frac {1}{24}}\\sum \\_{k=0}^{\\infty }(-1)^{k}{\\frac {(2k+1)!^{3}(2k)!^{3}k!^{3}(126392k^{5}+412708k^{4}+531578k^{3}+336367k^{2}+104000k+12463)}{(3k+2)!(4k+3)!^{3}}}.}}\n\nTask\n\n* Show the value of Apéry's constant calculated at least three different ways.\n\n:   1. Show the value of at least the first 1000 terms of \n\n       ζ\n       (\n       3\n       )\n       {\\displaystyle {\\displaystyle \\zeta (3)}}\n        by direct summing of reciprocal cubes, truncated to 100 decimal digits.\n    2. Show the value of the first 158 terms of Markov / Apéry representation truncated to 100 decimal digits.\n    3. Show the value of the first 20 terms of Wedeniwski representation truncated to 100 decimal digits.\n\nSee also\n\n* Wikipedia: Apéry's constant * OEIS:A002117 - Decimal expansion of zeta(3)"}, {"role": "assistant", "content": "```\nsub postfix:<!> (Int $n) { (constant f = 1, |[\\×] 1..*)[$n] }\n\nsay 'Actual value to 100 decimal places:';\nsay '1.2020569031595942853997381615114499907649862923404988817922715553418382057863130901864558736093352581';\n\nsay \"\\nFirst 1000 terms of ζ(3) truncated to 100 decimal places. (accurate to 6 decimal places):\";\nsay (1..1000).map({FatRat.new: 1, .³}).sum.substr: 0, 102;\n\nsay \"\\nFirst 158 terms of Markov / Apéry representation truncated to 100 decimal places:\";\nsay (5/2 × (1..158).map( -> \\k { (-1)**(k-1) × FatRat.new: k!², ((2×k)! × k³) } ).sum).substr: 0, 102;\n\nsay \"\\nFirst 20 terms of Wedeniwski representation truncated to 100 decimal places:\";\nsay (1/24 × ((^20).map: -> \\k {\n    (-1)**k × FatRat.new: (2×k+1)!³ × (2×k)!³ × k!³ × (126392×k⁵ + 412708×k⁴ + 531578×k³ + 336367×k² + 104000×k + 12463), (3×k+2)! × (4×k+3)!³\n}).sum).substr: 0, 102;\n\n```\n\nOutput:\n\nActual value to 100 decimal places:\n\n1.2020569031595942853997381615114499907649862923404988817922715553418382057863130901864558736093352581\n\nFirst 1000 terms of ζ(3) truncated to 100 decimal places. (accurate to 6 decimal places):\n1.2020564036593442854830714115115999903483212709031775135036540966118572571921400836130084123260473111\n\nFirst 158 terms of Markov / Apéry representation truncated to 100 decimal places:\n1.2020569031595942853997381615114499907649862923404988817922715553418382057863130901864558736093352581\n\nFirst 20 terms of Wedeniwski representation truncated to 100 decimal places:\n1.2020569031595942853997381615114499907649862923404988817922715553418382057863130901864558736093352581"}]}
{"messages": [{"role": "user", "content": "Using the in-built capabilities of your language, calculate the integer value of:\n\n```\n        \n  \n    \n      \n        \n          \n            \n              5\n              \n                \n                  4\n                  \n                    \n                      3\n                      \n                        2\n                      \n                    \n                  \n                \n              \n            \n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle 5^{4^{3^{2}}}}}\n  \n\n\n```\n\n* Confirm that the first and last twenty digits of the answer are:\n\n```\n     62060698786608744707...92256259918212890625\n\n```\n\n* Find and show the number of decimal digits in the answer.\n\nNote:\n\n* Do not submit an *implementation* of arbitrary precision arithmetic. The intention is to show the capabilities of the language as supplied. If a language has a single, overwhelming, library of varied modules that is endorsed by its home site – such as CPAN for Perl or Boost for C++ – then that *may* be used instead.\n* Strictly speaking, this should not be solved by fixed-precision numeric libraries where the precision has to be manually set to a large value; although if this is the **only** recourse then it may be used with a note explaining that the precision must be set manually to a large enough value.\n\nRelated tasks\n\n* Long multiplication\n* Exponentiation order\n* exponentiation operator\n* Exponentiation with infix operators in (or operating on) the base"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2022.07\n\n```\ngiven [**] 5, 4, 3, 2 {\n  use Test;\n  ok /^ 62060698786608744707 <digit>* 92256259918212890625 $/,\n     '5**4**3**2 has expected first and last twenty digits';\n  printf 'This number has %d digits', .chars;\n}\n\n```\n\nOutput:\n\n```\nok 1 - 5**4**3**2 has expected first and last twenty digits\nThis number has 183231 digits\n```"}]}
{"messages": [{"role": "user", "content": "The Archimedean spiral is a spiral named after the Greek mathematician Archimedes.\n\nAn Archimedean spiral can be described by the equation:\n\n:   r\n    =\n    a\n    +\n    b\n    θ\n    {\\displaystyle {\\displaystyle \\,r=a+b\\theta }}\n\nwith real numbers *a* and *b*.\n\nTask\n\nDraw an Archimedean spiral."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.10\n\n```\nuse Image::PNG::Portable;\n\nmy ($w, $h) = (400, 400);\n\nmy $png = Image::PNG::Portable.new: :width($w), :height($h);\n\n(0, .025 ... 52*π).race.map: -> \\Θ {\n    $png.set: |((cis( Θ / π ) * Θ).reals »+« ($w/2, $h/2))».Int, 255, 0, 255;\n}\n\n$png.write: 'Archimedean-spiral-perl6.png';\n\n```"}]}
{"messages": [{"role": "user", "content": "Dynamically allocated objects take their memory from a heap.\n\nThe memory for an object is provided by an **allocator** which maintains the storage pool used for the heap.\n\nOften a call to allocator is denoted as\n\n```\nP := new T\n\n```\n\nwhere   **T**   is the type of an allocated object,   and   **P**   is a reference to the object.\n\nThe storage pool chosen by the allocator can be determined by either:\n\n* the object type   **T**\n* the type of pointer   **P**\n\nIn the former case objects can be allocated only in one storage pool.\n\nIn the latter case objects of the type can be allocated in any storage pool or on the stack.\n\nTask\n\nThe task is to show how allocators and user-defined storage pools are supported by the language.\n\nIn particular:\n\n1. define an arena storage pool.   An arena is a pool in which objects are allocated individually, but freed by groups.\n2. allocate some objects (e.g., integers) in the pool.\n\nExplain what controls the storage pool choice in the language."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku is a high level language where, to a first approximation, everything is an object. Raku dynamically allocates memory as objects are created and does automatic garbage collection and freeing of memory as objects go out of scope. There is almost no high level control over how memory is managed, it is considered to be an implementation detail of the virtual machine on which it is running.\n\nIf you absolutely must take manual control over memory management you would need to use the foreign function interface to call into a language that provides the capability, but even that would only affect items in the scope of that function, not anything in the mainline process.\n\nThere is some ability to specify data types for various objects which allows for (but does not guarantee) more efficient memory layout, but again, it is considered to be an implementation detail, the use that the virtual machine makes of that information varies by implementation maturity and capabilities."}]}
{"messages": [{"role": "user", "content": "Arithmetic coding is a form of entropy encoding used in lossless data compression. Normally, a string of characters such as the words \"hello there\" is represented using a fixed number of bits per character, as in the ASCII code. When a string is converted to arithmetic encoding, frequently used characters will be stored with fewer bits and not-so-frequently occurring characters will be stored with more bits, resulting in fewer bits used in total. Arithmetic coding differs from other forms of entropy encoding, such as Huffman coding, in that rather than separating the input into component symbols and replacing each with a code, arithmetic coding encodes the entire message into a single number.\n\nTask\n\nCreate a program which implements the arithmetic coding as a generalized change of radix.\n\nShow the results, in base 10, for all the following strings:\n\n* \"DABDDB\"\n* \"DABDDBBDDBA\"\n* \"ABRACADABRA\"\n* \"TOBEORNOTTOBEORTOBEORNOT\"\n\nVerify the implementation by decoding the results back into strings and checking for equality with the given strings."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub cumulative_freq(%freq) {\n    my %cf;\n    my $total = 0;\n    for %freq.keys.sort -> $c {\n        %cf{$c} = $total;\n        $total += %freq{$c};\n    }\n    return %cf;\n}\n\nsub arithmethic_coding($str, $radix) {\n    my @chars = $str.comb;\n\n    # The frequency characters\n    my %freq;\n    %freq{$_}++ for @chars;\n\n    # The cumulative frequency table\n    my %cf = cumulative_freq(%freq);\n\n    # Base\n    my $base = @chars.elems;\n\n    # Lower bound\n    my $L = 0;\n\n    # Product of all frequencies\n    my $pf = 1;\n\n    # Each term is multiplied by the product of the\n    # frequencies of all previously occurring symbols\n    for @chars -> $c {\n        $L = $L*$base + %cf{$c}*$pf;\n        $pf *= %freq{$c};\n    }\n\n    # Upper bound\n    my $U = $L + $pf;\n\n    my $pow = 0;\n    loop {\n        $pf div= $radix;\n        last if $pf == 0;\n        ++$pow;\n    }\n\n    my $enc = ($U - 1) div ($radix ** $pow);\n    ($enc, $pow, %freq);\n}\n\nsub arithmethic_decoding($encoding, $radix, $pow, %freq) {\n\n    # Multiply encoding by radix^pow\n    my $enc = $encoding * $radix**$pow;\n\n    # Base\n    my $base = [+] %freq.values;\n\n    # Create the cumulative frequency table\n    my %cf = cumulative_freq(%freq);\n\n    # Create the dictionary\n    my %dict;\n    for %cf.kv -> $k,$v {\n        %dict{$v} = $k;\n    }\n\n    # Fill the gaps in the dictionary\n    my $lchar;\n    for ^$base -> $i {\n        if (%dict{$i}:exists) {\n            $lchar = %dict{$i};\n        }\n        elsif (defined $lchar) {\n            %dict{$i} = $lchar;\n        }\n    }\n\n    # Decode the input number\n    my $decoded = '';\n    for reverse(^$base) -> $i {\n\n        my $pow = $base**$i;\n        my $div = $enc div $pow;\n\n        my $c  = %dict{$div};\n        my $fv = %freq{$c};\n        my $cv = %cf{$c};\n\n        my $rem = ($enc - $pow*$cv) div $fv;\n\n        $enc = $rem;\n        $decoded ~= $c;\n    }\n\n    # Return the decoded output\n    return $decoded;\n}\n\nmy $radix = 10;    # can be any integer greater or equal with 2\n\nfor <DABDDB DABDDBBDDBA ABRACADABRA TOBEORNOTTOBEORTOBEORNOT> -> $str {\n    my ($enc, $pow, %freq) = arithmethic_coding($str, $radix);\n    my $dec = arithmethic_decoding($enc, $radix, $pow, %freq);\n\n    printf(\"%-25s=> %19s * %d^%s\\n\", $str, $enc, $radix, $pow);\n\n    if ($str ne $dec) {\n        die \"\\tHowever that is incorrect!\";\n    }\n}\n\n```\n\nOutput:\n\n```\nDABDDB                   =>                 251 * 10^2\nDABDDBBDDBA              =>              167351 * 10^6\nABRACADABRA              =>             7954170 * 10^4\nTOBEORNOTTOBEORTOBEORNOT => 1150764267498783364 * 10^15\n\n```"}]}
{"messages": [{"role": "user", "content": "The **arithmetic derivative** of an integer (more specifically, the\n**Lagarias arithmetic derivative**) is a function defined for integers, based on prime\nfactorization, by analogy with the product rule for the derivative of a function that is\nused in mathematical analysis. Accordingly, for natural numbers n, the arithmetic\nderivative D(n) is defined as follows:\n\n* D ( 0 ) = D ( 1 ) = 0 {\\displaystyle {\\displaystyle D(0)=D(1)=0}} . * D ( p ) = 1 for any prime p {\\displaystyle {\\displaystyle D(p)=1\\;{\\text{for any prime}}\\;p}} . * D ( m n ) = D ( m ) n + m D ( n ) for any m , n ∈ N {\\displaystyle {\\displaystyle D(mn)=D(m)n+mD(n)\\;{\\text{for any}}\\;m,n\\in N}} . (Leibniz rule for derivatives).\n\nAdditionally, for negative integers the arithmetic derivative may be defined as \n\n−\nD\n(\n−\nn\n)\n\n\nfor\n\n(\nn\n<\n0\n)\n{\\displaystyle {\\displaystyle -D(-n)\\;{\\text{for}}\\;(n<0)}}\n.\n\nExamples\n\nD\n(\n2\n)\n=\n1\n{\\displaystyle {\\displaystyle D(2)=1}}\n and \n\nD\n(\n3\n)\n=\n1\n{\\displaystyle {\\displaystyle D(3)=1}}\n (both are prime) so if \n\nm\nn\n=\n2\n⋅\n3\n{\\displaystyle {\\displaystyle mn=2\\cdot 3}}\n, then \n\nD\n(\n6\n)\n=\nD\n(\n2\n⋅\n3\n)\n=\nD\n(\n2\n)\n⋅\n3\n+\n2\n⋅\nD\n(\n3\n)\n=\n1\n⋅\n3\n+\n2\n⋅\n1\n=\n5\n{\\displaystyle {\\displaystyle D(6)=D(2\\cdot 3)=D(2)\\cdot 3+2\\cdot D(3)=1\\cdot 3+2\\cdot 1=5}}\n.\n\nD\n(\n9\n)\n=\nD\n(\n3\n)\n⋅\n3\n+\n3\n⋅\nD\n(\n3\n)\n=\n1\n⋅\n3\n+\n3\n⋅\n1\n=\n6\n{\\displaystyle {\\displaystyle D(9)=D(3)\\cdot 3+3\\cdot D(3)=1\\cdot 3+3\\cdot 1=6}}\n\nD\n(\n27\n)\n=\nD\n(\n3\n)\n⋅\n9\n+\n3\n⋅\nD\n(\n9\n)\n=\n1\n⋅\n9\n+\n3\n⋅\n6\n=\n27\n{\\displaystyle {\\displaystyle D(27)=D(3)\\cdot 9+3\\cdot D(9)=1\\cdot 9+3\\cdot 6=27}}\n\nD\n(\n30\n)\n=\nD\n(\n5\n)\n⋅\n6\n+\n5\n⋅\nD\n(\n6\n)\n=\n1\n⋅\n6\n+\n5\n⋅\n5\n=\n31\n{\\displaystyle {\\displaystyle D(30)=D(5)\\cdot 6+5\\cdot D(6)=1\\cdot 6+5\\cdot 5=31}}\n.\n\nTask\n\nFind and show the arithmetic derivatives for -99 through 100.\n\nStretch task\n\nFind (the arithmetic derivative of \n\n10\n\nm\n{\\displaystyle {\\displaystyle 10^{m}}}\n) then divided by 7, where m is from 1 to 20.\n\nSee also\n\n* OEIS:A003415 - a(n) = n' = arithmetic derivative of n. * Wikipedia: Arithmetic Derivative"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\n\nmulti D (0) { 0 }\nmulti D (1) { 0 }\nmulti D ($n where &is-prime) { 1 }\nmulti D ($n where * < 0 ) { -D -$n }\nmulti D ($n) { sum $n.&prime-factors.Bag.map: { $n × .value / .key } }\n\n\nput (-99 .. 100).map(&D).batch(10)».fmt(\"%4d\").join: \"\\n\";\n\nput '';\n\nput join \"\\n\", (1..20).map: { sprintf \"D(10**%-2d) / 7 == %d\", $_, D(10**$_) / 7 }\n\n```\n\nOutput:\n\n```\n -75  -77   -1 -272  -24  -49  -34  -96  -20 -123\n  -1 -140  -32  -45  -22 -124   -1  -43 -108 -176\n  -1  -71  -18  -80  -55  -39   -1 -156   -1  -59\n -26  -72   -1  -61  -18 -192  -51  -33   -1  -92\n  -1  -31  -22  -92  -16  -81   -1  -56  -20  -45\n -14 -112   -1  -25  -39  -48   -1  -41   -1  -68\n -16  -21   -1  -60  -12  -19  -14  -80   -1  -31\n  -1  -32  -27  -15  -10  -44   -1  -13  -10  -24\n  -1  -21   -1  -32   -8   -9   -1  -16   -1   -7\n  -6  -12   -1   -5   -1   -4   -1   -1    0    0\n   0    1    1    4    1    5    1   12    6    7\n   1   16    1    9    8   32    1   21    1   24\n  10   13    1   44   10   15   27   32    1   31\n   1   80   14   19   12   60    1   21   16   68\n   1   41    1   48   39   25    1  112   14   45\n  20   56    1   81   16   92   22   31    1   92\n   1   33   51  192   18   61    1   72   26   59\n   1  156    1   39   55   80   18   71    1  176\n 108   43    1  124   22   45   32  140    1  123\n  20   96   34   49   24  272    1   77   75  140\n\nD(10**1 ) / 7 == 1\nD(10**2 ) / 7 == 20\nD(10**3 ) / 7 == 300\nD(10**4 ) / 7 == 4000\nD(10**5 ) / 7 == 50000\nD(10**6 ) / 7 == 600000\nD(10**7 ) / 7 == 7000000\nD(10**8 ) / 7 == 80000000\nD(10**9 ) / 7 == 900000000\nD(10**10) / 7 == 10000000000\nD(10**11) / 7 == 110000000000\nD(10**12) / 7 == 1200000000000\nD(10**13) / 7 == 13000000000000\nD(10**14) / 7 == 140000000000000\nD(10**15) / 7 == 1500000000000000\nD(10**16) / 7 == 16000000000000000\nD(10**17) / 7 == 170000000000000000\nD(10**18) / 7 == 1800000000000000000\nD(10**19) / 7 == 19000000000000000000\nD(10**20) / 7 == 200000000000000000000\n```"}]}
{"messages": [{"role": "user", "content": "Create a program which parses and evaluates arithmetic expressions.\n\nRequirements\n\n* An abstract-syntax tree (AST) for the expression must be created from parsing the input.\n* The AST must be used in evaluation, also, so the input may not be directly evaluated (e.g. by calling eval or a similar language feature.)\n* The expression will be a string or list of symbols like \"(1+3)\\*7\".\n* The four symbols + - \\* / must be supported as binary operators with conventional precedence rules.\n* Precedence-control parentheses must also be supported.\n\nNote\n\nFor those who don't remember, mathematical precedence is as follows:\n\n* Parentheses\n* Multiplication/Division (left to right)\n* Addition/Subtraction (left to right)\n\nC.f\n\n* 24 game Player.\n* Parsing/RPN calculator algorithm.\n* Parsing/RPN to infix conversion."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n```\nsub ev (Str $s --> Numeric) {\n\n    grammar expr {\n        token TOP { ^ <sum> $ }\n        token sum { <product> (('+' || '-') <product>)* }\n        token product { <factor> (('*' || '/') <factor>)* }\n        token factor { <unary_minus>? [ <parens> || <literal> ] }\n        token unary_minus { '-' }\n        token parens { '(' <sum> ')' }\n        token literal { \\d+ ['.' \\d+]? || '.' \\d+ }\n    }\n    \n    my sub minus ($b) { $b ?? -1 !! +1 }\n\n    my sub sum ($x) {\n        [+] flat product($x<product>), map\n            { minus($^y[0] eq '-') * product $^y<product> },\n            |($x[0] or [])\n    }\n    \n    my sub product ($x) {\n        [*] flat factor($x<factor>), map\n            { factor($^y<factor>) ** minus($^y[0] eq '/') },\n            |($x[0] or [])\n    }\n    \n    my sub factor ($x) {\n        minus($x<unary_minus>) * ($x<parens>\n          ?? sum $x<parens><sum>\n          !! $x<literal>)\n    }\n\n    expr.parse([~] split /\\s+/, $s);\n    $/ or fail 'No parse.';\n    sum $/<sum>;\n\n}\n\n# Testing:\n\nsay ev '5';                                    #   5\nsay ev '1 + 2 - 3 * 4 / 5';                    #   0.6\nsay ev '1 + 5*3.4 - .5  -4 / -2 * (3+4) -6';   #  25.5\nsay ev '((11+15)*15)* 2 + (3) * -4 *1';        # 768\n\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nA positive integer **n** is an arithmetic number if the average of its positive divisors is also an integer.\n\nClearly all odd primes **p** must be arithmetic numbers because their only divisors are **1** and **p** whose sum is even and hence their average must be an integer. However, the prime number **2** is not an arithmetic number because the average of its divisors is 1.5.\n\nExample\n\n30 is an arithmetic number because its 7 divisors are: [1, 2, 3, 5, 6, 10, 15, 30], their sum is 72 and average 9 which is an integer.\n\nTask\n\nCalculate and show here:\n\n1. The first 100 arithmetic numbers.\n\n2. The **x**th arithmetic number where **x** = 1,000 and **x** = 10,000.\n\n3. How many of the first **x** arithmetic numbers are composite.\n\nNote that, technically, the arithmetic number **1** is neither prime nor composite.\n\nStretch\n\nCarry out the same exercise in 2. and 3. above for **x** = 100,000 and **x** = 1,000,000.\n\nReferences\n\n* Wikipedia: Arithmetic number\n* OEIS:A003601 - Numbers n such that the average of the divisors of n is an integer"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\nuse Lingua::EN::Numbers;\n\nmy @arithmetic = lazy (1..∞).hyper.grep: { my @div = .&divisors; @div.sum %% @div }\n\nsay \"The first { .Int.&cardinal } arithmetic numbers:\\n\", @arithmetic[^$_].batch(10)».fmt(\"%{.chars}d\").join: \"\\n\" given 1e2;\n\nfor 1e3, 1e4, 1e5, 1e6 {\n    say \"\\nThe { .Int.&ordinal }: { comma @arithmetic[$_-1] }\";\n    say \"Composite arithmetic numbers ≤ { comma @arithmetic[$_-1] }: { comma +@arithmetic[^$_].grep({!.is-prime}) - 1 }\";\n}\n\n```\n\n```\nThe first one hundred arithmetic numbers:\n  1   3   5   6   7  11  13  14  15  17\n 19  20  21  22  23  27  29  30  31  33\n 35  37  38  39  41  42  43  44  45  46\n 47  49  51  53  54  55  56  57  59  60\n 61  62  65  66  67  68  69  70  71  73\n 77  78  79  83  85  86  87  89  91  92\n 93  94  95  96  97  99 101 102 103 105\n107 109 110 111 113 114 115 116 118 119\n123 125 126 127 129 131 132 133 134 135\n137 138 139 140 141 142 143 145 147 149\n\nThe one thousandth: 1,361\nComposite arithmetic numbers ≤ 1,361: 782\n\nThe ten thousandth: 12,953\nComposite arithmetic numbers ≤ 12,953: 8,458\n\nThe one hundred thousandth: 125,587\nComposite arithmetic numbers ≤ 125,587: 88,219\n\nThe one millionth: 1,228,663\nComposite arithmetic numbers ≤ 1,228,663: 905,043\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Arithmetic-geometric mean. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nWrite a function to compute the arithmetic-geometric mean of two numbers.\n\nThe arithmetic-geometric mean of two numbers can be (usefully) denoted as \n\na\ng\nm\n(\na\n,\ng\n)\n{\\displaystyle {\\displaystyle \\mathrm {agm} (a,g)}}\n, and is equal to the limit of the sequence:\n\n:   a\n\n    0\n    =\n    a\n    ;\n\n\n    g\n\n    0\n    =\n    g\n    {\\displaystyle {\\displaystyle a\\_{0}=a;\\qquad g\\_{0}=g}}\n:   a\n\n    n\n    +\n    1\n    =\n\n    1\n    2\n    (\n\n    a\n\n    n\n    +\n\n    g\n\n    n\n    )\n    ;\n\n\n    g\n\n    n\n    +\n    1\n    =\n\n    a\n\n    n\n\n    g\n\n    n\n    .\n    {\\displaystyle {\\displaystyle a\\_{n+1}={\\tfrac {1}{2}}(a\\_{n}+g\\_{n});\\quad g\\_{n+1}={\\sqrt {a\\_{n}g\\_{n}}}.}}\n\nSince the limit of \n\na\n\nn\n−\n\ng\n\nn\n{\\displaystyle {\\displaystyle a\\_{n}-g\\_{n}}}\n tends (rapidly) to zero with iterations, this is an efficient method.\n\nDemonstrate the function by calculating:\n\n:   a\n    g\n    m\n    (\n    1\n    ,\n    1\n\n    /\n\n\n    2\n    )\n    {\\displaystyle {\\displaystyle \\mathrm {agm} (1,1/{\\sqrt {2}})}}\n\nAlso see\n\n* mathworld.wolfram.com/Arithmetic-Geometric Mean"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub agm( $a is copy, $g is copy ) {\n    ($a, $g) = ($a + $g)/2, sqrt $a * $g until $a ≅ $g;\n    return $a;\n}\n \nsay agm 1, 1/sqrt 2;\n```\n\nOutput:\n\n```\n0.84721308479397917\n```\n\nIt's also possible to write it recursively:\n\n```\nsub agm( $a, $g ) {\n    $a ≅ $g ?? $a !! agm(|@$_)\n        given ($a + $g)/2, sqrt $a * $g;\n}\n\nsay agm 1, 1/sqrt 2;\n```\n\nWe can also get a bit fancy and use a converging sequence of complex numbers:\n\n```\nsub agm {\n  ($^z, {(.re+.im)/2 + (.re*.im).sqrt*1i} ... * ≅ *)\n  .tail.re\n}\n \nsay agm 1 + 1i/2.sqrt\n```"}]}
{"messages": [{"role": "user", "content": "Almkvist Berndt 1988 begins with an investigation of why the agm is such an efficient algorithm, and proves that it converges quadratically. This is an efficient method to calculate \n\nπ\n{\\displaystyle {\\displaystyle \\pi }}\n.\n\nWith the same notations used in Arithmetic-geometric mean, we can summarize the paper by writing:\n\nπ\n=\n\n4\n\n\na\ng\nm\n(\n1\n,\n1\n\n/\n\n\n2\n\n)\n\n2\n\n1\n−\n\n∑\n\nn\n=\n1\n\n∞\n\n2\n\nn\n+\n1\n(\n\na\n\nn\n\n2\n−\n\ng\n\nn\n\n2\n)\n{\\displaystyle {\\displaystyle \\pi ={\\frac {4\\;\\mathrm {agm} (1,1/{\\sqrt {2}})^{2}}{1-\\sum \\limits \\_{n=1}^{\\infty }2^{n+1}(a\\_{n}^{2}-g\\_{n}^{2})}}}}\n\nThis allows you to make the approximation, for any large   **N**:\n\nπ\n≈\n\n4\n\n\na\n\nN\n\n2\n\n1\n−\n\n∑\n\nk\n=\n1\n\nN\n\n2\n\nk\n+\n1\n(\n\na\n\nk\n\n2\n−\n\ng\n\nk\n\n2\n)\n{\\displaystyle {\\displaystyle \\pi \\approx {\\frac {4\\;a\\_{N}^{2}}{1-\\sum \\limits \\_{k=1}^{N}2^{k+1}(a\\_{k}^{2}-g\\_{k}^{2})}}}}\n\nThe purpose of this task is to demonstrate how to use this approximation in order to compute a large number of decimals of \n\nπ\n{\\displaystyle {\\displaystyle \\pi }}\n."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Ruby\n\nThere is not yet a FixDecimal type module in Raku, and using FatRat all along would be too slow and would be coerced to Num when computing the square root anyway, so we'll use a custom definition of the square root for Int and FatRat, with a limitation to the number of decimals. We'll show all the intermediate results.\n\nThe trick to compute the square root of a rational \n\nn\nd\n{\\displaystyle {\\displaystyle n \\over d}}\n up to a certain amount of decimals N is to write:\n\nn\nd\n=\n\nn\n\n10\n\n2\nN\n\n/\nd\n\nd\n\n10\n\n2\nN\n\n/\nd\n=\n\nn\n\n10\n\n2\nN\n\n/\nd\n\n10\n\nN\n{\\displaystyle {\\displaystyle {\\sqrt {\\frac {n}{d}}}={\\sqrt {\\frac {n10^{2N}/d}{d10^{2N}/d}}}={\\frac {\\sqrt {n10^{2N}/d}}{10^{N}}}}}\n\nso that what we need is one square root of a big number that we'll truncate to its integer part. We'll use the method described in Integer roots to compute the square root of this big integer.\n\nNotice that we don't get the exact number of decimals required : the last two decimals or so can be wrong. This is because we don't need \n\na\n\nn\n{\\displaystyle {\\displaystyle a\\_{n}}}\n, but rather \n\na\n\nn\n\n2\n{\\displaystyle {\\displaystyle a\\_{n}^{2}}}\n. Elevating to the square makes us lose a bit of precision. It could be compensated by choosing a slightly higher value of N (in a way that could be precisely calculated), but that would probably be overkill.\n\n```\nconstant number-of-decimals = 100;\n\nmulti sqrt(Int $n) {\n  (10**($n.chars div 2), { ($_ + $n div $_) div 2 } ... * == *).tail\n}\n\nmulti sqrt(FatRat $r --> FatRat) {\n  return FatRat.new:\n    sqrt($r.numerator * 10**(number-of-decimals*2) div $r.denominator),\n    10**number-of-decimals;\n}\n\nmy FatRat ($a, $n) = 1.FatRat xx 2;\nmy FatRat $g = sqrt(1/2.FatRat);\nmy $z = .25;\n\nfor ^10 {\n  given [ ($a + $g)/2, sqrt($a * $g) ] {\n    $z -= (.[0] - $a)**2 * $n;\n    $n += $n;\n    ($a, $g) = @$_;\n    say ($a ** 2 / $z).substr: 0, 2 + number-of-decimals;\n  }\n}\n\n```\n\nOutput:\n\n```\n3.1876726427121086272019299705253692326510535718593692264876339862751228325281223301147286106601617972\n3.1416802932976532939180704245600093827957194388154028326441894631956630010102553193888894275152646100\n3.1415926538954464960029147588180434861088792372613115896511013576846530795030865017740975862898631567\n3.1415926535897932384663606027066313217577024113424293564868460152384109486069277582680622007332762125\n3.1415926535897932384626433832795028841971699491647266058346961259487480060953290058518515759317101932\n3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280468522286541140\n3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170668\n3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170665\n3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170664\n3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170663\n\n```"}]}
{"messages": [{"role": "user", "content": "A   **complex number**   is a number which can be written as:\n\na\n+\nb\n×\ni\n{\\displaystyle {\\displaystyle a+b\\times i}}\n(sometimes shown as:\n\nb\n+\na\n×\ni\n{\\displaystyle {\\displaystyle b+a\\times i}}\nwhere   \n\na\n{\\displaystyle {\\displaystyle a}}\n   and   \n\nb\n{\\displaystyle {\\displaystyle b}}\n  are real numbers,   and  \ni\n{\\displaystyle {\\displaystyle i}}\n  is   √ -1 \n\nTypically, complex numbers are represented as a pair of real numbers called the \"imaginary part\" and \"real part\",   where the imaginary part is the number to be multiplied by \n\ni\n{\\displaystyle {\\displaystyle i}}\n.\n\nTask\n\n* Show addition, multiplication, negation, and inversion of complex numbers in separate functions. (Subtraction and division operations can be made with pairs of these operations.)\n* Print the results for each operation tested.\n* *Optional:* Show complex conjugation.\n\nBy definition, the   complex conjugate   of\n\na\n+\nb\ni\n{\\displaystyle {\\displaystyle a+bi}}\nis\n\na\n−\nb\ni\n{\\displaystyle {\\displaystyle a-bi}}\n\nSome languages have complex number libraries available.   If your language does, show the operations.   If your language does not, also show the definition of this type."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nmy $a = 1 + i;\nmy $b = pi + 1.25i;\n\n.say for $a + $b, $a * $b, -$a, 1 / $a, $a.conj;\n.say for $a.abs, $a.sqrt, $a.re, $a.im;\n\n```\n\nOutput:\n\n(precision varies with different implementations)\n\n```\n4.1415926535897931+2.25i\n1.8915926535897931+4.3915926535897931i\n-1-1i\n0.5-0.5i\n1-1i\n1.4142135623730951\n1.0986841134678098+0.45508986056222733i\n1\n1\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGet two integers from the user,   and then (for those two integers), display their:\n\n:   :   :   :   * sum\n                * difference\n                * product\n                * integer quotient\n                * remainder\n                * exponentiation   (if the operator exists)\n\nDon't include error handling.\n\nFor quotient, indicate how it rounds   (e.g. towards zero, towards negative infinity, etc.).\n\nFor remainder, indicate whether its sign matches the sign of the first operand or of the second operand, if they are different.\n\nBonus: Include an example of the integer `divmod` operator. For example: as in #Haskell, #Python and #ALGOL 68"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nNote that `div` **requires** integer arguments. If you want integer division with other types, say `floor($a/$b)`.\n\n```\nmy Int $a = get.floor;\nmy Int $b = get.floor;\n\nsay 'sum:              ', $a + $b;\nsay 'difference:       ', $a - $b;\nsay 'product:          ', $a * $b;\nsay 'integer quotient: ', $a div $b;\nsay 'remainder:        ', $a % $b;\nsay 'exponentiation:   ', $a**$b;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a reasonably complete implementation of rational arithmetic in the particular language using the idioms of the language.\n\nExample\n\nDefine a new type called **frac** with binary operator \"//\" of two integers that returns a **structure** made up of the numerator and the denominator (as per a rational number).\n\nFurther define the appropriate rational unary **operators** **abs** and '-', with the binary **operators** for addition '+', subtraction '-', multiplication '×', division '/', integer division '÷', modulo division, the comparison operators (e.g. '<', '≤', '>', & '≥') and equality operators (e.g. '=' & '≠').\n\nDefine standard coercion **operators** for casting **int** to **frac** etc.\n\nIf space allows, define standard increment and decrement **operators** (e.g. '+:=' & '-:=' etc.).\n\nFinally test the operators:\nUse the new type **frac** to find all perfect numbers less than 219 by summing the reciprocal of the factors.\n\nRelated tasks\n\n* Perfect Numbers\n* Check Machin-like formulas"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.08\n\nRaku supports rational arithmetic natively.\n\n```\n(2..2**19).hyper.map: -> $candidate {\n    my $sum = 1 / $candidate;\n    for 2 .. ceiling(sqrt($candidate)) -> $factor {\n        if $candidate %% $factor {\n            $sum += 1 / $factor + 1 / ($candidate / $factor);\n        }\n    }\n    if $sum.nude[1] == 1 {\n        say \"Sum of reciprocal factors of $candidate = $sum exactly\", ($sum == 1 ?? \", perfect!\" !! \".\");\n    }\n}\n\n```\n\nNote also that ordinary decimal literals are stored as Rats, so the following loop always stops exactly on 10 despite 0.1 not being exactly representable in floating point:\n\n```\nfor 1.0, 1.1, 1.2 ... 10 { .say }\n\n```\n\nThe arithmetic is all done in rationals, which are converted to floating-point just before display so that people don't have to puzzle out what 53/10 means."}]}
{"messages": [{"role": "user", "content": "Task\n\nShow how to concatenate two arrays in your language.\n\nIf this is as simple as `array1 + array2`, so be it."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.06\n\n```\nmy @array1 = 1, 2, 3;\nmy @array2 = 4, 5, 6;\n\n# If you want to concatenate two array to form a third,\n# either use the slip operator \"|\", to flatten each array.\n\nmy @array3 = |@array1, |@array2;\nsay @array3;\n\n# or just flatten both arrays in one fell swoop\n\n@array3 = flat @array1, @array2;\nsay @array3;\n\n# On the other hand, if you just want to add the elements\n# of the second array to the first, use the .append method.\n\nsay @array1.append: @array2;\n```\n\nOutput:\n\n```\n[1 2 3 4 5 6]\n[1 2 3 4 5 6]\n[1 2 3 4 5 6]\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDetermine the number of elements in an array.\n\nAs an example use an array holding the strings 'apple' and 'orange'.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.04\n\nTo get the number of elements of an array in Raku you put the array in a coercing Numeric context, or call `elems` on it.\n\n```\nmy @array = <apple orange>;\n\nsay @array.elems;  # 2\nsay elems @array;  # 2\nsay + @array;      # 2\nsay @array + 0;    # 2\n```\n\nWatch out for infinite/lazy arrays though. You can't get the length of those.\n\n```\nmy @infinite = 1 .. Inf;  # 1, 2, 3, 4, ...\n\nsay @infinite[5000];  # 5001\nsay @infinite.elems;  # Throws exception \"Cannot .elems a lazy list\"\n```"}]}
{"messages": [{"role": "user", "content": "This task is about arrays.\n\nFor hashes or associative arrays, please see Creating an Associative Array.\n\nFor a definition and in-depth discussion of what an array is, see Array.\n\nTask\n\nShow basic array syntax in your language.\n\nBasically, create an array, assign a value to it, and retrieve an element   (if available, show both fixed-length arrays and\ndynamic arrays, pushing a value into it).\n\nPlease discuss at Village Pump:   Arrays.\n\nPlease merge code in from these obsolete tasks:\n\n:   :   :   * Creating an Array\n            * Assigning Values to an Array\n            * Retrieving an Element of an Array\n\nRelated tasks\n\n* Collections\n* Creating an Associative Array\n* Two-dimensional array (runtime)"}, {"role": "assistant", "content": "(formerly Perl 6)\nAt its most basic, an array in Raku is quite similar to an array in Perl 5.\n\n```\nmy @arr;\n \npush @arr, 1;\npush @arr, 3;\n \n@arr[0] = 2;\n \nsay @arr[0];\n```\n\n### Some further exposition:\n\nIn Raku, arrays have a very specific definition: \"A collection of Scalar containers that do the Positional Role.\" Scalar container means it is mutable and may contain any object; an Integer, a Rational number, a String, another Array, whatever... literally any other object that can be instantiated in Raku. The Positional Role means that it uses integer indexing for access. The index must be a positive integer, an expression that evaluates to a positive integer, or something that can be coerced to a positive integer. Arrays are always indexed from 0. The starting index can not be changed.\n\nArrays are unconstrained by default. They may hold any number of any type of object up to available memory. They do not need to be pre-allocated. Simply assigning (or even referring in some cases) to an index slot is enough to autovivify the container and allocate enough memory to hold the assigned object. Memory will automatically be allocated and will grow and shrink as necessary to hold the values assigned.\n\nValues may be pushed onto the end of an array, popped off of the end, shifted off of the front or unshifted onto the front, and spliced into or out of the interior.\n\n```\n   @array.push: 'value';\n   my $value = @array.pop;\n   @array.unshift: 'value';\n   my $value = @array.shift;\n   @array.splice(2,3, <some arbitrary string values>);\n\n```\n\nArrays may be constrained to only accept a certain number of objects or only a certain type of object.\n\n```\n   my Int @array; # can only hold Integer objects. Assigning any other type will cause an exception.\n   my @array[9];  # can only 10 objects (zero indexed). Trying to assign to an index greater than 9 with cause an exception. \n\n```\n\nArrays are constructed with square brackets, an explicit constructor, or by coercing some other object either explicitly using a coercer or implicitly by simply assigning to an array variable. These are all arrays:\n\n```\n   [1, 2, 3, 4]\n   ['a', 'b', 'c', 'd']\n   Array.new<this is an array of words>\n   ('as', 'is', 'this').Array\n   my @implicit = <yep, this too>\n\n```\n\nArray variables in Raku are variables whose names bear the @ sigil, and are expected to contain some sort of list-like object. Of course, other variables may also contain these objects, but @-sigiled variables always do, and are expected to act the part. Array storage slots are accessed through postcircumfix square bracket notation. Unlike Perl 5, @-sigiled variables are invariant on access, whether you are accessing one slot, many slots, or all of the slots. The first slot in @array is @array[0] not $array[0]. @array and $array are two different unconnected variables.\n\n```\n   @array[1]      # a single value in the 2nd slot\n   @array[*-1]    # a single value in the last slot\n   @array[1..5]   # an array slice, 2nd through 6th slots\n   @array[1,3,7]  # slice, 2nd, 4th and 8th slot\n   @array[8,5,2]  # can be in any order\n   @array[*]      # all the slots\n   @array[]       # all the slots (zen slice)\n   @array[^10]    # first 10 slots (upto 10 or 0..9)\n   @array.head(5) # first 5 slots\n   @array.tail(2) # last two\n\n```\n\nMulti-dimensioned arrays also use postcircumfix square brackets for access. If the array is not ragged, (every sub array is the same size) you may use semicolon subscripting.\n\n```\n   @array[1][1]   # 2nd item in the second slot\n   @array[1;1]    # same thing, implies rectangular (non-ragged) arrays\n\n```\n\nThere are several objects that have an Iterable Role and a PositionalBindFailover Role which makes them act similar to arrays and allows them to be used nearly interchangeably in read-only applications. (Raku is big on duck typing. \"If it looks like a duck and quacks like a duck and waddles like a duck, it's a duck.\") These constructs are ordered and use integer indexing and are often used in similar circumstances as arrays, however, **they are immutable**. Values in slots can not be changed. They can not be pushed to, popped from or spliced. They can easily converted to arrays by simply assigning them to an array variable.\n\n**List**: A fixed Iterable collection of immutable values. Lists are constructed similarly to arrays:\n\n```\n   (1, 2, 3, 4)\n   ('a', 'b', 'c', 'd')\n   List.new(<this is a list of words>)\n   ('as', 'is', 'this').List\n   my @not-a-list = (<oops, this isn't>)\n   my @implicit := (<but this is>) # note the values are bound := not assigned =\n\n```\n\n**Range**: Iterable list of consecutive numbers or strings with a lower and an upper boundary. (That boundary may be infinite.) Reified on demand.\n\n```\n   2..20    # integers two through twenty\n   1..Inf   # natural numbers\n   'a'..'z' # lowercase latin letters\n\n```\n\n**Sequence**: Iterable list of objects with some method to determine the next (or previous) item in the list. Reified on demand. Will try to automatically deduce simple arithmetic or geometric sequences. Pass in a code object to calculate more complex sequences.\n\n```\n  0,2,4 ... 64   # even numbers up to 64\n  1,2,4 ... 64   # geometric increase\n  1,1, *+* ... * # infinite Fibonacci sequence\n  1,1,{$^n2 + $^n1 + 1} ... * # infinite Leonardo numbers\n\n```\n\nPostcircumfix indexing works for any object that has a Positional (or PositionalBindFailover) role, it need not be in a @-sigiled variable, or indeed, in a variable at all.\n\n```\n   [2,4,6,8,10][1]                             # 4 - anonymous array\n   <my dog has fleas>[*-2]                     # 'has' - anonymous list\n   sub a {(^Inf).grep: *.is-prime}; a()[99];   # 541 - (100th prime) subroutine returning a sequence\n   my $lol = ((1,2), (3,4), (5,6)); $lol[1];   # (3 4) - list of lists in a Scalar variable\n\n```"}]}
{"messages": [{"role": "user", "content": "Generate and show all primes with strictly ascending decimal digits.\n\nAside: Try solving without peeking at existing solutions. I had a weird idea for generating\na prime sieve faster, which needless to say didn't pan out. The solution may be p(r)etty trivial\nbut generating them quickly is at least mildly interesting.\nTip: filtering all 7,027,260 primes below 123,456,789 probably won't kill you, but there is\nat least one significantly better and much faster way, needing a mere 511 odd/prime tests.\n\nSee also\n\n* OEIS:A052015 - Primes with distinct digits in ascending order\n\nRelated\n\n* Primes with digits in nondecreasing order (infinite series allowing duplicate digits, whereas this isn't and doesn't)\n* Pandigital prime (whereas this is the smallest, with gaps in the used digits being permitted)\n* Descending primes"}, {"role": "assistant", "content": "```\nput (flat 2, 3, 5, 7, sort +*, gather (1..8).map: &recurse ).batch(10)».fmt(\"%8d\").join: \"\\n\";\n\nsub recurse ($str) {\n    .take for ($str X~ (3, 7, 9)).grep: { .is-prime && [<] .comb };\n    recurse $str × 10 + $_ for $str % 10 ^.. 9;\n}\n\nprintf \"%.3f seconds\", now - INIT now;\n\n```\n\nOutput:\n\n```\n       2        3        5        7       13       17       19       23       29       37\n      47       59       67       79       89      127      137      139      149      157\n     167      179      239      257      269      347      349      359      367      379\n     389      457      467      479      569     1237     1249     1259     1279     1289\n    1367     1459     1489     1567     1579     1789     2347     2357     2389     2459\n    2467     2579     2689     2789     3457     3467     3469     4567     4679     4789\n    5689    12347    12379    12457    12479    12569    12589    12689    13457    13469\n   13567    13679    13789    15679    23459    23567    23689    23789    25679    34589\n   34679   123457   123479   124567   124679   125789   134789   145679   234589   235679\n  235789   245789   345679   345689  1234789  1235789  1245689  1456789 12356789 23456789\n0.075 seconds\n```"}]}
{"messages": [{"role": "user", "content": "Given the RFC 1035 message diagram from Section 4.1.1 (Header section format) as a string:\nhttp://www.ietf.org/rfc/rfc1035.txt\n\n```\n+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n|                      ID                       |\n+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n|QR|   Opcode  |AA|TC|RD|RA|   Z    |   RCODE   |\n+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n|                    QDCOUNT                    |\n+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n|                    ANCOUNT                    |\n+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n|                    NSCOUNT                    |\n+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n|                    ARCOUNT                    |\n+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n\n```\n\nWhere (every column of the table is 1 bit):\n\n```\nID is 16 bits\nQR = Query (0) or Response (1)\nOpcode = Four bits defining kind of query:\n  0:    a standard query (QUERY)\n  1:    an inverse query (IQUERY)\n  2:    a server status request (STATUS)\n  3-15: reserved for future use\nAA = Authoritative Answer bit\nTC = Truncation bit\nRD = Recursion Desired bit\nRA = Recursion Available bit\nZ = Reserved\nRCODE = Response code\nQC = Question Count\nANC = Answer Count\nAUC = Authority Count\nADC = Additional Count\n\n```\n\nWrite a function, member function, class or template that accepts a similar multi-line string as input to define a data structure or something else able to decode or store a header with that specified bit structure.\n\nIf your language has macros, introspection, code generation, or powerful enough templates, then accept such string at compile-time to define the header data structure statically.\n\nSuch \"Header\" function or template should accept a table with 8, 16, 32 or 64 columns, and any number of rows. For simplicity the only allowed symbols to define the table are + - | (plus, minus, pipe), and whitespace. Lines of the input string composed just of whitespace should be ignored. Leading and trailing whitespace in the input string should be ignored, as well as before and after each table row. The box for each bit of the diagram takes four chars \"+--+\". The code should perform a little of validation of the input string, but for brevity a full validation is not required.\n\nBonus: perform a thoroughly validation of the input string."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.05\n\n```\ngrammar RFC1025 {\n    rule  TOP {  <.line-separator> [<line> <.line-separator>]+ }\n    rule  line-separator { <.ws> '+--'+ '+' }\n    token line  { <.ws> '|' +%% <field>  }\n    token field  { \\s* <label> \\s* }\n    token label { \\w+[\\s+\\w+]* }\n}\n\nsub bits ($item) { ($item.chars + 1) div 3 }\n\nsub deconstruct ($bits, %struct) {\n    map { $bits.substr(.<from>, .<bits>) }, @(%struct<fields>);\n}\n\nsub interpret ($header) {\n    my $datagram = RFC1025.parse($header);\n    my %struct;\n    for $datagram.<line> -> $line {\n        FIRST %struct<line-width> = $line.&bits;\n        state $from = 0;\n        %struct<fields>.push: %(:bits(.&bits), :ID(.<label>.Str), :from($from.clone), :to(($from+=.&bits)-1))\n          for $line<field>;\n    }\n    %struct\n}\n\nuse experimental :pack;\n\nmy $diagram = q:to/END/;\n\n    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n    |                      ID                       |\n    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n    |QR|   Opcode  |AA|TC|RD|RA|   Z    |   RCODE   |\n    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n    |                    QDCOUNT                    |\n    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n    |                    ANCOUNT                    |\n    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n    |                    NSCOUNT                    |\n    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n    |                    ARCOUNT                    |\n    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n\nEND\n\nmy %structure = interpret($diagram);\n\nsay 'Line width: ', %structure<line-width>, ' bits';\nprintf(\"Name: %7s, bit count: %2d, bit %2d to bit %2d\\n\", .<ID>, .<bits>, .<from>, .<to>) for @(%structure<fields>);\nsay \"\\nGenerate a random 12 byte \\\"header\\\"\";\nsay my $buf = Buf.new((^0xFF .roll) xx 12);\nsay \"\\nShow it converted to a bit string\";\nsay my $bitstr = $buf.unpack('C*')».fmt(\"%08b\").join;\nsay \"\\nAnd unpack it\";\nprintf(\"%7s, %02d bits: %s\\n\", %structure<fields>[$_]<ID>,  %structure<fields>[$_]<bits>,\n  deconstruct($bitstr, %structure)[$_]) for ^@(%structure<fields>);\n\n```\n\nOutput:\n\n```\nLine width: 16 bits\nName:      ID, bit count: 16, bit  0 to bit 15\nName:      QR, bit count:  1, bit 16 to bit 16\nName:  Opcode, bit count:  4, bit 17 to bit 20\nName:      AA, bit count:  1, bit 21 to bit 21\nName:      TC, bit count:  1, bit 22 to bit 22\nName:      RD, bit count:  1, bit 23 to bit 23\nName:      RA, bit count:  1, bit 24 to bit 24\nName:       Z, bit count:  3, bit 25 to bit 27\nName:   RCODE, bit count:  4, bit 28 to bit 31\nName: QDCOUNT, bit count: 16, bit 32 to bit 47\nName: ANCOUNT, bit count: 16, bit 48 to bit 63\nName: NSCOUNT, bit count: 16, bit 64 to bit 79\nName: ARCOUNT, bit count: 16, bit 80 to bit 95\n\nGenerate a random 12 byte \"header\"\nBuf:0x<78 47 7b bf 54 96 e1 2e 1b f1 69 a4>\n\nShow it converted to a bit string\n011110000100011101111011101111110101010010010110111000010010111000011011111100010110100110100100\n\nAnd unpack it\n     ID, 16 bits: 0111100001000111\n     QR, 01 bits: 0\n Opcode, 04 bits: 1111\n     AA, 01 bits: 0\n     TC, 01 bits: 1\n     RD, 01 bits: 1\n     RA, 01 bits: 1\n      Z, 03 bits: 011\n  RCODE, 04 bits: 1111\nQDCOUNT, 16 bits: 0101010010010110\nANCOUNT, 16 bits: 1110000100101110\nNSCOUNT, 16 bits: 0001101111110001\nARCOUNT, 16 bits: 0110100110100100\n```"}]}
{"messages": [{"role": "user", "content": "ASCII is the American Standard Code for Information Interchange. There are 128 ASCII characters of which the first 32 and the last are 'control characters'.\n\nTask\n\nShow how your language might treat control characters *en bloc* by using an enum, an enum like structure or other approach to associate their names with their ASCII values thereby enabling them to be retrieved or listed by name.\n\nTechnically, the 33rd character 'space' is a printable character, not a control character, though you may treat it as the latter for the purposes of this task.\n\nReference\n\n* Wikipedia: ASCII"}, {"role": "assistant", "content": "There doesn't seem to really be a point or a purpose to this task other than creating a enumeration...\n\n'space' is absolutely **NOT** a control character. Pretending it is is just completely incorrect.\n\n```\nenum C0 (|(^32).map({ (0x2400 + $_).chr => $_ }), '␡' => 127);\n\nprintf \"Ord: %3d, Unicode: %s, Enum: %s\\n\", $_, .uniname, C0($_)\n   for (^128).grep: {.chr ~~ /<:Cc>/}\n\n```\n\nOutput:\n\n```\nOrd:   0, Unicode: <control-0000>, Enum: ␀\nOrd:   1, Unicode: <control-0001>, Enum: ␁\nOrd:   2, Unicode: <control-0002>, Enum: ␂\nOrd:   3, Unicode: <control-0003>, Enum: ␃\nOrd:   4, Unicode: <control-0004>, Enum: ␄\nOrd:   5, Unicode: <control-0005>, Enum: ␅\nOrd:   6, Unicode: <control-0006>, Enum: ␆\nOrd:   7, Unicode: <control-0007>, Enum: ␇\nOrd:   8, Unicode: <control-0008>, Enum: ␈\nOrd:   9, Unicode: <control-0009>, Enum: ␉\nOrd:  10, Unicode: <control-000A>, Enum: ␊\nOrd:  11, Unicode: <control-000B>, Enum: ␋\nOrd:  12, Unicode: <control-000C>, Enum: ␌\nOrd:  13, Unicode: <control-000D>, Enum: ␍\nOrd:  14, Unicode: <control-000E>, Enum: ␎\nOrd:  15, Unicode: <control-000F>, Enum: ␏\nOrd:  16, Unicode: <control-0010>, Enum: ␐\nOrd:  17, Unicode: <control-0011>, Enum: ␑\nOrd:  18, Unicode: <control-0012>, Enum: ␒\nOrd:  19, Unicode: <control-0013>, Enum: ␓\nOrd:  20, Unicode: <control-0014>, Enum: ␔\nOrd:  21, Unicode: <control-0015>, Enum: ␕\nOrd:  22, Unicode: <control-0016>, Enum: ␖\nOrd:  23, Unicode: <control-0017>, Enum: ␗\nOrd:  24, Unicode: <control-0018>, Enum: ␘\nOrd:  25, Unicode: <control-0019>, Enum: ␙\nOrd:  26, Unicode: <control-001A>, Enum: ␚\nOrd:  27, Unicode: <control-001B>, Enum: ␛\nOrd:  28, Unicode: <control-001C>, Enum: ␜\nOrd:  29, Unicode: <control-001D>, Enum: ␝\nOrd:  30, Unicode: <control-001E>, Enum: ␞\nOrd:  31, Unicode: <control-001F>, Enum: ␟\nOrd: 127, Unicode: <control-007F>, Enum: ␡\n\n```"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nThe main goal of Aspect Oriented Programming (AOP) is to keep all the code relating to a single feature in one module of code.\n\nThere are a variety of ways to achieve this with object-oriented programming and functional programming, including inheritance, decorators and configuration trees.\n\nIn Aspect Oriented Programming existing code is extended with new behaviors invisibly, by means of stealthy instrumentation. There are some similarities between this concept and some debugging tools, such as Linux Kernel Probes. In fact, one obvious application for AOP is to add detailed tracing, with access to data, without touching the instrumented code. An aspect could be used to capture the calls to an entire API and log the arguments and return values.\n\nThe idea is that when the instrumented function is executes, either prior the execution of function, or at its point of return, or both, a block of code in instrumenting module is able to gain control. It can obtain access to the function arguments almost as if it were its own arguments, execute its own logic, and even decide whether or not the instrumented function will run at all, and with what argument values, and what it shall return.\n\nFurthermore, there can be additional refinements, such as instrumenting calls to some function A, but only when it is directly called by function B. Or only when function B is somewhere in the activation chain, etc.\n\nAlso part of AOP is the idea of instrumenting data structures such as classes. An \"aspect\" is a hidden extension to some existing set of classes, which adds hidden new instance variables to the class. These variables are not accessible by the class itself, only by the instrumenting Aspect code. An object-oriented Aspect resembles a class, except that its instance variables are injected into another class (or classes!), and its methods are instrumenting hooks that capture control from the methods of other classes.\n\nAn Aspect Oriented Programming System provides the abstractions to make this happen: a way to write aspects which specify what classes and methods they instrument, and the code, data and activation rules for doing it.\n\nAOP introduces some new terms. A \"join point\" is a place in the control flow where code is instrumented, like a function call or return. A \"point cut\" is a selection of join points according to some query, which are tied to a common instrumenting code. (A single instrumenting function can handle a large point cut of different join points.)\n\nAOP allows for a \"separation of concerns\" because new features are introduced as aspects tied to the execution of existing code, but without touching any of it, thereby keeping code bases completely separate. For instance, a mutex locking discipline can be added to a class without touching any of its code. An aspect identifies the methods that need locking, introduces the mutex variable into every instance of every instrumented class, and gains control around the invocations of the targetted methods to manage the mutex. Without AOP, the concern for locking is spread everywhere. Mutex lock/unlock calls have to be written or at the very least, methods have to be declared as synchronized, and this is repeated in every class that requires locking.\n\nTask\n\nThe task is to describe or show how, or to what extent, a given programming language implements, or is able to implement or simulate, Aspect Oriented Programming."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nAll methods in Raku are really just routines under the control of the meta-object protocol for purposes of dispatch, so there are several ways to subvert the system in order to deal with aspects. First, you could intercept the MOP calls, or you could install alternate metaclasses. More likely, since methods are really just routines in disguise, and since a routine can be wrapped (in place) in an outer routine via the .wrap method, you'd just wrap all the methods and other routines that share a cross-cutting concern.\n\nNote that the optimizer is free to assume routines are immutable after CHECK time (the end of compilation), so while you can always wrap routines during compile time, you might need a \"use soft\" declaration or some such to enable wrapping at run time, that is, in order to keep considering the routine to be mutable. (Only code doing the Routine role is ever mutable in Raku—bare blocks and other lambdas are considered immutable from the start.) Note that keeping routines mutable is likely to pessimize spots where the optimizer might otherwise be able to inline the code.\n\nOf course, you can also simply redefine Raku on the fly to be any language you want in the current lexical scope, so you are really only limited by your imagination in how you wish to express these \"aspects\", whatever you might mean by that term…"}]}
{"messages": [{"role": "user", "content": "Assertions are a way of breaking out of code when there is an error or an unexpected input.\n\nSome languages throw exceptions and some treat it as a break point.\n\nTask\n\nShow an assertion in your language by asserting that an integer variable is equal to **42**."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $a = (1..100).pick;\n$a == 42 or die '$a ain\\'t 42';\n\n```"}]}
{"messages": [{"role": "user", "content": "According to   Wikipedia;   assertions can function as a form of documentation:   they can describe the state the code expects to find before it runs (its preconditions), and the state the code expects to result in when it is finished running (postconditions);   they can also specify invariants of a class.\n\nTask\n\nShow in the program language of your choice an example of the use of assertions as a form of documentation."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.05\n\nMost of theses entries seem to have missed the point. This isn't about how to implement or use assertions, it is about how the language uses design-by-contract to help the programmer get correct results.\n\nRaku doesn't have an assert routine in CORE. You could easily add one; several modules geared toward unit testing supply various \"assertion\" routines, though I'm not aware of any actually specifically named \"assert()\".\n\nRaku core has subroutine signatures, multi-dispatch and exceptions to implement design-by-contract.\n\nSubroutine signature allow the programmer to make the parameters supplied to a routine be checked to make sure they are the of correct quantity, type, and value and can constrain the returned value(s) to a particular type. See the below snippet for a brief demonstration. Raku does some static analysis to trap errors at compile time, but traps many errors at run time since it is often impossible to tell if a variable is of the correct type before the program is run.\n\nWhen Raku encounters a design-by-contract violation, it will fail with an error message telling where the problem occurred, what it expected and what it actually got. Some failures are trappable and resumeable. Failures may be trapped by adding a CATCH { } block in the current scope. Failures will transfer execution to the CATCH block where the failure may be analysed and further action taken. Depending on the failure type, execution may be resumable. Some failures cause execution to halt unavoidably.\n\nIn this snippet, the routine repeat takes one Integer that must be greater than 1, a String and returns a String. (Note that as written, it is incorrect since it actually returns a boolean.)\n\n```\nsub repeat ( Int $repeat where * > 1, Str $message, --> Str ) {\n    say $message x $repeat;\n    True # wrong return type\n}\n\nrepeat( 2, 'A' ); # parameters ok, return type check error\n\nrepeat( 4, 2 ); # wrong second parameter type\n\nrepeat( 'B', 3 ); # wrong first (and second) parameter type\n\nrepeat( 1, 'C' ); # constraint check fail\n\nrepeat( ); # wrong number of parameters\n\nCATCH {\n    default {\n        say \"Error trapped: $_\";\n        .resume;\n    }\n}\n\n```\n\nOutput:\n\n```\nAA\nError trapped: Type check failed for return value; expected Str but got Bool (Bool::True)\nError trapped: Type check failed in binding to parameter '$message'; expected Str but got Int (2)\nError trapped: Type check failed in binding to parameter '$repeat'; expected Int but got Str (\"B\")\nError trapped: Constraint type check failed in binding to parameter '$repeat'; expected anonymous constraint to be met but got Int (1)\nError trapped: Too few positionals passed; expected 2 arguments but got 0\nThis exception is not resumable\n  in block  at contract.p6 line 19\n  in block <unit> at contract.p6 line 14\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nThe goal is to create an associative array (also known as a dictionary, map, or hash).\n\nRelated tasks:\n\n* Associative arrays/Iteration\n* Hash from two arrays\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nThe fatarrow, `=>`, is no longer just a quoting comma; it now constructs a `Pair` object. But you can still define a hash with an ordinary list of even length.\n\n```\nmy %h1 = key1 => 'val1', 'key-2' => 2, three => -238.83, 4 => 'val3';\nmy %h2 = 'key1', 'val1', 'key-2', 2, 'three', -238.83, 4, 'val3';\n\n# Creating a hash from two lists using a metaoperator.\n\nmy @a = 1..5;\nmy @b = 'a'..'e';\nmy %h = @a Z=> @b;\n\n# Hash elements and hash slices now use the same sigil as the whole hash. This is construed as a feature.\n# Curly braces no longer auto-quote, but Raku's qw (shortcut < ... >) now auto-subscripts.\n\nsay %h1{'key1'};\nsay %h1<key1>;\n%h1<key1> = 'val1';\n%h1<key1 three> = 'val1', -238.83;\n\n# Special syntax is no longer necessary to access a hash stored in a scalar.\n\nmy $h = {key1 => 'val1', 'key-2' => 2, three => -238.83, 4 => 'val3'};\nsay $h<key1>;\n\n# Keys are of type Str or Int by default. The type of the key can be provided.\n\nmy %hash{Any}; # same as %hash{*}\nclass C {};\nmy %cash{C};\n%cash{C.new} = 1;\n```"}]}
{"messages": [{"role": "user", "content": "Show how to iterate over the key-value pairs of an associative array, and print each pair out.\n\nAlso show how to iterate just over the keys, or the values, if there is a separate way to do that in your language.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nmy %pairs = hello => 13, world => 31, '!' => 71;\n \nfor %pairs.kv -> $k, $v {\n    say \"(k,v) = ($k, $v)\";\n}\n\n# Stable order\nfor %pairs.sort(*.value)>>.kv -> ($k, $v) {\n    say \"(k,v) = ($k, $v)\";\n}\n\n{ say \"$^a => $^b\" } for %pairs.kv;\n\nsay \"key = $_\" for %pairs.keys;\n\nsay \"value = $_\" for %pairs.values;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDefine two associative arrays, where one represents the following \"base\" data:\n\n:   :   :   :   :   |  |  |\n                    | --- | --- |\n                    | **Key** | **Value** |\n                    | \"name\" | \"Rocket Skates\" |\n                    | \"price\" | 12.75 |\n                    | \"color\" | \"yellow\" |\n\nAnd the other represents \"update\" data:\n\n:   :   :   :   :   |  |  |\n                    | --- | --- |\n                    | **Key** | **Value** |\n                    | \"price\" | 15.25 |\n                    | \"color\" | \"red\" |\n                    | \"year\" | 1974 |\n\nMerge these into a new associative array that contains every key found in either of the source ones. Each key should map to the value in the second (update) table if that exists, or else to the value in the first (base) table. If possible, do this in a way that does not mutate the original two associative arrays. Obviously this should be done in a way that would work for any data, not just the specific data given here, but in this example the result should be:\n\n:   :   :   :   :   |  |  |\n                    | --- | --- |\n                    | **Key** | **Value** |\n                    | \"name\" | \"Rocket Skates\" |\n                    | \"price\" | 15.25 |\n                    | \"color\" | \"red\" |\n                    | \"year\" | 1974 |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\nI must say I somewhat disagree with the terminology. The requested operation is an update not a merge. Demonstrate both an update and a merge. Associative arrays are commonly called hashes in Raku.\n\n```\n# Show original hashes\nsay my %base   = :name('Rocket Skates'), :price<12.75>, :color<yellow>;\nsay my %update = :price<15.25>, :color<red>, :year<1974>;\n\n# Need to assign to anonymous hash to get the desired results and avoid mutating\n# TIMTOWTDI\nsay \"\\nUpdate:\\n\", join \"\\n\", sort %=%base, %update;\n# Same\nsay \"\\nUpdate:\\n\", {%base, %update}.sort.join: \"\\n\";\n\nsay \"\\nMerge:\\n\", join \"\\n\", sort ((%=%base).push: %update)».join: ', ';\n# Same\nsay \"\\nMerge:\\n\", ({%base}.push: %update)».join(', ').sort.join: \"\\n\";\n\n# Demonstrate unmutated hashes\nsay \"\\n\", %base, \"\\n\", %update;\n\n```\n\nOutput:\n\n```\n{color => yellow, name => Rocket Skates, price => 12.75}\n{color => red, price => 15.25, year => 1974}\n\nUpdate:\ncolor\tred\nname\tRocket Skates\nprice\t15.25\nyear\t1974\n\nUpdate:\ncolor\tred\nname\tRocket Skates\nprice\t15.25\nyear\t1974\n\nMerge:\ncolor\tyellow, red\nname\tRocket Skates\nprice\t12.75, 15.25\nyear\t1974\n\nMerge:\ncolor\tyellow, red\nname\tRocket Skates\nprice\t12.75, 15.25\nyear\t1974\n\n{color => yellow, name => Rocket Skates, price => 12.75}\n{color => red, price => 15.25, year => 1974}\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDefine a data type consisting of a fixed number of 'buckets', each containing a nonnegative integer value, which supports operations to:\n\n1. get the current value of any bucket\n2. remove a specified amount from one specified bucket and add it to another, preserving the total of all bucket values, and clamping the transferred amount to ensure the values remain non-negative\n\n---\n\nIn order to exercise this data type, create one set of buckets, and start three concurrent tasks:\n\n1. As often as possible, pick two buckets and make their values closer to equal.\n2. As often as possible, pick two buckets and arbitrarily redistribute their values.\n3. At whatever rate is convenient, display (by any means) the total value and, optionally, the individual values of each bucket.\n\nThe display task need not be explicit; use of e.g. a debugger or trace tool is acceptable provided it is simple to set up to provide the display.\n\n---\n\nThis task is intended as an exercise in *atomic* operations.   The sum of the bucket values must be preserved even if the two tasks attempt to perform transfers simultaneously, and a straightforward solution is to ensure that at any time, only one transfer is actually occurring — that the transfer operation is *atomic*."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Ruby\n\n**Works with**: Rakudo version 2016.07\n\n```\n#| A collection of non-negative integers, with atomic operations.\nclass BucketStore {\n  \n  has $.elems is required;\n  has @!buckets = ^1024 .pick xx $!elems;\n  has $lock     = Lock.new;\n \n  #| Returns an array with the contents of all buckets.\n  method buckets {\n    $lock.protect: { [@!buckets] }\n  }\n \n  #| Transfers $amount from bucket at index $from, to bucket at index $to.\n  method transfer ($amount, :$from!, :$to!) {\n    return if $from == $to;\n \n    $lock.protect: {\n      my $clamped = $amount min @!buckets[$from];\n \n      @!buckets[$from] -= $clamped;\n      @!buckets[$to]   += $clamped;\n    }\n  }\n}\n\n# Create bucket store\nmy $bucket-store = BucketStore.new: elems => 8;\nmy $initial-sum = $bucket-store.buckets.sum;\n\n# Start a thread to equalize buckets\nThread.start: {\n  loop {\n    my @buckets = $bucket-store.buckets;\n    \n    # Pick 2 buckets, so that $to has not more than $from\n    my ($to, $from) = @buckets.keys.pick(2).sort({ @buckets[$_] });\n    \n    # Transfer half of the difference, rounded down\n    $bucket-store.transfer: ([-] @buckets[$from, $to]) div 2, :$from, :$to;\n  }\n}\n\n# Start a thread to distribute values among buckets\nThread.start: {\n  loop {\n    my @buckets = $bucket-store.buckets;\n    \n    # Pick 2 buckets\n    my ($to, $from) = @buckets.keys.pick(2);\n \n    # Transfer a random portion\n    $bucket-store.transfer: ^@buckets[$from] .pick, :$from, :$to;\n  }\n}\n\n# Loop to display buckets\nloop {\n  sleep 1;\n  \n  my @buckets = $bucket-store.buckets;\n  my $sum = @buckets.sum;\n  \n  say \"{@buckets.fmt: '%4d'}, total $sum\";\n  \n  if $sum != $initial-sum {\n    note \"ERROR: Total changed from $initial-sum to $sum\";\n    exit 1;\n  }\n}\n\n```\n\nOutput:\n\n```\n  23   52  831  195 1407  809  813   20, total 4150\n1172   83  336  306  751  468  615  419, total 4150\n 734  103 1086   88  313  136 1252  438, total 4150\n 512  323  544  165  200    3 2155  248, total 4150\n...\n\n```"}]}
{"messages": [{"role": "user", "content": "A number is an   *attractive number*   if the number of its prime factors (whether distinct or not) is also prime.\n\nExample\n\nThe number   **20**,   whose prime decomposition is   **2 × 2 × 5**,   is an   *attractive number*   because the number of its prime factors   (**3**)   is also prime.\n\nTask\n\nShow sequence items up to   **120**.\n\nReference\n:   * The OEIS entry:   A063989: Numbers with a prime number of prime divisors."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\nThis algorithm is concise but not really well suited to finding large quantities of consecutive attractive numbers. It works, but isn't especially speedy. More than a hundred thousand or so gets tedious. There are other, much faster (though more verbose) algorithms that *could* be used. This algorithm **is** well suited to finding **arbitrary** attractive numbers though.\n\n```\nuse Lingua::EN::Numbers;\nuse ntheory:from<Perl5> <factor is_prime>;\n\nsub display ($n,$m) { ($n..$m).grep: (~*).&factor.elems.&is_prime }\n\nsub count ($n,$m) { +($n..$m).grep: (~*).&factor.elems.&is_prime }\n\n# The Task\nput \"Attractive numbers from 1 to 120:\\n\" ~\ndisplay(1, 120)».fmt(\"%3d\").rotor(20, :partial).join: \"\\n\";\n\n# Robusto!\nfor 1, 1000,  1, 10000, 1, 100000, 2**73 + 1, 2**73 + 100 -> $a, $b {\n    put \"\\nCount of attractive numbers from {comma $a} to {comma $b}:\\n\" ~\n    comma count $a, $b\n}\n\n```\n\nOutput:\n\n```\nAttractive numbers from 1 to 120:\n  4   6   8   9  10  12  14  15  18  20  21  22  25  26  27  28  30  32  33  34\n 35  38  39  42  44  45  46  48  49  50  51  52  55  57  58  62  63  65  66  68\n 69  70  72  74  75  76  77  78  80  82  85  86  87  91  92  93  94  95  98  99\n102 105 106 108 110 111 112 114 115 116 117 118 119 120\n\nCount of attractive numbers from 1 to 1,000:\n636\n\nCount of attractive numbers from 1 to 10,000:\n6,396\n\nCount of attractive numbers from 1 to 100,000:\n63,255\n\nCount of attractive numbers from 9,444,732,965,739,290,427,393 to 9,444,732,965,739,290,427,492:\n58\n```"}]}
{"messages": [{"role": "user", "content": "**AudioAlarm** is a program that asks the user to enter a certain number, representing a number of seconds. After the user enters the number, the program will ask the user to enter the name of an MP3 audio file (without the .mp3 file extension). The program will then display a (usually blank) page. After the time (indicated by the number) is up, a sound (indicated by the MP3 file) will go off. Useful for timers and alarm clocks. The app must be installed in its own folder, preferrably with a name like *AudioAlarm*. To install a sound on the app, just copy the MP3 to the app folder you set up. Then, when the app asks you for the filename, you just type in the name without an extension."}, {"role": "assistant", "content": "requires mpg123 to be installed.\n\n```\n# 20221111 Raku programming solution\n\nloop (my $wait; $wait !~~ Int;) { $wait=prompt('enter seconds to wait: ') }\n\nloop (my $mp3='';!\"$mp3.mp3\".IO.e;) { $mp3=prompt('enter filename to play: ') }\n\nrun '/usr/bin/clear';\n\nsleep($wait);\n\nrun '/usr/bin/mpg123', \"$mp3.mp3\";\n\n```"}]}
{"messages": [{"role": "user", "content": "An audio frequency generator produces a continual audible monotone at a set frequency and level of volume.\nThere are controls to adjust the frequency and the volume up and down as desired.\nSome also have a selector to switch the waveform type between sine wave, square wave and triangular sawtooth.\n\nThe task is to emulate an audio frequency generator.\nIt is permissible to use an inbuilt computer speaker\nif the system does not have the facility to utilize dedicated sound hardware.\n\nThe solution should include:\n\n* A demonstration of how to check for availability of sound hardware on the system (on systems where this is possible)\n* A demonstration of how to produce a continual audible monotone (on sound hardware this would typically be a sine wave)\n* A method of adjusting the frequency and volume of the monotone. (one way would be to use left and right arrow keys to increase or decrease frequency, and up and down keys to increase or decrease the volume)\n* A method to silence or reset the sound hardware on exit.\n\nOptionally the solution can also include:\n\n* A demonstration of how to fall back to internal speaker, if sound hardware is not available\n* A facility to switch between sine wave, square wave and triangular sawtooth\n\nLanguages that provide no facilities for utilizing sound hardware of any kind should be omitted."}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20240130 Raku programming solution\n\nmy ($kindS, $kind, $freq, $vol, $dur) = 'sine', |(0 xx *);\n\nwhile $freq < 40 || $freq > 10000 {\n   print \"Enter frequency in Hz (40 to 10000) : \";\n   $freq = prompt().Int;\n}\n\nwhile $vol < 1 || $vol > 50 {\n   print \"Enter volume in dB (1 to 50) : \";\n   $vol = prompt().Int;\n}\n\nwhile $dur < 2 || $dur > 10 {\n   print \"Enter duration in seconds (2 to 10) : \";\n   $dur = prompt().Int;\n}\n\nwhile $kind < 1 || $kind > 3 {\n   print 'Enter kind (1 = Sine, 2 = Square, 3 = Sawtooth) : ';\n   given $kind = prompt().Int {\n      when $kind == 2 { $kindS = 'square'   }\n      when $kind == 3 { $kindS = 'sawtooth' }\n   }\n}\n\nmy @args = \"-n\", \"synth\", $dur, $kindS, $freq, \"vol\", $vol, \"dB\";\nrun 'play', @args, :out('/dev/null'), :err('/dev/null');\n\n```"}]}
{"messages": [{"role": "user", "content": "**Audio Overlap Loop** is a program that produces an \"echo chamber\" effect by playing an audio file several times in an overlapping loop. A repetition level determines the number of times that the file is looped. For the purpose of this task, write a program that takes a parameter for the number of repetitions and plays the file *loop.wav* in an overlapping loop according to the number of repetitions.\n\nOptionally take parameters for delay between repetitions, and decay (fractional volume reduction between consecutive repetitions)."}, {"role": "assistant", "content": "**Translation of**: Julia\n\n```\n# 20241230 Raku programming solution\n\nmy $soundfile = \"notes.wav\";\nmy $repetitions;\n\nif @*ARGS.elems < 1 {\n   say \"Usage: give number of repetitions in echo effect as argument to the program.\"\n} else {\n   given $*KERNEL.cpu-cores { $repetitions = @*ARGS[0] < $_ ?? @*ARGS[0] !! $_ }\n}\n\nfor 0.0, 0.1 ... (($repetitions - 1) * 0.1) -> $seconds {\n   sleep $seconds;\n   my $proc = Proc::Async.new('play', '--no-show-progress', $soundfile);\n   $proc.start\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nAn **autogram** is a sentence that describes itself in the sense of providing an inventory of its own characters. An essential feature is the use of full cardinal number names such as \"one\", \"two\", etc., in recording character counts.\n\nAutograms are also called 'self-enumerating' or 'self-documenting' sentences. Whilst they usually just count letters of the alphabet, they can also count punctuation symbols as well.\n\nExample\n\nIf punctuation is ignored, the following sentence is an autogram:\n\n```\nThis sentence employs two a's, two c's, two d's, twenty-eight e's, five f's, three g's, eight h's, eleven i's, three l's, two m's, thirteen n's, nine o's, two p's, five r's, twenty-five s's, twenty-three t's, six v's, ten w's, two x's, five y's, and one z.\n\n```\n\nTask\n\nWrite a routine in your language to check whether or not a given sentence is an autogram and use it to test the above example (Sentence 1.) and also the following sentences:\n\n2. This sentence employs two a's, two c's, two d's, twenty eight e's, five f's, three g's, eight h's, eleven i's, three l's, two m's, thirteen n's, nine o's, two p's, five r's, twenty five s's, twenty three t's, six v's, ten w's, two x's, five y's, and one z.\n\n3. Only the fool would take trouble to verify that his sentence was composed of ten a's, three b's, four c's, four d's, forty-six e's, sixteen f's, four g's, thirteen h's, fifteen i's, two k's, nine l's, four m's, twenty-five n's, twenty-four o's, five p's, sixteen r's, forty-one s's, thirty-seven t's, ten u's, eight v's, eight w's, four x's, eleven y's, twenty-seven commas, twenty-three apostrophes, seven hyphens and, last but not least, a single !\n\n4. This pangram contains four as, one b, two cs, one d, thirty es, six fs, five gs, seven hs, eleven is, one j, one k, two ls, two ms, eighteen ns, fifteen os, two ps, one q, five rs, twenty-seven ss, eighteen ts, two us, seven vs, eight ws, two xs, three ys, & one z.\n\n5. This sentence contains one hundred and ninety-seven letters: four a's, one b, three c's, five d's, thirty-four e's, seven f's, one g, six h's, twelve i's, three l's, twenty-six n's, ten o's, ten r's, twenty-nine s's, nineteen t's, six u's, seven v's, four w's, four x's, five y's, and one z.\n\n6. Thirteen e's, five f's, two g's, five h's, eight i's, two l's, three n's, six o's, six r's, twenty s's, twelve t's, three u's, four v's, six w's, four x's, two y's.\n\n7. Fifteen e's, seven f's, four g's, six h's, eight i's, four n's, five o's, six r's, eighteen s's, eight t's, four u's, three v's, two w's, three x's.\n\n8. Sixteen e's, five f's, three g's, six h's, nine i's, five n's, four o's, six r's, eighteen s's, eight t's, three u's, three v's, two w's, four z's.\n\nPunctuation should be ignored in all cases except for sentences number 3. and 7. For task 3 and 7, punctuation counts must be checked, and some ('comma', 'apostrophe', 'hyphen') punctuation may be represented in the autogram using the spelled out english names for the punctuation and the checker must respect the inconsistent use of apostrophes in the spellings of the counts (while still counting apostrophes accurately) and must accept 'single' as a synonym for 'one'.\n\nNote that the only difference between sentences 1. and 2. is that there are no hyphens in the latter.\n\nAssumptions\n\n* Ignore capitalization.\n\n* Never count spaces or full stops.\n\nIf it helps you may also make the following simplifying assumptions:\n\n* No sentence will be such that there are more than 99 instances of any countable character.\n\n* If punctuation is to be allowed for, only commas, hyphens, apostrophes and exclamation marks need be counted.\n\nReference\n\n* Wikipedia: Autogram\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "Slightly fragile, especially for non-letter character counts, but good enough for here.\n\nUsing Text::Wrap from the ecosystem. Install command: `zef install -v git://github.com/jkramer/p6-Text-Wrap.git`.\n\n```\nmy %nums = :0zero, :1one, :2two, :3three, :4four, :5five, :6six, :7seven, :8eight, :9nine, :10ten, :11eleven,\n    :12twelve, :13thirteen, :14fourteen, :15fifteen, :16sixteen, :17seventeen, :18eighteen, :19nineteen,\n    :20twenty, :30thirty, :40forty, :50fifty, :60sixty, :70seventy, :80eighty, :90ninety, :100hundred, :1single;\n\nsub whitespace  { $^a.subst(:g, /\\s|'.'/, '') }\nsub non-letters { $^a.subst(:g, /\\W/, '') }\n\nmy @tests =\n    (&non-letters, \"This sentence employs two a's, two c's, two d's, twenty-eight e's, five f's, three g's, eight h's, eleven i's, three l's, two m's, thirteen n's, nine o's, two p's, five r's, twenty-five s's, twenty-three t's, six v's, ten w's, two x's, five y's, and one z.\"),\n    (&non-letters, \"This sentence employs two a's, two c's, two d's, twenty eight e's, five f's, three g's, eight h's, eleven i's, three l's, two m's, thirteen n's, nine o's, two p's, five r's, twenty five s's, twenty three t's, six v's, ten w's, two x's, five y's, and one z.\"),\n    (&whitespace,  \"Only the fool would take trouble to verify that his sentence was composed of ten a's, three b's, four c's, four d's, forty-six e's, sixteen f's, four g's, thirteen h's, fifteen i's, two k's, nine l's, four m's, twenty-five n's, twenty-four o's, five p's, sixteen r's, forty-one s's, thirty-seven t's, ten u's, eight v's, eight w's, four x's, eleven y's, twenty-seven commas, twenty-three apostrophes, seven hyphens and, last but not least, a single !\"),\n    (&non-letters, \"This pangram contains four as, one b, two cs, one d, thirty es, six fs, five gs, seven hs, eleven is, one j, one k, two ls, two ms, eighteen ns, fifteen os, two ps, one q, five rs, twenty-seven ss, eighteen ts, two us, seven vs, eight ws, two xs, three ys, & one z.\"),\n    (&non-letters, \"This sentence contains one hundred and ninety-seven letters: four a's, one b, three c's, five d's, thirty-four e's, seven f's, one g, six h's, twelve i's, three l's, twenty-six n's, ten o's, ten r's, twenty-nine s's, nineteen t's, six u's, seven v's, four w's, four x's, five y's, and one z.\"),\n    (&non-letters, \"Thirteen e's, five f's, two g's, five h's, eight i's, two l's, three n's, six o's, six r's, twenty s's, twelve t's, three u's, four v's, six w's, four x's, two y's.\"),\n    (&whitespace,  \"Fifteen e's, seven f's, four g's, six h's, eight i's, four n's, five o's, six r's, eighteen s's, eight t's, four u's, three v's, two w's, three x's.\"),\n    (&non-letters, \"Sixteen e's, five f's, three g's, six h's, nine i's, five n's, four o's, six r's, eighteen s's, eight t's, three u's, three v's, two w's, four z's.\")\n;\n\nuse Text::Wrap;\n\nsay '=' x 100;\n\nfor @tests ->  (&filter, $text) {\n\n    # Original\n    say wrap-text :100width, $text;\n\n    say \"\\nFiltering out \" ~ &filter.name ~ ':';\n\n    # Semi-bogus and somewhat fragile names to numbers conversion.\n    my $str = $text.lc;\n    for %nums.kv -> $word, $number { $str ~~ s:g/ <|w> $word <|w> /$number/ }\n    $str ~~ s:g/ (\\d)<ws>['and'|'-']<ws>(\\d)  /$0 $1/;\n    $str ~~ s:g/ <|w>(\\d ** 2)<ws>(\\d ** 2) <|w> /{ $0 × 100 + $1}/;\n    $str ~~ s:g/ ( [\\d+<ws>]* \\d+ ) /{[+] $0.split: ' '}/;\n\n    # Build a hash of claimed characters.\n    my %claim = flat $str.lc.match(:g, /\\d+ <:ws> ['comma'|'apostrophe'|'hyphen'|.]/)».split(' ')»[1,0]».pairup;\n    for <comma , hyphen - apostrophe '> #`['] -> $word, $symbol { %claim{$symbol} = %claim{$word}:delete if %claim{$word} }\n    say \"\\nClaimed character counts:\\n\" ~ wrap-text :100width, %claim.sort( ~*.key ).map( { sprintf \"%s\\(%d)\", .key, .value } ).join: ' ';\n\n    # And of the actual character counts.\n    my %count = &filter($text).lc.comb.Bag.hash;\n    say \"\\nActual:\\n\" ~ wrap-text :100width, %count.sort( ~*.key ).map( { sprintf \"%s\\(%d)\", .key, .value } ).join: ' ';\n\n    # And compare them\n    say \"\\nAutogram? \" ~\n    quietly (so all %count.map: { .value == %claim{.key} }) && (so all %claim.map: { .value == %count{.key} });\n\n    say '=' x 100;\n}\n\n```\n\nOutput:\n\n```\n====================================================================================================\nThis sentence employs two a's, two c's, two d's, twenty-eight e's, five f's, three g's, eight h's,\neleven i's, three l's, two m's, thirteen n's, nine o's, two p's, five r's, twenty-five s's,\ntwenty-three t's, six v's, ten w's, two x's, five y's, and one z.\n\nFiltering out non-letters:\n\nClaimed character counts:\na(2) c(2) d(2) e(28) f(5) g(3) h(8) i(11) l(3) m(2) n(13) o(9) p(2) r(5) s(25) t(23) v(6) w(10) x(2)\ny(5) z(1)\n\nActual:\na(2) c(2) d(2) e(28) f(5) g(3) h(8) i(11) l(3) m(2) n(13) o(9) p(2) r(5) s(25) t(23) v(6) w(10) x(2)\ny(5) z(1)\n\nAutogram? True\n====================================================================================================\nThis sentence employs two a's, two c's, two d's, twenty eight e's, five f's, three g's, eight h's,\neleven i's, three l's, two m's, thirteen n's, nine o's, two p's, five r's, twenty five s's, twenty\nthree t's, six v's, ten w's, two x's, five y's, and one z.\n\nFiltering out non-letters:\n\nClaimed character counts:\na(2) c(2) d(2) e(28) f(5) g(3) h(8) i(11) l(3) m(2) n(13) o(9) p(2) r(5) s(25) t(23) v(6) w(10) x(2)\ny(5) z(1)\n\nActual:\na(2) c(2) d(2) e(28) f(5) g(3) h(8) i(11) l(3) m(2) n(13) o(9) p(2) r(5) s(25) t(23) v(6) w(10) x(2)\ny(5) z(1)\n\nAutogram? True\n====================================================================================================\nOnly the fool would take trouble to verify that his sentence was composed of ten a's, three b's,\nfour c's, four d's, forty-six e's, sixteen f's, four g's, thirteen h's, fifteen i's, two k's, nine\nl's, four m's, twenty-five n's, twenty-four o's, five p's, sixteen r's, forty-one s's, thirty-seven\nt's, ten u's, eight v's, eight w's, four x's, eleven y's, twenty-seven commas, twenty-three\napostrophes, seven hyphens and, last but not least, a single !\n\nFiltering out whitespace:\n\nClaimed character counts:\n!(1) '(23) ,(27) -(7) a(10) b(3) c(4) d(4) e(46) f(16) g(4) h(13) i(15) k(2) l(9) m(4) n(25) o(24)\np(5) r(16) s(41) t(37) u(10) v(8) w(8) x(4) y(11)\n\nActual:\n!(1) '(23) ,(27) -(7) a(10) b(3) c(4) d(4) e(46) f(16) g(4) h(13) i(15) k(2) l(9) m(4) n(25) o(24)\np(5) r(16) s(41) t(37) u(10) v(8) w(8) x(4) y(11)\n\nAutogram? True\n====================================================================================================\nThis pangram contains four as, one b, two cs, one d, thirty es, six fs, five gs, seven hs, eleven\nis, one j, one k, two ls, two ms, eighteen ns, fifteen os, two ps, one q, five rs, twenty-seven ss,\neighteen ts, two us, seven vs, eight ws, two xs, three ys, & one z.\n\nFiltering out non-letters:\n\nClaimed character counts:\na(4) b(1) c(2) d(1) e(30) f(6) g(5) h(7) i(11) j(1) k(1) l(2) m(2) n(18) o(15) p(2) q(1) r(5) s(27)\nt(18) u(2) v(7) w(8) x(2) y(3) z(1)\n\nActual:\na(4) b(1) c(2) d(1) e(30) f(6) g(5) h(7) i(11) j(1) k(1) l(2) m(2) n(18) o(15) p(2) q(1) r(5) s(27)\nt(18) u(2) v(7) w(8) x(2) y(3) z(1)\n\nAutogram? True\n====================================================================================================\nThis sentence contains one hundred and ninety-seven letters: four a's, one b, three c's, five d's,\nthirty-four e's, seven f's, one g, six h's, twelve i's, three l's, twenty-six n's, ten o's, ten r's,\ntwenty-nine s's, nineteen t's, six u's, seven v's, four w's, four x's, five y's, and one z.\n\nFiltering out non-letters:\n\nClaimed character counts:\na(4) b(1) c(3) d(5) e(34) f(7) g(1) h(6) i(12) l(3) n(26) o(10) r(10) s(29) t(19) u(6) v(7) w(4)\nx(4) y(5) z(1)\n\nActual:\na(4) b(1) c(3) d(5) e(34) f(7) g(1) h(6) i(12) l(3) n(26) o(10) r(10) s(29) t(19) u(6) v(7) w(4)\nx(4) y(5) z(1)\n\nAutogram? True\n====================================================================================================\nThirteen e's, five f's, two g's, five h's, eight i's, two l's, three n's, six o's, six r's, twenty\ns's, twelve t's, three u's, four v's, six w's, four x's, two y's.\n\nFiltering out non-letters:\n\nClaimed character counts:\ne(13) f(5) g(2) h(5) i(8) l(2) n(3) o(6) r(6) s(20) t(12) u(3) v(4) w(6) x(4) y(2)\n\nActual:\ne(13) f(5) g(2) h(5) i(8) l(2) n(3) o(6) r(6) s(20) t(12) u(3) v(4) w(6) x(4) y(2)\n\nAutogram? True\n====================================================================================================\nFifteen e's, seven f's, four g's, six h's, eight i's, four n's, five o's, six r's, eighteen s's,\neight t's, four u's, three v's, two w's, three x's.\n\nFiltering out whitespace:\n\nClaimed character counts:\ne(15) f(7) g(4) h(6) i(8) n(4) o(5) r(6) s(18) t(8) u(4) v(3) w(2) x(3)\n\nActual:\n'(14) ,(13) e(15) f(7) g(4) h(6) i(8) n(4) o(5) r(6) s(18) t(8) u(4) v(3) w(2) x(3)\n\nAutogram? False\n====================================================================================================\nSixteen e's, five f's, three g's, six h's, nine i's, five n's, four o's, six r's, eighteen s's,\neight t's, three u's, three v's, two w's, four z's.\n\nFiltering out non-letters:\n\nClaimed character counts:\ne(16) f(5) g(3) h(6) i(9) n(5) o(4) r(6) s(18) t(8) u(3) v(3) w(2) z(4)\n\nActual:\ne(16) f(5) g(3) h(6) i(9) n(5) o(4) r(6) s(18) t(8) u(3) v(3) w(2) x(3) z(1)\n\nAutogram? False\n====================================================================================================\n```"}]}
{"messages": [{"role": "user", "content": "Let `f` be a uniformly-randomly chosen mapping from the numbers 1..N to the numbers 1..N (note: not necessarily a permutation of 1..N; the mapping could produce a number in more than one way or not at all). At some point, the sequence `1, f(1), f(f(1))...` will contain a *repetition*, a number that occurring for the second time in the sequence.\n\nTask\n\nWrite a program or a script that estimates, for each `N`, the average length until the first such repetition.\n\nAlso calculate this expected length using an analytical formula, and optionally compare the simulated result with the theoretical one.\n\nThis problem comes from the end of Donald Knuth's Christmas tree lecture 2011.\n\nExample of expected output:\n\n```\n N    average    analytical    (error)\n===  =========  ============  =========\n  1     1.0000        1.0000  (  0.00%)\n  2     1.4992        1.5000  (  0.05%)\n  3     1.8784        1.8889  (  0.56%)\n  4     2.2316        2.2188  (  0.58%)\n  5     2.4982        2.5104  (  0.49%)\n  6     2.7897        2.7747  (  0.54%)\n  7     3.0153        3.0181  (  0.09%)\n  8     3.2429        3.2450  (  0.07%)\n  9     3.4536        3.4583  (  0.14%)\n 10     3.6649        3.6602  (  0.13%)\n 11     3.8091        3.8524  (  1.12%)\n 12     3.9986        4.0361  (  0.93%)\n 13     4.2074        4.2123  (  0.12%)\n 14     4.3711        4.3820  (  0.25%)\n 15     4.5275        4.5458  (  0.40%)\n 16     4.6755        4.7043  (  0.61%)\n 17     4.8877        4.8579  (  0.61%)\n 18     4.9951        5.0071  (  0.24%)\n 19     5.1312        5.1522  (  0.41%)\n 20     5.2699        5.2936  (  0.45%)\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nconstant MAX_N  = 20;\nconstant TRIALS = 100;\n \nfor 1 .. MAX_N -> $N {\n    my $empiric = TRIALS R/ [+] find-loop(random-mapping $N).elems xx TRIALS;\n    my $theoric = [+]\n        map -> $k { $N ** ($k + 1) R/ [×] flat $k**2, $N - $k + 1 .. $N }, 1 .. $N;\n \n    FIRST say \" N    empiric      theoric      (error)\";\n    FIRST say \"===  =========  ============  =========\";\n \n    printf \"%3d  %9.4f  %12.4f    (%4.2f%%)\\n\",\n            $N,  $empiric, $theoric, 100 × abs($theoric - $empiric) / $theoric;\n}\n \nsub random-mapping { hash .list Z=> .roll($_) given ^$^size }\nsub find-loop { 0, | %^mapping{*} ...^ { (%){$_}++ } }\n\n```\n\nExample:\n\n```\n N    empiric      theoric      (error)\n===  =========  ============  =========\n  1     1.0000        1.0000    (0.00%)\n  2     1.5600        1.5000    (4.00%)\n  3     1.7800        1.8889    (5.76%)\n  4     2.1800        2.2188    (1.75%)\n  5     2.6200        2.5104    (4.37%)\n  6     2.8300        2.7747    (1.99%)\n  7     3.1200        3.0181    (3.37%)\n  8     3.1400        3.2450    (3.24%)\n  9     3.4500        3.4583    (0.24%)\n 10     3.6700        3.6602    (0.27%)\n 11     3.8300        3.8524    (0.58%)\n 12     4.3600        4.0361    (8.03%)\n 13     3.9000        4.2123    (7.42%)\n 14     4.4900        4.3820    (2.46%)\n 15     4.9500        4.5458    (8.89%)\n 16     4.9800        4.7043    (5.86%)\n 17     4.9100        4.8579    (1.07%)\n 18     4.9700        5.0071    (0.74%)\n 19     5.1000        5.1522    (1.01%)\n 20     5.2300        5.2936    (1.20%)\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program to find the mean (arithmetic average) of a numeric vector.\n\nIn case of a zero-length input, since the mean of an empty set of numbers is ill-defined, the program may choose to behave in any way it deems appropriate, though if the programming language has an established convention for conveying math errors or undefined values, it's preferable to follow it.\n\nSee also\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| | Tasks for calculating statistical measures | | | --- | --- | |  | | |  |  |  |  |  | | --- | --- | --- | --- | --- | |  | | in one go | moving *(sliding window)* | moving *(cumulative)* | | Mean | Arithmetic | Statistics/Basic  Averages/Arithmetic mean  Averages/Pythagorean means | Averages/Simple moving average |  | | Geometric | Averages/Pythagorean means |  |  | | Harmonic | Averages/Pythagorean means |  |  | | Quadratic | Averages/Root mean square |  |  | | Circular | Averages/Mean angle  Averages/Mean time of day |  |  | | Median | | Averages/Median |  |  | | Mode | | Averages/Mode |  |  | | Standard deviation | | Statistics/Basic |  | Cumulative standard deviation | | | |\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.10-11\n\n```\nmulti mean([]){ Failure.new('mean on empty list is not defined') }; # Failure-objects are lazy exceptions\nmulti mean (@a) { ([+] @a) / @a }\n```"}]}
{"messages": [{"role": "user", "content": "When calculating the average or mean of an angle one has to take into account how angles wrap around so that any angle in degrees plus any integer multiple of 360 degrees is a measure of the same angle.\n\nIf one wanted an average direction of the wind over two readings where the first reading was of 350 degrees and the second was of 10 degrees then the average of the numbers is 180 degrees, whereas if you can note that 350 degrees is equivalent to -10 degrees and so you have two readings at 10 degrees either side of zero degrees leading to a more fitting mean angle of zero degrees.\n\nTo calculate the mean angle of several angles:\n\n1. Assume all angles are on the unit circle and convert them to complex numbers expressed in real and imaginary form.\n2. Compute the mean of the complex numbers.\n3. Convert the complex mean to polar coordinates whereupon the phase of the complex mean is the required angular mean.\n\n(Note that, since the mean is the sum divided by the number of numbers, and division by a positive real number does not affect the angle, you can also simply compute the sum for step 2.)\n\nYou can alternatively use this formula:\n\n:   Given the angles \n\n    α\n\n    1\n    ,\n    …\n    ,\n\n    α\n\n    n\n    {\\displaystyle {\\displaystyle \\alpha \\_{1},\\dots ,\\alpha \\_{n}}}\n     the mean is computed by\n\n:   :   α\n        ¯\n        =\n        atan2\n        ⁡\n\n        (\n\n        1\n        n\n        ⋅\n\n        ∑\n\n        j\n        =\n        1\n\n        n\n        sin\n        ⁡\n\n        α\n\n        j\n        ,\n\n\n        1\n        n\n        ⋅\n\n        ∑\n\n        j\n        =\n        1\n\n        n\n        cos\n        ⁡\n\n        α\n\n        j\n        )\n        {\\displaystyle {\\displaystyle {\\bar {\\alpha }}=\\operatorname {atan2} \\left({\\frac {1}{n}}\\cdot \\sum \\_{j=1}^{n}\\sin \\alpha \\_{j},{\\frac {1}{n}}\\cdot \\sum \\_{j=1}^{n}\\cos \\alpha \\_{j}\\right)}}\n\nTask\n\n1. write a function/method/subroutine/... that given a list of angles in degrees returns their mean angle.   \n    (You should use a built-in function if you have one that does this for degrees or radians).\n2. Use the function to compute the means of these lists of angles (in degrees):\n   * [350, 10]\n   * [90, 180, 270, 360]\n   * [10, 20, 30]\n3. Show your output here.\n\nSee also\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| | Tasks for calculating statistical measures | | | --- | --- | |  | | |  |  |  |  |  | | --- | --- | --- | --- | --- | |  | | in one go | moving *(sliding window)* | moving *(cumulative)* | | Mean | Arithmetic | Statistics/Basic  Averages/Arithmetic mean  Averages/Pythagorean means | Averages/Simple moving average |  | | Geometric | Averages/Pythagorean means |  |  | | Harmonic | Averages/Pythagorean means |  |  | | Quadratic | Averages/Root mean square |  |  | | Circular | Averages/Mean angle  Averages/Mean time of day |  |  | | Median | | Averages/Median |  |  | | Mode | | Averages/Mode |  |  | | Standard deviation | | Statistics/Basic |  | Cumulative standard deviation | | | |\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\nThis solution refuses to return an answer when the angles cancel out to a tiny magnitude.\n\n```\n# Of course, you can still use pi and 180.\nsub deg2rad { $^d * tau / 360 }\nsub rad2deg { $^r * 360 / tau }\n\nsub phase ($c)  {\n    my ($mag,$ang) = $c.polar;\n    return NaN if $mag < 1e-16;\n    $ang;\n}\n\nsub meanAngle { rad2deg phase [+] map { cis deg2rad $_ }, @^angles }\n\nsay meanAngle($_).fmt(\"%.2f\\tis the mean angle of \"), $_ for\n    [350, 10],\n    [90, 180, 270, 360],\n    [10, 20, 30];\n\n```\n\nOutput:\n\n```\n-0.00\tis the mean angle of 350 10\nNaN\tis the mean angle of 90 180 270 360\n20.00\tis the mean angle of 10 20 30\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nA particular activity of bats occurs at these times of the day:\n\n:   23:00:17, 23:40:20, 00:12:45, 00:17:19\n\nUsing the idea that there are twenty-four hours in a day,\nwhich is analogous to there being 360 degrees in a circle,\nmap times of day to and from angles;\nand using the ideas of Averages/Mean angle\ncompute and show the average time of the nocturnal activity\nto an accuracy of one second of time.\n\nSee also\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| | Tasks for calculating statistical measures | | | --- | --- | |  | | |  |  |  |  |  | | --- | --- | --- | --- | --- | |  | | in one go | moving *(sliding window)* | moving *(cumulative)* | | Mean | Arithmetic | Statistics/Basic  Averages/Arithmetic mean  Averages/Pythagorean means | Averages/Simple moving average |  | | Geometric | Averages/Pythagorean means |  |  | | Harmonic | Averages/Pythagorean means |  |  | | Quadratic | Averages/Root mean square |  |  | | Circular | Averages/Mean angle  Averages/Mean time of day |  |  | | Median | | Averages/Median |  |  | | Mode | | Averages/Mode |  |  | | Standard deviation | | Statistics/Basic |  | Cumulative standard deviation | | | |\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub tod2rad($_) { [+](.comb(/\\d+/) Z* 3600,60,1) * tau / 86400 }\n \nsub rad2tod ($r) {\n    my $x = $r * 86400 / tau;\n    (($x xx 3 Z/ 3600,60,1) Z% 24,60,60).fmt('%02d',':');\n}\n \nsub phase ($c) { $c.polar[1] }\n \nsub mean-time (@t) { rad2tod phase [+] map { cis tod2rad $_ }, @t }\n\nmy @times = [\"23:00:17\", \"23:40:20\", \"00:12:45\", \"00:17:19\"];\n \nsay \"{ mean-time(@times) } is the mean time of @times[]\";\n\n```\n\nOutput:\n\n```\n23:47:43 is the mean time of 23:00:17 23:40:20 00:12:45 00:17:19\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program to find the   median   value of a vector of floating-point numbers.\n\nThe program need not handle the case where the vector is empty, but *must* handle the case where there are an even number of elements.   In that case, return the average of the two middle values.\n\nThere are several approaches to this.   One is to sort the elements, and then pick the element(s) in the middle.\n\nSorting would take at least   O(*n* log*n*).   Another approach would be to build a priority queue from the elements, and then extract half of the elements to get to the middle element(s).   This would also take   O(*n* log*n*).   The best solution is to use the   selection algorithm   to find the median in   O(*n*)   time.\n\nSee also\n\nQuickselect\\_algorithm\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| | Tasks for calculating statistical measures | | | --- | --- | |  | | |  |  |  |  |  | | --- | --- | --- | --- | --- | |  | | in one go | moving *(sliding window)* | moving *(cumulative)* | | Mean | Arithmetic | Statistics/Basic  Averages/Arithmetic mean  Averages/Pythagorean means | Averages/Simple moving average |  | | Geometric | Averages/Pythagorean means |  |  | | Harmonic | Averages/Pythagorean means |  |  | | Quadratic | Averages/Root mean square |  |  | | Circular | Averages/Mean angle  Averages/Mean time of day |  |  | | Median | | Averages/Median |  |  | | Mode | | Averages/Mode |  |  | | Standard deviation | | Statistics/Basic |  | Cumulative standard deviation | | | |\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.08\n\n```\nsub median {\n  my @a = sort @_;\n  return (@a[(*-1) div 2] + @a[* div 2]) / 2;\n}\n\n```\n\nNotes:\n\n* The div operator does integer division. The / operator (rational number division) would work too, since the array subscript automatically coerces to Int, but using div is more explicit (i.e. clearer to readers) as well as faster, and thus recommended in cases like this.\n* The \\* inside the subscript stands for the array's length (see documentation).\n\nIn a slightly more compact way:\n\n```\nsub median { @_.sort[(*-1)/2, */2].sum / 2 }\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program to find the mode value of a collection.\n\nThe case where the collection is empty may be ignored. Care must be taken to handle the case where the mode is non-unique.\n\nIf it is not appropriate or possible to support a general collection, use a vector (array), if possible. If it is not appropriate or possible to support an unspecified value type, use integers.\n\nSee also\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| | Tasks for calculating statistical measures | | | --- | --- | |  | | |  |  |  |  |  | | --- | --- | --- | --- | --- | |  | | in one go | moving *(sliding window)* | moving *(cumulative)* | | Mean | Arithmetic | Statistics/Basic  Averages/Arithmetic mean  Averages/Pythagorean means | Averages/Simple moving average |  | | Geometric | Averages/Pythagorean means |  |  | | Harmonic | Averages/Pythagorean means |  |  | | Quadratic | Averages/Root mean square |  |  | | Circular | Averages/Mean angle  Averages/Mean time of day |  |  | | Median | | Averages/Median |  |  | | Mode | | Averages/Mode |  |  | | Standard deviation | | Statistics/Basic |  | Cumulative standard deviation | | | |\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03.1\n\n```\nsub mode (*@a) {\n    my %counts := @a.Bag;\n    my $max = %counts.values.max;\n    %counts.grep(*.value == $max).map(*.key);\n}\n\n# Testing with arrays:\nsay mode [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17];\nsay mode [1, 1, 2, 4, 4];\n\n```\n\nOutput:\n\n```\n6\n(4 1)\n\n```\n\nAlternatively, a version that uses a single method chain with no temporary variables: (Same output with same input)\n\n```\nsub mode (*@a) {\n    @a.Bag                # count elements\n      .classify(*.value)  # group elements with the same count\n      .max(*.key)         # get group with the highest count\n      .value.map(*.key);  # get elements in the group\n}\n\nsay mode [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17];\nsay mode [1, 1, 2, 4, 4];\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCompute all three of the Pythagorean means of the set of integers 1 through 10 (inclusive).\n\nShow that \n\nA\n(\n\nx\n\n1\n,\n…\n,\n\nx\n\nn\n)\n≥\nG\n(\n\nx\n\n1\n,\n…\n,\n\nx\n\nn\n)\n≥\nH\n(\n\nx\n\n1\n,\n…\n,\n\nx\n\nn\n)\n{\\displaystyle {\\displaystyle A(x\\_{1},\\ldots ,x\\_{n})\\geq G(x\\_{1},\\ldots ,x\\_{n})\\geq H(x\\_{1},\\ldots ,x\\_{n})}}\n for this set of positive integers.\n\n* The most common of the three means, the arithmetic mean, is the sum of the list divided by its length:\n\n:   A\n    (\n\n    x\n\n    1\n    ,\n    …\n    ,\n\n    x\n\n    n\n    )\n    =\n\n    x\n\n    1\n    +\n    ⋯\n    +\n\n    x\n\n    n\n    n\n    {\\displaystyle {\\displaystyle A(x\\_{1},\\ldots ,x\\_{n})={\\frac {x\\_{1}+\\cdots +x\\_{n}}{n}}}}\n\n* The geometric mean is the \n\n  n\n  {\\displaystyle {\\displaystyle n}}\n  th root of the product of the list:\n\n:   G\n    (\n\n    x\n\n    1\n    ,\n    …\n    ,\n\n    x\n\n    n\n    )\n    =\n\n    x\n\n    1\n    ⋯\n\n    x\n\n    n\n\n    n\n    {\\displaystyle {\\displaystyle G(x\\_{1},\\ldots ,x\\_{n})={\\sqrt[{n}]{x\\_{1}\\cdots x\\_{n}}}}}\n\n* The harmonic mean is \n\n  n\n  {\\displaystyle {\\displaystyle n}}\n   divided by the sum of the reciprocal of each item in the list:\n\n:   H\n    (\n\n    x\n\n    1\n    ,\n    …\n    ,\n\n    x\n\n    n\n    )\n    =\n\n\n    n\n\n    1\n\n    x\n\n    1\n    +\n    ⋯\n    +\n\n\n    1\n\n    x\n\n    n\n    {\\displaystyle {\\displaystyle H(x\\_{1},\\ldots ,x\\_{n})={\\frac {n}{{\\frac {1}{x\\_{1}}}+\\cdots +{\\frac {1}{x\\_{n}}}}}}}\n\nSee also\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| | Tasks for calculating statistical measures | | | --- | --- | |  | | |  |  |  |  |  | | --- | --- | --- | --- | --- | |  | | in one go | moving *(sliding window)* | moving *(cumulative)* | | Mean | Arithmetic | Statistics/Basic  Averages/Arithmetic mean  Averages/Pythagorean means | Averages/Simple moving average |  | | Geometric | Averages/Pythagorean means |  |  | | Harmonic | Averages/Pythagorean means |  |  | | Quadratic | Averages/Root mean square |  |  | | Circular | Averages/Mean angle  Averages/Mean time of day |  |  | | Median | | Averages/Median |  |  | | Mode | | Averages/Mode |  |  | | Standard deviation | | Statistics/Basic |  | Cumulative standard deviation | | | |\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub A { ([+] @_) / @_ }\nsub G { ([*] @_) ** (1 / @_) }\nsub H { @_ / [+] 1 X/ @_ }\n\nsay \"A(1,...,10) = \", A(1..10);\nsay \"G(1,...,10) = \", G(1..10);\nsay \"H(1,...,10) = \", H(1..10);\n\n```\n\nOutput:\n\n```\nA(1,...,10) = 5.5\nG(1,...,10) = 4.52872868811677\nH(1,...,10) = 3.41417152147406\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCompute the   Root mean square   of the numbers 1..10.\n\nThe   *root mean square*   is also known by its initials RMS (or rms), and as the **quadratic mean**.\n\nThe RMS is calculated as the mean of the squares of the numbers, square-rooted:\n\n:   :   :   x\n\n\n            r\n            m\n            s\n            =\n\n            x\n\n            1\n\n            2\n            +\n\n            x\n\n            2\n\n            2\n            +\n            ⋯\n            +\n\n            x\n\n            n\n\n            2\n            n\n            .\n            {\\displaystyle {\\displaystyle x\\_{\\mathrm {rms} }={\\sqrt {{{x\\_{1}}^{2}+{x\\_{2}}^{2}+\\cdots +{x\\_{n}}^{2}} \\over n}}.}}\n\nSee also\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| | Tasks for calculating statistical measures | | | --- | --- | |  | | |  |  |  |  |  | | --- | --- | --- | --- | --- | |  | | in one go | moving *(sliding window)* | moving *(cumulative)* | | Mean | Arithmetic | Statistics/Basic  Averages/Arithmetic mean  Averages/Pythagorean means | Averages/Simple moving average |  | | Geometric | Averages/Pythagorean means |  |  | | Harmonic | Averages/Pythagorean means |  |  | | Quadratic | Averages/Root mean square |  |  | | Circular | Averages/Mean angle  Averages/Mean time of day |  |  | | Median | | Averages/Median |  |  | | Mode | | Averages/Mode |  |  | | Standard deviation | | Statistics/Basic |  | Cumulative standard deviation | | | |\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub rms(*@nums) { sqrt ([+] @nums X** 2) / @nums }\n\nsay rms 1..10;\n\n```\n\nHere's a slightly more concise version, albeit arguably less readable:\n\n```\nsub rms { sqrt @_ R/ [+] @_».² }\n\n```"}]}
{"messages": [{"role": "user", "content": "Computing the simple moving average of a series of numbers.\n\nTask\n\nCreate a stateful function/class/instance that takes a period and returns a routine that takes a number as argument and returns a simple moving average of its arguments so far.\n\nDescription\n\nA simple moving average is a method for computing an average of a stream of numbers by only averaging the last   P   numbers from the stream,   where   P   is known as the period.\n\nIt can be implemented by calling an initialing routine with   P   as its argument,   I(P),   which should then return a routine that when called with individual, successive members of a stream of numbers, computes the mean of (up to), the last   P   of them, lets call this   SMA().\n\nThe word   *stateful*   in the task description refers to the need for   SMA()   to remember certain information between calls to it:\n\n* The period,   P\n* An ordered container of at least the last   P   numbers from each of its individual calls.\n\n*Stateful*   also means that successive calls to   I(),   the initializer,   should return separate routines that do   *not*   share saved state so they could be used on two independent streams of data.\n\nPseudo-code for an implementation of   SMA   is:\n\n```\nfunction SMA(number: N):\n    stateful integer: P\n    stateful list:    stream\n    number:           average\n\n    stream.append_last(N)\n    if stream.length() > P:\n        # Only average the last P elements of the stream\n        stream.delete_first()\n    if stream.length() == 0:\n        average = 0\n    else:    \n        average = sum( stream.values() ) / stream.length()\n    return average\n\n```\n\nSee also\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| | Tasks for calculating statistical measures | | | --- | --- | |  | | |  |  |  |  |  | | --- | --- | --- | --- | --- | |  | | in one go | moving *(sliding window)* | moving *(cumulative)* | | Mean | Arithmetic | Statistics/Basic  Averages/Arithmetic mean  Averages/Pythagorean means | Averages/Simple moving average |  | | Geometric | Averages/Pythagorean means |  |  | | Harmonic | Averages/Pythagorean means |  |  | | Quadratic | Averages/Root mean square |  |  | | Circular | Averages/Mean angle  Averages/Mean time of day |  |  | | Median | | Averages/Median |  |  | | Mode | | Averages/Mode |  |  | | Standard deviation | | Statistics/Basic |  | Cumulative standard deviation | | | |\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.08\n\n```\nsub sma-generator (Int $P where * > 0) {\n    sub ($x) {\n        state @a = 0 xx $P;\n        @a.push($x).shift;\n        @a.sum / $P;\n    }\n}\n\n# Usage:\nmy &sma = sma-generator 3;\n\nfor 1, 2, 3, 2, 7 {\n    printf \"append $_ --> sma = %.2f  (with period 3)\\n\", sma $_;\n}\n\n```\n\nOutput:\n\n```\nappend 1 --> sma = 0.33  (with period 3)\nappend 2 --> sma = 1.00  (with period 3)\nappend 3 --> sma = 2.00  (with period 3)\nappend 2 --> sma = 2.33  (with period 3)\nappend 7 --> sma = 4.00  (with period 3)\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at AVL tree. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn computer science, an **AVL tree** is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; at no time do they differ by more than one because rebalancing is done ensure this is the case. Lookup, insertion, and deletion all take O(log *n*) time in both the average and worst cases, where n is the number of nodes in the tree prior to the operation. Insertions and deletions may require the tree to be rebalanced by one or more tree rotations. Note the tree of nodes comprise a set, so duplicate node keys are not allowed.\n\nAVL trees are often compared with red-black trees because they support the same set of operations and because red-black trees also take O(log *n*) time for the basic operations. Because AVL trees are more rigidly balanced, they are faster than red-black trees for lookup-intensive applications. Similar to red-black trees, AVL trees are height-balanced, but in general not weight-balanced nor μ-balanced; that is, sibling nodes can have hugely differing numbers of descendants.\n\nTask\n\nImplement an AVL tree in the language of choice, and provide at least basic operations.\n\nRelated task\n\nRed\\_black\\_tree\\_sort"}, {"role": "assistant", "content": "(formerly Perl 6)\nThis code has been translated from the Java version on\n<https://rosettacode.org>. Consequently, it should have the same\nlicense: GNU Free Document License 1.2. In addition to the translated\ncode, other public methods have been added as shown by the asterisks\nin the following list of all public methods:\n\n* insert node\n* delete node\n* show all node keys\n* show all node balances\n* \\*delete nodes by a list of node keys\n* \\*find and return node objects by key\n* \\*attach data per node\n* \\*return list of all node keys\n* \\*return list of all node objects\n\nNote one of the interesting features of Raku is the ability to use characters\nlike the apostrophe (') and hyphen (-) in identifiers.\n\n```\nclass AVL-Tree {\n    has $.root is rw = 0;\n\n    class Node {\n        has $.key    is rw = '';\n        has $.parent is rw = 0;\n        has $.data   is rw = 0;\n        has $.left   is rw = 0;\n        has $.right  is rw = 0;\n        has Int $.balance is rw = 0;\n        has Int $.height  is rw = 0;\n    }\n\n    #=====================================================\n    # public methods\n    #=====================================================\n\n    #| returns a node object or 0 if not found\n    method find($key) {\n        return 0 if !$.root;\n        self!find: $key, $.root;\n    }\n\n    #| returns a list of tree keys\n    method keys() {\n        return () if !$.root;\n        my @list;\n        self!keys: $.root, @list;\n        @list;\n    }\n\n    #| returns a list of tree nodes\n    method nodes() {\n        return () if !$.root;\n        my @list;\n        self!nodes: $.root, @list;\n        @list;\n    }\n\n    #| insert a node key, optionally add data (the `parent` arg is for\n    #| internal use only)\n    method insert($key, :$data = 0, :$parent = 0,) {\n        return $.root = Node.new: :$key, :$parent, :$data if !$.root;\n        my $n = $.root;\n        while True {\n            return False if $n.key eq $key;\n            my $parent = $n;\n            my $goLeft = $n.key > $key;\n            $n = $goLeft ?? $n.left !! $n.right;\n            if !$n {\n                if $goLeft {\n                    $parent.left = Node.new: :$key, :$parent, :$data;\n                }\n                else {\n                    $parent.right = Node.new: :$key, :$parent, :$data;\n                }\n                self!rebalance: $parent;\n                last\n            }\n        }\n        True\n    }\n\n    #| delete one or more nodes by key\n    method delete(*@del-key) {\n        return if !$.root;\n        for @del-key -> $del-key {\n            my $child = $.root;\n            while $child {\n                my $node = $child;\n                $child = $del-key >= $node.key ?? $node.right !! $node.left;\n                if $del-key eq $node.key {\n                    self!delete: $node;\n                    next;\n                }\n            }\n        }\n    }\n\n    #| show a list of all nodes by key\n    method show-keys {\n        self!show-keys: $.root;\n        say()\n    }\n\n    #| show a list of all nodes' balances (not normally needed)\n    method show-balances {\n        self!show-balances: $.root;\n        say()\n    }\n\n    #=====================================================\n    # private methods\n    #=====================================================\n\n    method !delete($node) {\n        if !$node.left && !$node.right {\n            if !$node.parent {\n                $.root = 0;\n            }\n            else {\n                my $parent = $node.parent;\n                if $parent.left === $node {\n                    $parent.left = 0;\n                }\n                else {\n                    $parent.right = 0;\n                }\n                self!rebalance: $parent;\n            }\n            return\n        }\n\n        if $node.left {\n            my $child = $node.left;\n            while $child.right {\n                $child = $child.right;\n            }\n            $node.key = $child.key;\n            self!delete: $child;\n        }\n        else {\n            my $child = $node.right;\n            while $child.left {\n                $child = $child.left;\n            }\n            $node.key = $child.key;\n            self!delete: $child;\n        }\n    }\n\n    method !rebalance($n is copy) {\n        self!set-balance: $n;\n\n        if $n.balance == -2 {\n            if self!height($n.left.left) >= self!height($n.left.right) {\n                $n = self!rotate-right: $n;\n            }\n            else {\n                $n = self!rotate-left'right: $n;\n            }\n        }\n        elsif $n.balance == 2 {\n            if self!height($n.right.right) >= self!height($n.right.left) {\n                $n = self!rotate-left: $n;\n            }\n            else {\n                $n = self!rotate-right'left: $n;\n            }\n        }\n\n        if $n.parent {\n            self!rebalance: $n.parent;\n        }\n        else {\n            $.root = $n;\n        }\n    }\n\n    method !rotate-left($a) {\n\n        my $b     = $a.right;\n        $b.parent = $a.parent;\n\n        $a.right = $b.left;\n\n        if $a.right {\n            $a.right.parent = $a;\n        }\n\n        $b.left   = $a;\n        $a.parent = $b;\n\n        if $b.parent {\n            if $b.parent.right === $a {\n                $b.parent.right = $b;\n            }\n            else {\n                $b.parent.left = $b;\n            }\n        }\n\n        self!set-balance: $a, $b;\n        $b;\n    }\n\n    method !rotate-right($a) {\n\n        my $b = $a.left;\n        $b.parent = $a.parent;\n\n        $a.left = $b.right;\n\n        if $a.left {\n            $a.left.parent = $a;\n        }\n\n        $b.right  = $a;\n        $a.parent = $b;\n\n        if $b.parent {\n            if $b.parent.right === $a {\n                $b.parent.right = $b;\n            }\n            else {\n                $b.parent.left = $b;\n            }\n        }\n\n        self!set-balance: $a, $b;\n\n        $b;\n    }\n\n    method !rotate-left'right($n) {\n        $n.left = self!rotate-left: $n.left;\n        self!rotate-right: $n;\n    }\n\n    method !rotate-right'left($n) {\n        $n.right = self!rotate-right: $n.right;\n        self!rotate-left: $n;\n    }\n\n    method !height($n) {\n        $n ?? $n.height !! -1;\n    }\n\n    method !set-balance(*@n) {\n        for @n -> $n {\n            self!reheight: $n;\n            $n.balance = self!height($n.right) - self!height($n.left);\n        }\n    }\n\n    method !show-balances($n) {\n        if $n {\n            self!show-balances: $n.left;\n            printf \"%s \", $n.balance;\n            self!show-balances: $n.right;\n        }\n    }\n\n    method !reheight($node) {\n        if $node {\n            $node.height = 1 + max self!height($node.left), self!height($node.right);\n        }\n    }\n\n    method !show-keys($n) {\n        if $n {\n            self!show-keys: $n.left;\n            printf \"%s \", $n.key;\n            self!show-keys: $n.right;\n        }\n    }\n\n    method !nodes($n, @list) {\n        if $n {\n            self!nodes: $n.left, @list;\n            @list.push: $n if $n;\n            self!nodes: $n.right, @list;\n        }\n    }\n\n    method !keys($n, @list) {\n        if $n {\n            self!keys: $n.left, @list;\n            @list.push: $n.key if $n;\n            self!keys: $n.right, @list;\n        }\n    }\n\n    method !find($key, $n) {\n        if $n {\n            self!find: $key, $n.left;\n            return $n if $n.key eq $key;\n            self!find: $key, $n.right;\n        }\n    }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGenerate a B-spline curve with a list of 12 points and plot or save image.\n\nCoordinates of control points:\n\n```\n   start=171,171 \n   1 185,111, \n   2 202,109, \n   3 202,189 \n   4 328,160 \n   5 208,254 \n   6 241,330 \n   7 164,252 \n   8 69,278 \n   9 139,208 \n   10 72,148 \n   end=168,172\n\n```\n\nRules!!!!\n\nDo not use third party libraries or functions\n\nSee also\n\n* B-splines"}, {"role": "assistant", "content": "A minimal translation of this C program, by Bernhard R. Fischer.\n\n```\n# 20211112 Raku programming solution\n\nuse Cairo;\n\n# class point_t { has Num ($.x,$.y) is rw } # get by with two element lists\nclass line_t  { has ($.A,$.B) is rw }\n\nmy (\\WIDTH,  \\HEIGHT,  \\W_LINE,  \\CURVE_F,  \\DETACHED,          \\OUTPUT  ) = \n       400,      400,        2,      0.25,          0,  './b-spline.png' ;\n\nmy \\cnt = #`(Number of points) ( my \\pt = [\n   [171, 171], [185, 111], [202, 109], [202, 189], [328, 160], [208, 254],\n   [241, 330], [164, 252], [ 69, 278], [139, 208], [ 72, 148], [168, 172], ]\n).elems;\n\nsub angle(\\g) { atan2(g.B.[1] - g.A.[1], g.B.[0] - g.A.[0]) }\n\nsub control_points(\\g, \\l, @p1, @p2){\n\n#`[ This function calculates the control points. It takes two lines g and l as\n * arguments but it takes three lines into account for calculation. This is\n * line g (P0/P1), line h (P1/P2), and line l (P2/P3). The control points being\n * calculated are actually those for the middle line h, this is from P1 to P2.\n * Line g is the predecessor and line l the successor of line h.\n * @param g Pointer to first line (P0 to P1)\n * @param l Pointer to third line (P2 to P3)\n * @param p1 Pointer to memory of first control point. \n * @param p2 Pointer to memory of second control point. ]\n \n   my \\h = $ = line_t.new;\n\n   my \\lgt = sqrt([+]([ g.B.[0]-l.A.[0], g.B.[1]-l.A.[1] ]>>²));#length of P1 to P2\n\n   h.B = l.A.clone;  # end point of 1st tangent\n   # start point of tangent at same distance as end point along 'g'\n   h.A = g.B.[0] - lgt * cos(angle g) , g.B.[1] - lgt * sin(angle g);\n\n   my $a = angle h ; # angle of tangent\n   # 1st control point on tangent at distance 'lgt * CURVE_F'\n   @p1 = g.B.[0] + lgt * cos($a) * CURVE_F,  g.B.[1] + lgt * sin($a) * CURVE_F;\n\n   h.A = g.B.clone; # start point of 2nd tangent\n   # end point of tangent at same distance as start point along 'l'\n   h.B = l.A.[0] + lgt * cos(angle l) , l.A.[1] + lgt * sin(angle l);\n\n   $a = angle h; # angle of tangent\n   # 2nd control point on tangent at distance 'lgt * CURVE_F'\n   @p2 = l.A.[0] - lgt * cos($a) * CURVE_F,  l.A.[1] - lgt * sin($a) * CURVE_F;\n}\n\n\ngiven Cairo::Image.create(Cairo::FORMAT_ARGB32, WIDTH, HEIGHT) {\n   given Cairo::Context.new($_) {\n      my line_t ($g,$l);\n      my (@p1,@p2);\n\n      .line_width = W_LINE;\n      .move_to(pt[DETACHED - 1 + cnt].[0], pt[DETACHED - 1 + cnt].[1]);\n\n      for DETACHED..^cnt -> \\j { \n         $g = line_t.new: A=>pt[(j + cnt - 2) % cnt], B=>pt[(j + cnt - 1) % cnt];\n         $l = line_t.new: A=>pt[(j + cnt + 0) % cnt], B=>pt[(j + cnt + 1) % cnt];\n        \n         # Calculate controls points for points pt[j-1] and pt[j].\n         control_points($g, $l, @p1, @p2);\n         \n         .curve_to(@p1[0], @p1[1], @p2[0], @p2[1], pt[j].[0], pt[j].[1]);\n      }\n      .stroke;\n   };\n   .write_png(OUTPUT) and die # C return\n}\n\n```\n\nOutput: (Offsite image file)"}]}
{"messages": [{"role": "user", "content": "Charles Babbage\n\nCharles Babbage's analytical engine.\n\nCharles Babbage, looking ahead to the sorts of problems his Analytical Engine would be able to solve, gave this example:\n\nWhat is the smallest positive integer whose square ends in the digits 269,696?\n\n— Babbage, letter to Lord Bowden, 1837; see Hollingdale and Tootill, *Electronic Computers*, second edition, 1970, p. 125.\n\nHe thought the answer might be 99,736, whose square is 9,947,269,696; but he couldn't be certain.\n\nTask\n\nThe task is to find out if Babbage had the right answer — and to do so, as far as your language allows it, in code that Babbage himself would have been able to read and understand.\nAs Babbage evidently solved the task with pencil and paper, a similar efficient solution is preferred.\n\nFor these purposes, Charles Babbage may be taken to be an intelligent person, familiar with mathematics and with the idea of a computer; he has written the first drafts of simple computer programmes in tabular form. [Babbage Archive Series L].\n\nMotivation\n\nThe aim of the task is to write a program that is sufficiently clear and well-documented for such a person to be able to read it and be confident that it does indeed solve the specified problem."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis could certainly be written more concisely. Extra verbiage is included to make the process more clear.\n\n```\n# For all positive integers from 1 to Infinity\nfor 1 .. Inf -> $integer {\n    \n    # calculate the square of the integer\n    my $square = $integer²;\n    \n    # print the integer and square and exit if the square modulo 1000000 is equal to 269696\n    print \"{$integer}² equals $square\" and exit if $square mod 1000000 == 269696;\n}\n\n```\n\nOutput:\n\n```\n25264² equals 638269696\n```\n\nMore concisely (but clear enough to allow Mr. Babbage to understand what's going on?):\n\n```\n.say and exit if $_²  % 1e6 == 269696 for ^∞;\n\n```\n\nOutput:\n\n```\n25264\n```\n\nNotice that `exit` ends the process itself instead of ending just the loop, as `last` would. `exit` would arguably be easier to understand for Babbage though, so it may better fill the task requirement."}]}
{"messages": [{"role": "user", "content": "f\nThe **Babylonian spiral** is a sequence of points in the plane that are created so as to\ncontinuously minimally increase in vector length and minimally bend in vector direction,\nwhile always moving from point to point on strictly integral coordinates. Of the two criteria\nof length and angle, the length has priority.\n\nExamples\n\nP(1) and P(2) are defined to be at (x = 0, y = 0) and (x = 0, y = 1). The first vector is\nfrom P(1) to P(2). It is vertical and of length 1. Note that the square of that length is 1.\n\nNext in sequence is the vector from P(2) to P(3). This should be the smallest distance to a\npoint with integral (x, y) which is longer than the last vector (that is, 1). It should also bend clockwise\nmore than zero radians, but otherwise to the least degree.\n\nThe point chosen for P(3) that fits criteria is (x = 1, y = 2). Note the length of the vector\nfrom P(2) to P(3) is √2, which squared is 2. The lengths of the vectors thus determined can be given by a sorted\nlist of possible sums of two integer squares, including 0 as a square.\n\nTask\n\nFind and show the first 40 (x, y) coordinates of the Babylonian spiral.\n\nStretch task\n\nShow in your program how to calculate and plot the first 10000 points in the sequence. Your result\nshould look similar to the graph shown at the OEIS:\n\nSee also\n\n* OEIS:A256111 - squared distance to the origin of the n-th vertex on a Babylonian Spiral. * OEIS:A297346 - List of successive x-coordinates in the Babylonian Spiral. * OEIS:A297347 - List of successive y-coordinates in the Babylonian Spiral."}, {"role": "assistant", "content": "**Translation of**: Wren\n\n### Translation\n\n```\nsub babylonianSpiral (\\nsteps) {\n    my @squareCache = (0..nsteps).hyper.map: *²;\n    my @dxys = [0, 0], [0, 1];\n    my $dsq  = 1;\n\n    for ^(nsteps-2) {\n        my \\Θ = atan2 |@dxys[*-1][1,0];\n        my @candidates;\n\n        until @candidates.elems {\n            $dsq++;\n            for @squareCache.kv -> \\i, \\a {\n                last if a > $dsq/2;\n                for reverse 0 .. $dsq.sqrt.ceiling -> \\j {\n                    last if $dsq > (a + my \\b = @squareCache[j]);\n                    next if $dsq != a + b;\n                    @candidates.append: [i, j], [-i, j], [i, -j], [-i, -j],\n                                        [j, i], [-j, i], [j, -i], [-j, -i]\n                }\n            }\n        }\n        @dxys.push: @candidates.min: { ( Θ - atan2 |.[1,0] ) % τ };\n    }\n\n    [\\»+«] @dxys\n}\n\n# The task\nsay \"The first $_ Babylonian spiral points are:\\n\",\n(babylonianSpiral($_).map: { sprintf '(%3d,%4d)', @$_ }).batch(10).join(\"\\n\") given 40;\n\n# Stretch\nuse SVG;\n\n'babylonean-spiral-raku.svg'.IO.spurt: SVG.serialize(\n    svg => [\n        :width<100%>, :height<100%>,\n        :rect[:width<100%>, :height<100%>, :style<fill:white;>],\n        :polyline[ :points(flat babylonianSpiral(10000)),\n          :style(\"stroke:red; stroke-width:6; fill:white;\"),\n          :transform(\"scale (.05, -.05) translate (1000,-10000)\")\n        ],\n    ],\n);\n\n```\n\nOutput:\n\n```\nThe first 40 Babylonian spiral points are:\n(  0,   0) (  0,   1) (  1,   2) (  3,   2) (  5,   1) (  7,  -1) (  7,  -4) (  6,  -7) (  4, -10) (  0, -10)\n( -4,  -9) ( -7,  -6) ( -9,  -2) ( -9,   3) ( -8,   8) ( -6,  13) ( -2,  17) (  3,  20) (  9,  20) ( 15,  19)\n( 21,  17) ( 26,  13) ( 29,   7) ( 29,   0) ( 28,  -7) ( 24, -13) ( 17, -15) ( 10, -12) (  4,  -7) (  4,   1)\n(  5,   9) (  7,  17) ( 13,  23) ( 21,  26) ( 28,  21) ( 32,  13) ( 32,   4) ( 31,  -5) ( 29, -14) ( 24, -22)\n```\n\nStretch goal:\n\n(offsite SVG image - 96 Kb) - babylonean-spiral-raku.svg\n\n### Independent implementation\n\nExact same output; about one tenth the execution time.\n\n```\nmy @next = { :x(1), :y(1), :2hyp },;\n\nsub next-interval (Int $int) {\n     @next.append: (0..$int).map: { %( :x($int), :y($_), :hyp($int² + .²) ) };\n     @next = |@next.sort: *.<hyp>;\n}\n\nmy @spiral = [\\»+«] lazy gather {\n    my $interval = 1;\n    take [0,0];\n    take my @tail = 0,1;\n    loop {\n        my \\Θ = atan2 |@tail[1,0];\n        my @this = @next.shift;\n        @this.push: @next.shift while @next and @next[0]<hyp> == @this[0]<hyp>;\n        my @candidates = @this.map: {\n            my (\\i, \\j) = .<x y>;\n            next-interval(++$interval) if $interval == i;\n            |((i,j),(-i,j),(i,-j),(-i,-j),(j,i),(-j,i),(j,-i),(-j,-i))\n        }\n        take @tail = |@candidates.min: { ( Θ - atan2 |.[1,0] ) % τ };\n    }\n}\n\n# The task\nsay \"The first $_ Babylonian spiral points are:\\n\",\n@spiral[^$_].map({ sprintf '(%3d,%4d)', |$_ }).batch(10).join: \"\\n\" given 40;\n\n# Stretch\nuse SVG;\n\n'babylonean-spiral-raku.svg'.IO.spurt: SVG.serialize(\n    svg => [\n        :width<100%>, :height<100%>,\n        :rect[:width<100%>, :height<100%>, :style<fill:white;>],\n        :polyline[ :points(flat @spiral[^10000]),\n          :style(\"stroke:red; stroke-width:6; fill:white;\"),\n          :transform(\"scale (.05, -.05) translate (1000,-10000)\")\n        ],\n    ],\n);\n\n```\n\nSame output:"}]}
{"messages": [{"role": "user", "content": "Bacon's cipher is a method of steganography created by Francis Bacon.\nThis task is to implement a program for encryption and decryption of plaintext using the simple alphabet of the Baconian cipher or some other kind of representation of this alphabet (make anything signify anything).\n\nThe Baconian alphabet:\n\n```\na   AAAAA   g     AABBA   n    ABBAA   t     BAABA\nb   AAAAB   h     AABBB   o    ABBAB   u-v   BAABB\nc   AAABA   i-j   ABAAA   p    ABBBA   w     BABAA\nd   AAABB   k     ABAAB   q    ABBBB   x     BABAB\ne   AABAA   l     ABABA   r    BAAAA   y     BABBA\nf   AABAB   m     ABABB   s    BAAAB   z     BABBB\n\n```\n\n1. The Baconian alphabet may optionally be extended to encode all lower case characters individually and/or adding a few punctuation characters such as the space.\n2. It is impractical to use the original change in font for the steganography. For this task you must provide an example that uses a change in the case of successive alphabetical characters instead. Other examples for the language are encouraged to explore alternative steganographic means.\n3. Show an example plaintext message encoded and then decoded here on this page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### alternative steganography algorithm\n\nNot truly a Bacon Cipher as it doesn't encode using font variations. But fits with the spirit if not the exact definition.\n\n**Works with**: Rakudo version 2015-11-20\n\n```\nmy $secret = q:to/END/;\n    This task is to implement a program for encryption and decryption\n    of plaintext using the simple alphabet of the Baconian cipher or\n    some other kind of representation of this alphabet (make anything\n    signify anything). This example will work with anything in the\n    ASCII range... even code! $r%_-^&*(){}+~ #=`/\\';*1234567890\"'\n    END\n\nmy $text = q:to/END/;\n    Bah. It isn't really practical to use typeface changes to encode\n    information, it is too easy to tell that there is something going\n    on and will attract attention. Font changes with enough regularity\n    to encode mesages relatively efficiently would need to happen so\n    often it would be obvious that there was some kind of manipulation\n    going on. Steganographic encryption where it is obvious that there\n    has been some tampering with the carrier is not going to be very\n    effective. Not that any of these implementations would hold up to\n    serious scrutiny anyway. Anyway, here's a semi-bogus implementation\n    that hides information in white space. The message is hidden in this\n    paragraph of text. Yes, really. It requires a fairly modern file\n    viewer to display (not display?) the hidden message, but that isn't\n    too unlikely any more. It may be stretching things to call this a\n    Bacon cipher, but I think it falls within the spirit of the task,\n    if not the exact definition.\n    END\n#'\nmy @enc = \"\", \"​\";\nmy %dec = @enc.pairs.invert;\n\nsub encode ($c) { @enc[($c.ord).fmt(\"%07b\").comb].join('') }\n\nsub hide ($msg is copy, $text) { \n    $msg ~= @enc[0] x (0 - ($msg.chars % 8)).abs;\n    my $head = $text.substr(0,$msg.chars div 8);\n    my $tail = $text.substr($msg.chars div 8, *-1);\n    ($head.comb «~» $msg.comb(/. ** 8/)).join('') ~ $tail;\n}\n\nsub reveal ($steg) {\n    join '', map { :2(%dec{$_.comb}.join('')).chr }, \n    $steg.subst( /\\w | <punct> | \" \" | \"\\n\" /, '', :g).comb(/. ** 7/);\n}\n\nmy $hidden = join '', map  { .&encode }, $secret.comb;\n\nmy $steganography = hide $hidden, $text;\n\nsay \"Steganograpic message hidden in text:\";\nsay $steganography;\n\nsay '*' x 70;\n\nsay \"Hidden message revealed:\";\nsay reveal $steganography;\n\n```\n\nOutput:\n\n```\nSteganograpic message hidden in text:\nB​​​​a​​​​h​​​​​.​​​ ​​​​I​​t​​​​​​ ​​​​​i​​​s​​​​​n​​​'​​​​t​​​​​ ​​r​​​​​e​​​​​​a​​​l​​​​l​​​​​​y​​​​ ​​​​​​p​​​​r​​​a​​c​​​t​​​i​​​​​​c​​​​​​a​​​​​l​​​​ ​​​​t​​o​​​​​​ ​​​​​​u​s​​​​​e​​​​​​ ​​​​​t​​​​​y​​​​p​​​​e​​​​f​​​​​​​a​​​​​c​​e​​​​ ​​​​​c​h​​​a​​​​​n​​​​​g​​​​​e​​​​​s​​​​ ​​​t​​​​​​​o​​​​​ ​​​​e​​​​​​n​​​c​​​o​​​​d​​​e​​​​​\ni​​​​n​​​​​​f​​​​o​r​​​​​m​​​​​​a​​​​​t​​​​​i​​​​o​​​​n​​​,​​​​ ​​i​​​​​​t​​​​ ​​​​​​i​​​​s​​​ ​​t​​​​o​​​​​o​​​ ​​​e​​​a​​​​s​​​​​y​​ ​​​​​​​t​​​o​​​ ​​​​t​​​e​​l​​​l​​​​ ​​​​t​​​​​​​h​​​​​a​​​t​​​​​​ ​​t​​​​​h​​​​​e​​​r​​​e​​​​​ ​i​​​​​​​s​​​ ​​​​​s​​​​​o​​​​​​​m​​​​e​​t​​​​​​​h​​​​​i​​​n​​​​​g​​ ​​​​g​​​​​o​​​​​​i​​​n​​g​​​​​​\no​​​​n​​​​ ​​​​a​​​​​n​​​​​d​​​​ ​​​​​​w​​​​​i​​​l​​​​​l​​​​​ ​​​​​​a​​​​t​​​​t​​​​​​r​a​​​​​c​​​​t​​​​​ ​​​a​​t​​​​​t​​​e​​​​n​​​​t​​​i​​​​​o​​n​​.​​​​​ ​​​​F​​​​​​o​​​n​​t​​​​​ ​​​​​c​​​​​h​​​​a​​​​​n​​​​​g​​​​e​​​​s​​​​​ ​​​​​​w​​​​​​i​​​​​t​​​​​h​​​ ​​e​​​​​​n​​​​​o​​​​​u​​​​g​​​​h​​​​​ ​​​​​r​​​​​e​g​​​​u​​​​l​​​​​a​​​r​​​i​​​​​t​​​y​​​​​​\nt​​​​o​​​ ​​​​e​​​​​n​​​​​c​​​​o​​​d​​​​​​e​​​​​​​ ​​​​m​​​e​​​​​​s​​​​​a​​​​​g​​e​​s​​​​​ ​​​​​r​​​​​e​​​​l​​​​​a​​​​​t​​​​i​​​v​​​​​​e​l​​​​​y​​​​ ​​e​​​f​​​f​​​​i​​​​c​​​i​​​e​​​​n​​​​t​​​​​l​​​​​y​​​​​ ​​​​w​​​​​o​​u​​​​​l​​​​​d​​​​​​ ​n​​​​​e​​​​​​​e​​​d​​​ ​​t​​o​​​​ ​​​​h​​​​​​a​​​​​p​​​​p​​​​e​​​n​​​ ​​​​​​​s​​​​​​o​​​​​​\no​f​​​​​​t​​​e​​​​​​n​​​​ ​​​​​i​​​​​t​​​ ​​​​w​​​​o​​​u​​​​​l​​​​​d​​​​​​ ​​​b​​​e​​ ​​​​o​​bvious that there was some kind of manipulation\ngoing on. Steganographic encryption where it is obvious that there\nhas been some tampering with the carrier is not going to be very\neffective. Not that any of these implementations would hold up to\nserious scrutiny anyway. Anyway, here's a semi-bogus implementation\nthat hides information in white space. The message is hidden in this\nparagraph of text. Yes, really. It requires a fairly modern file\nviewer to display (not display?) the hidden message, but that isn't\ntoo unlikely any more. It may be stretching things to call this a\nBacon cipher, but I think it falls within the spirit of the task,\nif not the exact definition.\n**********************************************************************\nHidden message revealed:\nThis task is to implement a program for encryption and decryption\nof plaintext using the simple alphabet of the Baconian cipher or\nsome other kind of representation of this alphabet (make anything\nsignify anything). This example will work with anything in the\nASCII range... even code! $r%_-^&*(){}+~ #=`/\\';*1234567890\"'\n```\n\n### Bacon cipher solution\n\n```\nmy @abc = 'a' .. 'z';\nmy @symb = ' ', |@abc;  # modified Baconian charset - space and full alphabet\n# TODO original one with I=J U=V, nice for Latin\n\nmy %bacon = @symb Z=> (^@symb).map(*.base(2).fmt(\"%05s\"));\nmy %nocab = %bacon.antipairs;\n\nsub bacon ($s, $msg) {\n  my @raw = $s.lc.comb;\n  my @txt := @raw[ (^@raw).grep({@raw[$_] (elem) @abc}) ];\n  for $msg.lc.comb Z @txt.batch(5) -> ($c-msg, @a) {\n    for @a.kv -> $i, $c-str {\n      (my $x := @a[$i]) = $x.uc if %bacon{$c-msg}.comb[$i].Int.Bool;\n  } }\n  @raw.join;\n}\n\nsub unbacon ($s) {\n  my $chunks = ($s ~~ m:g/\\w+/)>>.Str.join.comb(/.**5/);\n  $chunks.map(*.comb.map({.uc eq $_})».Int».Str.join).map({%nocab{$_}}).join;\n}\n\nmy $msg = \"Omnes homines dignitate et iure liberi et pares nascuntur\";\n\nmy $str = <Lorem ipsum dolor sit amet, consectetur adipiscing elit,\nsed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\nUt enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi\nut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit\nin voluptate velit esse cillum dolore eu fugiat nulla pariatur.\nExcepteur sint occaecat cupidatat non proident, sunt in culpa\nqui officia deserunt mollit anim id est laborum.>;\n\nmy $baconed = bacon $str, $msg;\n$baconed = $baconed.?naive-word-wrapper || $baconed;\n# FIXME ^^^ makes dbl space after .\nsay \"text:\\n$baconed\\n\";\nmy $unbaconed = unbacon($baconed).trim.uc;\nsay \"hidden message:\\n$unbaconed\";\n\n```\n\nOutput:\n\n```\ntext:\nlOREM iPSuM dOLOr siT aMEt, cONsectetUr adiPISCiNG eLiT, seD dO EIusmOd\nTEmpOR incididUnt uT laBorE ET dOLOre MagNA aLiqua.  ut ENiM ad miNiM\nveniam, qUiS NoStrud exerCitATiOn ULlaMco lAbOris nisI Ut alIquIp ex Ea\ncoMmODo cOnsEquAt.  duis auTe IRuRe dolor iN reprehenDEriT in vOlUPtaTE\nvelit eSSE cilluM DolORe eu FUGiAt NuLLA pArIatUr.  ExCEptEur sint\noccaecat cupidatat non proident, sunt in culpa qui officia deserunt\nmollit anim id est laborum.\n\nhidden message:\nOMNES HOMINES DIGNITATE ET IURE LIBERI ET PARES NASCUNTUR\n```"}]}
{"messages": [{"role": "user", "content": "**Task**:\n\n* Generate a string with   **N**   opening brackets   **[**   and with   **N**   closing brackets   **]**,   in some arbitrary order.\n* Determine whether the generated string is *balanced*; that is, whether it consists entirely of pairs of opening/closing brackets (in that order), none of which mis-nest.\n\nExamples\n\n```\n   (empty)      OK\n   []           OK   \n   [][]         OK   \n   [[][]]       OK \n   ][         NOT OK\n   ][][       NOT OK\n   []][[]     NOT OK\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\nThere's More Than One Way To Do It.\n\n### Depth counter\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub balanced($s) {\n    my $l = 0;\n    for $s.comb {\n        when \"]\" {\n            --$l;\n            return False if $l < 0;\n        }\n        when \"[\" {\n            ++$l;\n        }\n    }\n    return $l == 0;\n}\n\nmy $n = prompt \"Number of brackets\";\nmy $s = (<[ ]> xx $n).flat.pick(*).join;\nsay \"$s {balanced($s) ?? \"is\" !! \"is not\"} well-balanced\"\n```\n\n### FP oriented\n\nHere's a more idiomatic solution using a hyperoperator to compare all the characters to a backslash (which is between the brackets in ASCII), a triangle reduction to return the running sum, a given to make that list the topic, and then a topicalized junction and a topicalized subscript to test the criteria for balance.\n\n```\nsub balanced($s) {\n    .none < 0 and .[*-1] == 0\n        given ([\\+] '\\\\' «leg« $s.comb).cache;\n}\n\nmy $n = prompt \"Number of bracket pairs: \";\nmy $s = <[ ]>.roll($n*2).join;\nsay \"$s { balanced($s) ?? \"is\" !! \"is not\" } well-balanced\"\n```\n\n### String munging\n\nOf course, a Perl 5 programmer might just remove as many inner balanced pairs as possible and then see what's left.\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub balanced($_ is copy) {\n    Nil while s:g/'[]'//;\n    $_ eq '';\n}\n\nmy $n = prompt \"Number of bracket pairs: \";\nmy $s = <[ ]>.roll($n*2).join;\nsay \"$s is\", ' not' x not balanced($s), \" well-balanced\";\n```\n\n### Parsing with a grammar\n\n**Works with**: Rakudo version 2015.12\n\n```\ngrammar BalBrack { token TOP { '[' <TOP>* ']' } }\n\nmy $n = prompt \"Number of bracket pairs: \";\nmy $s = ('[' xx $n, ']' xx $n).flat.pick(*).join;\nsay \"$s { BalBrack.parse($s) ?? \"is\" !! \"is not\" } well-balanced\";\n```"}]}
{"messages": [{"role": "user", "content": "Balanced ternary is a way of representing numbers. Unlike the prevailing binary representation, a balanced ternary integer is in base 3, and each digit can have the values 1, 0, or −1.\n\nExamples\n\nDecimal 11 = 32 + 31 − 30, thus it can be written as \"++−\"\n\nDecimal 6 = 32 − 31 + 0 × 30, thus it can be written as \"+−0\"\n\nTask\n\nImplement balanced ternary representation of integers with the following:\n\n1. Support arbitrarily large integers, both positive and negative;\n2. Provide ways to convert to and from text strings, using digits '+', '−' and '0' (unless you are already using strings to represent balanced ternary; but see requirement 5).\n3. Provide ways to convert to and from native integer type (unless, improbably, your platform's native integer type *is* balanced ternary). If your native integers can't support arbitrary length, overflows during conversion must be indicated.\n4. Provide ways to perform addition, negation and multiplication directly on balanced ternary integers; do *not* convert to native integers first.\n5. Make your implementation efficient, with a reasonable definition of \"efficient\" (and with a reasonable definition of \"reasonable\").\n\n**Test case** With balanced ternaries *a* from string \"+−0++0+\", *b* from native integer −436, *c* \"+−++−\":\n\n* write out *a*, *b* and *c* in decimal notation;\n* calculate *a* × (*b* − *c*), write out the result in both ternary and decimal notations.\n\n**Note:** The pages generalised floating point addition and generalised floating point multiplication have code implementing arbitrary precision floating point balanced ternary."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2017.01\n\n```\nclass BT {\n    has @.coeff;\n\n    my %co2bt = '-1' => '-', '0' => '0', '1' => '+';\n    my %bt2co = %co2bt.invert;\n\n    multi method new (Str $s) {\n\tself.bless(coeff => %bt2co{$s.flip.comb});\n    }\n    multi method new (Int $i where $i >= 0) {\n\tself.bless(coeff => carry $i.base(3).comb.reverse);\n    }\n    multi method new (Int $i where $i < 0) {\n\tself.new(-$i).neg;\n    }\n\n    method Str () { %co2bt{@!coeff}.join.flip }\n    method Int () { [+] @!coeff Z* (1,3,9...*) }\n\n    multi method neg () {\n\tself.new: coeff => carry self.coeff X* -1;\n    }\n}\n\nsub carry (*@digits is copy) {\n    loop (my $i = 0; $i < @digits; $i++) {\n\twhile @digits[$i] < -1 { @digits[$i] += 3; @digits[$i+1]--; }\n\twhile @digits[$i] > 1  { @digits[$i] -= 3; @digits[$i+1]++; }\n    }\n    pop @digits while @digits and not @digits[*-1];\n    @digits;\n}\n\nmulti prefix:<-> (BT $x) { $x.neg }\n\nmulti infix:<+> (BT $x, BT $y) {\n    my ($b,$a) = sort +*.coeff, ($x, $y);\n    BT.new: coeff => carry ($a.coeff Z+ |$b.coeff, |(0 xx $a.coeff - $b.coeff));\n}\n\nmulti infix:<-> (BT $x, BT $y) { $x + $y.neg }\n\nmulti infix:<*> (BT $x, BT $y) {\n    my @x = $x.coeff;\n    my @y = $y.coeff;\n    my @z = 0 xx @x+@y-1;\n    my @safe;\n    for @x -> $xd {\n\t@z = @z Z+ |(@y X* $xd), |(0 xx @z-@y);\n\t@safe.push: @z.shift;\n    }\n    BT.new: coeff => carry @safe, @z;\n}\n\nmy $a = BT.new: \"+-0++0+\";\nmy $b = BT.new: -436;\nmy $c = BT.new: \"+-++-\";\nmy $x = $a * ( $b - $c );\n\nsay 'a == ', $a.Int;\nsay 'b == ', $b.Int;\nsay 'c == ', $c.Int;\nsay \"a × (b − c) == \", ~$x, ' == ', $x.Int;\n\n```\n\nOutput:\n\n```\na == 523\nb == -436\nc == 65\na × (b − c) == ----0+--0++0 == -262023\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Banker's algorithm. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThe **Banker's algorithm** is a resource allocation and deadlock avoidance algorithm developed by Edsger Dijkstra that tests for safety by simulating the allocation of predetermined maximum possible amounts of all resources, and then makes a \"s-state\" check to test for possible deadlock conditions for all other pending activities, before deciding whether allocation should be allowed to continue.\n\nExample input\n\nAssuming that the system distinguishes between four types of resources, (A, B, C and D), the following is an example of how those resources could be distributed.\n\n*Note that this example shows the system at an instant before a new request for resources arrives.   Also, the types and number of resources are abstracted.   Real systems, for example, would deal with much larger quantities of each resource.*\n\n```\nTotal resources in system:\nA B C D\n6 5 7 6\n\n```\n\n```\nAvailable system resources are:\nA B C D\n3 1 1 2\n\n```\n\n```\nProcesses (currently allocated resources):\n   A B C D\nP1 1 2 2 1\nP2 1 0 3 3\nP3 1 2 1 0\n\n```\n\n```\nProcesses (maximum resources):\n   A B C D\nP1 3 3 2 2\nP2 1 2 3 4\nP3 1 3 5 0\n\n```\n\n```\nNeed= maximum resources - currently allocated resources\nProcesses (need resources):\n   A B C D\nP1 2 1 0 1\nP2 0 2 0 1\nP3 0 1 4 0\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\nBased on the Python3 solution by Shubham Singh found\nhere\n\n```\nmy @avail = <3 1 1 2>;                        # Available instances of resource\nmy @maxm  = <3 3 2 2>, <1 2 3 4>, <1 3 5 0>;  # Maximum resources that can be allocated to processes\nmy @allot = <1 2 2 1>, <1 0 3 3>, <1 2 1 0>;  # Resources allocated to processes\n\n# Function to find the system is in safe state or not\nsub isSafe(\\work is copy, \\maxm, \\allot) {\n    my \\P          = allot.elems;     # Number of processes\n    my \\Pool       = (^P).SetHash;    # Process pool\n    my \\R          = work.elems;      # Number of resources \n    my \\need       = maxm »-« allot;  # the need matrix\n    my @safe-sequence;\n\n    # While all processes are not finished or system is not in safe state\n    my $count = 0;\n    while $count < P {\n        my $found = False;\n        for Pool.keys -> \\p {           \n            if all need[p] »≤« work {    # now process can be finished\n                work »+=« allot[p;^R];   # Free the resources\n                say 'available resources: ' ~ work;\n                @safe-sequence.push: p;  # Add this process to safe sequence\n                Pool{p}--;               # Remove this process from Pool\n                $count += 1;\n                $found = True\n            }\n        }\n        # If we could not find a next process in safe sequence\n        return False, \"System is not in safe state.\" unless $found;\n    }\n    # If system is in safe state then safe sequence will be as below\n    return True, \"Safe sequence is: \" ~ @safe-sequence\n}\n\n# Check if system is in a safe state\nmy ($safe-state,$status-message) = isSafe @avail, @maxm, @allot;\nsay \"Safe state? $safe-state\";\nsay \"Message:    $status-message\";\n\n```\n\nOutput:\n\n```\navailable resources: 4 3 3 3\navailable resources: 5 3 6 6\navailable resources: 6 5 7 6\nSafe state? True\nMessage:    Safe sequence is: 0 1 2\n```"}]}
{"messages": [{"role": "user", "content": "A Barnsley fern is a fractal named after British mathematician Michael Barnsley and can be created using an iterated function system (IFS).\n\nTask\n\nCreate this fractal fern, using the following transformations:\n\n* ƒ1   (chosen 1% of the time)\n\n```\n        xn + 1 = 0\n        yn + 1 = 0.16 yn\n\n```\n\n* ƒ2   (chosen 85% of the time)\n\n```\n        xn + 1 = 0.85 xn + 0.04 yn\n        yn + 1 = −0.04 xn + 0.85 yn + 1.6\n\n```\n\n* ƒ3   (chosen 7% of the time)\n\n```\n        xn + 1 = 0.2 xn − 0.26 yn\n        yn + 1 = 0.23 xn + 0.22 yn + 1.6\n\n```\n\n* ƒ4   (chosen 7% of the time)\n\n```\n        xn + 1 = −0.15 xn + 0.28 yn\n        yn + 1 = 0.26 xn + 0.24 yn + 0.44.\n\n```\n\nStarting position: x = 0, y = 0"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.03\n\n**Translation of**: Perl\n\n```\nuse Image::PNG::Portable;\n\nmy ($w, $h) = (640, 640);\n\nmy $png = Image::PNG::Portable.new: :width($w), :height($h);\n\nmy ($x, $y) = (0, 0);\n\nfor ^2e5 {\n    my $r = 100.rand;\n    ($x, $y) = do given $r {\n        when  $r <=  1 { (                     0,              0.16 * $y       ) }\n        when  $r <=  8 { ( 0.20 * $x - 0.26 * $y,  0.23 * $x + 0.22 * $y + 1.60) }\n        when  $r <= 15 { (-0.15 * $x + 0.28 * $y,  0.26 * $x + 0.24 * $y + 0.44) }\n        default        { ( 0.85 * $x + 0.04 * $y, -0.04 * $x + 0.85 * $y + 1.60) }\n    };\n    $png.set(($w / 2 + $x * 60).Int, ($h - $y * 60).Int, 0, 255, 0);\n}\n\n$png.write: 'Barnsley-fern-perl6.png';\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow in decimal notation all positive integers (less than **501**) which, when converted to hexadecimal notation, cannot be written without using at least one non-decimal digit ('a' to 'f')."}, {"role": "assistant", "content": "Yet another poorly specced, poorly named, trivial task.\n\nHow many integers in base 16 cannot be written without using a hexadecimal digit? All of them. Or none of them.\n\nBase 16 is not hexadecimal. Hexadecimal is *an implementation* of base 16.\n\n```\nuse Base::Any;\nset-digits <⑩ ⑪ ⑫ ⑬ ⑭ ⑮ ⑯ ⑰ ⑱ ⑲ ⑳ ㉑ ㉒ ㉓ ㉔ ㉕>;\nsay (7**35).&to-base(16);\n\n# ⑭㉒⑱⑩⑰⑰⑳⑮⑱⑳⑩⑳⑱㉒㉑⑰㉒⑫⑭⑲⑯⑩㉔⑮⑰\n\n```\n\nHow many of those glyphs are decimal digits? And yet it **is** in base 16, albeit with non-standard digit glyphs. So they **all** can be written without using a hexadecimal digit.\n\nBut wait a minute; is 2 a hexadecimal digit? Why yes, yes it is. So *none* of them can be written in hexadecimal without using a hexadecimal digit.\n\nBah. Show which when written in base 16, contain a digit glyph with a value greater than 9:\n\n```\nput display :20cols, :fmt('%3d'), (^501).grep( { so any |.map: { .polymod(16 xx *) »>» 9 } } );\n\nsub display ($list, :$cols = 10, :$fmt = '%6d', :$title = \"{+$list} matching:\\n\" )   {\n    cache $list;\n    $title ~ $list.batch($cols)».fmt($fmt).join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\n301 matching:\n 10  11  12  13  14  15  26  27  28  29  30  31  42  43  44  45  46  47  58  59\n 60  61  62  63  74  75  76  77  78  79  90  91  92  93  94  95 106 107 108 109\n110 111 122 123 124 125 126 127 138 139 140 141 142 143 154 155 156 157 158 159\n160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179\n180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199\n200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219\n220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239\n240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 266 267 268 269\n270 271 282 283 284 285 286 287 298 299 300 301 302 303 314 315 316 317 318 319\n330 331 332 333 334 335 346 347 348 349 350 351 362 363 364 365 366 367 378 379\n380 381 382 383 394 395 396 397 398 399 410 411 412 413 414 415 416 417 418 419\n420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439\n440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459\n460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479\n480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499\n500\n```\n\nBut wait a minute. Let's take another look at the the task title. **Base-16 representation**. It isn't talking about Base 16 at all. It's talking about Base**-16**... so let's do it in base -16.\n\n```\nuse Base::Any;\n\nput display :20cols, :fmt('%3d'), (^501).grep( { .&to-base(-16).contains: /<[A..F]>/ } );\n\nsub display ($list, :$cols = 10, :$fmt = '%6d', :$title = \"{+$list} matching:\\n\" )   {\n    cache $list;\n    $title ~ $list.batch($cols)».fmt($fmt).join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\n306 matching:\n 10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29\n 30  31  32  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48  49\n 50  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69\n 70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89\n 90  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107 108 109\n110 111 122 123 124 125 126 127 138 139 140 141 142 143 154 155 156 157 158 159\n170 171 172 173 174 175 186 187 188 189 190 191 202 203 204 205 206 207 218 219\n220 221 222 223 234 235 236 237 238 239 250 251 252 253 254 255 266 267 268 269\n270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289\n290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309\n310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329\n330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349\n350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 378 379\n380 381 382 383 394 395 396 397 398 399 410 411 412 413 414 415 426 427 428 429\n430 431 442 443 444 445 446 447 458 459 460 461 462 463 474 475 476 477 478 479\n490 491 492 493 494 495\n```\n\nOf course, if you are looking for the **count** of the hexadecimal numbers up to some threshold that only use \"decimal\" digits, it is silly and counter-productive to iterate through them and check ***each*** when you really only need to check ***one***.\n\n```\nuse Lingua::EN::Numbers;\n\nfor 500\n   ,10**8\n   ,10**25\n   ,10**35\n   -> $threshold {\n    my $limit = $threshold.base(16);\n    my $i  = $limit.index: ['A'..'F'];\n    quietly $limit = $limit.substr(0, $i) ~ ('9' x ($limit.chars - $i)) if $i.Str;\n\n    for '  CAN  ', $limit,\n        'CAN NOT', $threshold - $limit {\n        printf( \"Quantity of numbers up to %s that %s be expressed in hexadecimal without using any alphabetics: %*s\\n\",\n         comma($threshold), $^a, comma($threshold).chars, comma($^c) )\n    }\n\n    say '';\n}\n\n```\n\nOutput:\n\n```\nQuantity of numbers up to 500 that   CAN   be expressed in hexadecimal without using any alphabetics: 199\nQuantity of numbers up to 500 that CAN NOT be expressed in hexadecimal without using any alphabetics: 301\n\nQuantity of numbers up to 100,000,000 that   CAN   be expressed in hexadecimal without using any alphabetics:   5,999,999\nQuantity of numbers up to 100,000,000 that CAN NOT be expressed in hexadecimal without using any alphabetics:  94,000,001\n\nQuantity of numbers up to 10,000,000,000,000,000,000,000,000 that   CAN   be expressed in hexadecimal without using any alphabetics:        845,951,614,014,849,999,999\nQuantity of numbers up to 10,000,000,000,000,000,000,000,000 that CAN NOT be expressed in hexadecimal without using any alphabetics:  9,999,154,048,385,985,150,000,001\n\nQuantity of numbers up to 100,000,000,000,000,000,000,000,000,000,000,000 that   CAN   be expressed in hexadecimal without using any alphabetics:         134,261,729,999,999,999,999,999,999,999\nQuantity of numbers up to 100,000,000,000,000,000,000,000,000,000,000,000 that CAN NOT be expressed in hexadecimal without using any alphabetics:  99,999,865,738,270,000,000,000,000,000,000,001\n```"}]}
{"messages": [{"role": "user", "content": "The popular encoding of small and medium-sized checksums is base16, that is more compact than usual base10 and is human readable... For checksums resulting in *hash digests* bigger than ~100 bits, the base16 is too long: base58 is shorter and (when using good alphabet) preserves secure human readability. The most popular alphabet of base58 is the variant used in bitcoin address (see Bitcoin/address validation), so it is the \"default base58 alphabet\".\n\nWrite a program that takes a checksum (resultant hash digest) *integer binary* representation as argument, and converts (encode it) into base58 with the standard Bitcoin alphabet — which uses an alphabet of the characters 0 .. 9, A ..Z, a .. z, but without the four characters:\n\n:   :   :   * **O**   the uppercase letter \"oh\",\n            * **I**    the uppercase letter \"eye\",\n            * **l**    the lowercase letter \"ell\",   and\n            * **0**   the digit zero.\n\nThe *reference algorithm* is at the Bitcoin's Base58Check page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub encode_Base58 ( Int $x ) {\n    constant @codes = <\n          1 2 3 4 5 6 7 8 9\n        A B C D E F G H   J K L M N   P Q R S T U V W X Y Z\n        a b c d e f g h i j k   m n o p q r s t u v w x y z\n    >;\n\n    return @codes[ $x.polymod( 58 xx * ) ].join.flip;\n}\n\nmy @tests = \n    25420294593250030202636073700053352635053786165627414518 => '6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM',\n    0x61                    => '2g',\n    0x626262                => 'a3gV',\n    0x636363                => 'aPEr',\n    0x73696d706c792061206c6f6e6720737472696e67 => '2cFupjhnEsSn59qHXstmK2ffpLv2',\n    0x516b6fcd0f            => 'ABnLTmg',\n    0xbf4f89001e670274dd    => '3SEo3LWLoPntC',\n    0x572e4794              => '3EFU7m',\n    0xecac89cad93923c02321  => 'EJDM8drfXA6uyA',\n    0x10c8511e              => 'Rt5zm',\n;\nuse Test;\nfor @tests {\n    is encode_Base58(.key), .value, \"{.key} encodes to {.value}\";\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "See Base64 encode data.\n\nNow write a program that takes the output of the Base64 encode data task as input and regenerate the original file.\n\nWhen working on the VBA implementation I found several 'solutions' on the net, including one from the software maker himself, that showed output with incorrect padding. Obviously with incorrect padding in the output you can not decode correctly to the original file again."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.11\n\n```\nmy $e64 = '\nVG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2\n9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=\n';\n\nmy @base64map = flat 'A' .. 'Z', 'a' .. 'z', ^10, '+', '/';\nmy %base64 is default(0) = @base64map.pairs.invert;\n\nsub base64-decode-slow ($enc) {\n    my $buf = Buf.new;\n    for $enc.subst(/\\s/, '', :g).comb(4) -> $chunck {\n        $buf.append: |(sprintf \"%06d%06d%06d%06d\", |$chunck.comb.map:\n            {%base64{$_}.base(2)}).comb(8).map: {:2($_)};\n    }\n    $buf\n}\n\nsay 'Slow:';\nsay base64-decode-slow($e64).decode('utf8');\n\n\n# Of course, the above routine is slow and is only for demonstration purposes.\n# For real code you should use a module, which is MUCH faster and heavily tested.\nsay \"\\nFast:\";\nuse Base64::Native;\nsay base64-decode($e64).decode('utf8');\n\n```\n\nOutput:\n\n```\nSlow:\nTo err is human, but to really foul things up you need a computer.\n    -- Paul R. Ehrlich\n\nFast:\nTo err is human, but to really foul things up you need a computer.\n    -- Paul R. Ehrlich\n```"}]}
{"messages": [{"role": "user", "content": "Convert an array of bytes or binary string to the base64-encoding of that string and output that value. Use the icon for Rosetta Code as the data to convert.\n\nSee also Base64 decode data."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub MAIN {\n    my $buf = slurp(\"./favicon.ico\", :bin);\n    say buf-to-Base64($buf);\n}\n\nmy @base64map = flat 'A' .. 'Z', 'a' .. 'z', ^10, '+', '/';\n\nsub buf-to-Base64($buf) {\n    join '', gather for $buf.list -> $a, $b = [], $c = [] {\n        my $triplet = ($a +< 16) +| ($b +< 8) +| $c;\n        take @base64map[($triplet +> (6 * 3)) +& 0x3F];\n        take @base64map[($triplet +> (6 * 2)) +& 0x3F];\n        if $c.elems {\n            take @base64map[($triplet +> (6 * 1)) +& 0x3F];\n            take @base64map[($triplet +> (6 * 0)) +& 0x3F];\n        }\n        elsif $b.elems {\n            take @base64map[($triplet +> (6 * 1)) +& 0x3F];\n            take '=';\n        }\n        else { take '==' }\n    }\n}\n\n```\n\nOutput:\n\n```\nAAABAAIAEBAAAAAAAABoBQAAJgAAACAgAA...QAAAAEAAAABAAAAAQAAAAE=\n```"}]}
{"messages": [{"role": "user", "content": "Bell or exponential numbers are enumerations of the number of different ways to partition a set that has exactly **n** elements. Each element of the sequence **Bn** is the number of partitions of a set of size **n** where order of the elements and order of the partitions are non-significant. E.G.: **{a b}** is the same as **{b a}** and **{a} {b}** is the same as **{b} {a}**.\n\nSo\n\n:   **B0 = 1** trivially. There is only one way to partition a set with zero elements. **{ }**\n\n:   **B1 = 1** There is only one way to partition a set with one element. **{a}**\n\n:   **B2 = 2** Two elements may be partitioned in two ways. **{a} {b}, {a b}**\n\n:   **B3 = 5** Three elements may be partitioned in five ways **{a} {b} {c}, {a b} {c}, {a} {b c}, {a c} {b}, {a b c}**\n\n:   and so on.\n\nA simple way to find the Bell numbers is construct a **Bell triangle**, also known as an **Aitken's array** or **Peirce triangle**, and read off the numbers in the first column of each row. There are other generating algorithms though, and you are free to choose the best / most appropriate for your case.\n\nTask\n\nWrite a routine (function, generator, whatever) to generate the Bell number sequence and call the routine to show here, on this page at least the **first 15** and (if your language supports big Integers) **50th** elements of the sequence.\n\nIf you *do* use the Bell triangle method to generate the numbers, also show the **first ten rows** of the Bell triangle.\n\nSee also\n\n:   * **OEIS:A000110 Bell or exponential numbers**\n    * **OEIS:A011971 Aitken's array**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### via Aitken's array\n\n**Works with**: Rakudo version 2019.03\n\n```\n my @Aitkens-array = lazy [1], -> @b {\n     my @c = @b.tail;\n     @c.push: @b[$_] + @c[$_] for ^@b;\n     @c\n } ... *;\n\n my @Bell-numbers = @Aitkens-array.map: { .head };\n\nsay \"First fifteen and fiftieth Bell numbers:\";\nprintf \"%2d: %s\\n\", 1+$_, @Bell-numbers[$_] for flat ^15, 49;\n\nsay \"\\nFirst ten rows of Aitken's array:\";\n.say for @Aitkens-array[^10];\n\n```\n\nOutput:\n\n```\nFirst fifteen and fiftieth Bell numbers:\n 1: 1\n 2: 1\n 3: 2\n 4: 5\n 5: 15\n 6: 52\n 7: 203\n 8: 877\n 9: 4140\n10: 21147\n11: 115975\n12: 678570\n13: 4213597\n14: 27644437\n15: 190899322\n50: 10726137154573358400342215518590002633917247281\n\nFirst ten rows of Aitken's array:\n[1]\n[1 2]\n[2 3 5]\n[5 7 10 15]\n[15 20 27 37 52]\n[52 67 87 114 151 203]\n[203 255 322 409 523 674 877]\n[877 1080 1335 1657 2066 2589 3263 4140]\n[4140 5017 6097 7432 9089 11155 13744 17007 21147]\n[21147 25287 30304 36401 43833 52922 64077 77821 94828 115975]\n```\n\n### via Recurrence relation\n\n**Works with**: Rakudo version 2019.03\n\n```\nsub binomial { [*] ($^n … 0) Z/ 1 .. $^p }\n\nmy @bell = 1, -> *@s { [+] @s »*« @s.keys.map: { binomial(@s-1, $_) }  } … *;\n\n.say for @bell[^15], @bell[50 - 1];\n\n```\n\nOutput:\n\n```\n(1 1 2 5 15 52 203 877 4140 21147 115975 678570 4213597 27644437 190899322)\n10726137154573358400342215518590002633917247281\n```\n\n### via Stirling sums\n\n**Works with**: Rakudo version 2019.03\n\n```\nmy @Stirling_numbers_of_the_second_kind =\n    (1,),\n    { (0, |@^last) »+« (|(@^last »*« @^last.keys), 0) } … *\n;\nmy @bell = @Stirling_numbers_of_the_second_kind.map: *.sum;\n\n.say for @bell.head(15), @bell[50 - 1];\n\n```\n\nOutput:\n\n```\n(1 1 2 5 15 52 203 877 4140 21147 115975 678570 4213597 27644437 190899322)\n10726137154573358400342215518590002633917247281 \n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Benford's\\_law. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\n**Benford's law**, also called the **first-digit law**, refers to the frequency distribution of digits in many (but not all) real-life sources of data.\n\nIn this distribution, the number 1 occurs as the first digit about 30% of the time, while larger numbers occur in that position less frequently: 9 as the first digit less than 5% of the time. This distribution of first digits is the same as the widths of gridlines on a logarithmic scale.\n\nBenford's law also concerns the expected distribution for digits beyond the first, which approach a uniform distribution.\n\nThis result has been found to apply to a wide variety of data sets, including electricity bills, street addresses, stock prices, population numbers, death rates, lengths of rivers, physical and mathematical constants, and processes described by power laws (which are very common in nature). It tends to be most accurate when values are distributed across multiple orders of magnitude.\n\nA set of numbers is said to satisfy Benford's law if the leading digit \n\nd\n{\\displaystyle {\\displaystyle d}}\n  (\n\nd\n∈\n{\n1\n,\n…\n,\n9\n}\n{\\displaystyle {\\displaystyle d\\in \\{1,\\ldots ,9\\}}}\n) occurs with probability\n\n:   :   :   :   P\n                (\n                d\n                )\n                =\n\n                log\n\n                10\n                ⁡\n                (\n                d\n                +\n                1\n                )\n                −\n\n                log\n\n                10\n                ⁡\n                (\n                d\n                )\n                =\n\n                log\n\n                10\n                ⁡\n\n                (\n\n                1\n                +\n\n\n                1\n                d\n                )\n                {\\displaystyle {\\displaystyle P(d)=\\log \\_{10}(d+1)-\\log \\_{10}(d)=\\log \\_{10}\\left(1+{\\frac {1}{d}}\\right)}}\n\nFor this task, write (a) routine(s) to calculate the distribution of first significant (non-zero) digits in a collection of numbers, then display the actual vs. expected distribution in the way most convenient for your language (table / graph / histogram / whatever).\n\nUse the first 1000 numbers from the Fibonacci sequence as your data set. No need to show how the Fibonacci numbers are obtained.\n\nYou can generate them or load them from a file; whichever is easiest.\n\nDisplay your actual vs expected distribution.\n\n*For extra credit:* Show the distribution for one other set of numbers from a page on Wikipedia. State which Wikipedia page it can be obtained from and what the set enumerates. Again, no need to display the actual list of numbers or the code to load them.\n\nSee also:\n\n* numberphile.com.\n* A starting page on Wolfram Mathworld is Benfords Law ."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016-10-24\n\n```\nsub benford(@a) { bag +« @a».substr(0,1) }\n\nsub show(%distribution) {\n    printf \"%9s %9s  %s\\n\", <Actual Expected Deviation>;\n    for 1 .. 9 -> $digit {\n        my $actual = %distribution{$digit} * 100 / [+] %distribution.values;\n        my $expected = (1 + 1 / $digit).log(10) * 100;\n        printf \"%d: %5.2f%% | %5.2f%% | %.2f%%\\n\",\n          $digit, $actual, $expected, abs($expected - $actual);\n    }\n}\n\nmulti MAIN($file) { show benford $file.IO.lines }\nmulti MAIN() { show benford ( 1, 1, 2, *+* ... * )[^1000] }\n\n```\n\n**Output:** First 1000 Fibonaccis\n\n```\n   Actual  Expected  Deviation\n1: 30.10% | 30.10% | 0.00%\n2: 17.70% | 17.61% | 0.09%\n3: 12.50% | 12.49% | 0.01%\n4:  9.60% |  9.69% | 0.09%\n5:  8.00% |  7.92% | 0.08%\n6:  6.70% |  6.69% | 0.01%\n7:  5.60% |  5.80% | 0.20%\n8:  5.30% |  5.12% | 0.18%\n9:  4.50% |  4.58% | 0.08%\n```\n\n**Extra credit:** Square Kilometers of land under cultivation, by country / territory. First column from Wikipedia: Land use statistics by country.\n\n```\n   Actual  Expected  Deviation\n1: 33.33% | 30.10% | 3.23%\n2: 18.31% | 17.61% | 0.70%\n3: 13.15% | 12.49% | 0.65%\n4:  8.45% |  9.69% | 1.24%\n5:  9.39% |  7.92% | 1.47%\n6:  5.63% |  6.69% | 1.06%\n7:  4.69% |  5.80% | 1.10%\n8:  5.16% |  5.12% | 0.05%\n9:  1.88% |  4.58% | 2.70%\n```"}]}
{"messages": [{"role": "user", "content": "The **Berlekamp–Massey algorithm** is an efficient algorithm for finding the shortest linear feedback shift register (LFSR) that generates a given sequence over a finite field. It determines the minimal polynomial of a linearly recurrent sequence, which is crucial in applications like error-correcting codes, cryptography, and sequence analysis.\n\nOverview\n\nGiven a sequence of elements \n\ns\n\n0\n,\n\ns\n\n1\n,\n…\n,\n\ns\n\nn\n−\n1\n{\\displaystyle {\\displaystyle s\\_{0},s\\_{1},\\dots ,s\\_{n-1}}}\n from a finite field, the Berlekamp–Massey algorithm computes the shortest LFSR, characterized by its connection polynomial \n\nC\n(\nx\n)\n=\n1\n+\n\nc\n\n1\nx\n+\n\nc\n\n2\n\nx\n\n2\n+\n⋯\n+\n\nc\n\nL\n\nx\n\nL\n{\\displaystyle {\\displaystyle C(x)=1+c\\_{1}x+c\\_{2}x^{2}+\\dots +c\\_{L}x^{L}}}\n, such that the sequence satisfies the recurrence relation:\n\n:   s\n\n    i\n    +\n    L\n    =\n    −\n\n    ∑\n\n    k\n    =\n    1\n\n    L\n\n    c\n\n    k\n\n    s\n\n    i\n    +\n    L\n    −\n    k\n    {\\displaystyle {\\displaystyle s\\_{i+L}=-\\sum \\_{k=1}^{L}c\\_{k}s\\_{i+L-k}}}\n\nfor all valid indices. The degree \n\nL\n{\\displaystyle {\\displaystyle L}}\n of the polynomial is the *linear complexity* of the sequence, representing the length of the shortest LFSR.\n\nHistory\n\nThe algorithm was independently developed by Elwyn Berlekamp in 1968 for decoding BCH codes and by James Massey in 1969 for cryptographic applications. It remains a cornerstone in coding theory and sequence analysis.\n\nAlgorithm Description\n\nThe Berlekamp–Massey algorithm iteratively constructs the connection polynomial by processing the input sequence element by element. It maintains a current polynomial \n\nC\n(\nx\n)\n{\\displaystyle {\\displaystyle C(x)}}\n and updates it whenever a discrepancy is found between the predicted and actual sequence values. The key steps are:\n\n1. Initialize \n\nC\n(\nx\n)\n=\n1\n{\\displaystyle {\\displaystyle C(x)=1}}\n, degree \n\nL\n=\n0\n{\\displaystyle {\\displaystyle L=0}}\n, and a temporary polynomial \n\nB\n(\nx\n)\n=\n1\n{\\displaystyle {\\displaystyle B(x)=1}}\n.\n2. For each sequence element \n\ns\n\ni\n{\\displaystyle {\\displaystyle s\\_{i}}}\n:\n\n```\n  * Compute the discrepancy \n  \n    \n      \n        \n          \n            Δ\n            =\n            \n              s\n              \n                i\n              \n            \n            +\n            \n              ∑\n              \n                k\n                =\n                1\n              \n              \n                L\n              \n            \n            \n              c\n              \n                k\n              \n            \n            \n              s\n              \n                i\n                −\n                k\n              \n            \n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\Delta =s_{i}+\\sum _{k=1}^{L}c_{k}s_{i-k}}}\n  \n.\n  * If \n  \n    \n      \n        \n          \n            Δ\n            ≠\n            0\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\Delta \\neq 0}}\n  \n:\n    * Update \n  \n    \n      \n        \n          \n            C\n            (\n            x\n            )\n            ←\n            C\n            (\n            x\n            )\n            −\n            Δ\n            x\n            B\n            (\n            x\n            )\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle C(x)\\leftarrow C(x)-\\Delta xB(x)}}\n  \n.\n    * If the discrepancy indicates a need for a longer LFSR (i.e., \n  \n    \n      \n        \n          \n            2\n            L\n            ≤\n            i\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle 2L\\leq i}}\n  \n), update \n  \n    \n      \n        \n          \n            L\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle L}}\n  \n and adjust \n  \n    \n      \n        \n          \n            B\n            (\n            x\n            )\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle B(x)}}\n  \n.\n\n```\n\n3. Output \n\nC\n(\nx\n)\n{\\displaystyle {\\displaystyle C(x)}}\n and \n\nL\n{\\displaystyle {\\displaystyle L}}\n.\n\nThe algorithm runs in \n\nO\n(\n\nn\n\n2\n)\n{\\displaystyle {\\displaystyle O(n^{2})}}\n time, where \n\nn\n{\\displaystyle {\\displaystyle n}}\n is the sequence length, and uses \n\nO\n(\nn\n)\n{\\displaystyle {\\displaystyle O(n)}}\n space.\n\nApplications\n\n* **Error Correction**: Used in decoding Reed–Solomon codes and BCH codes.\n* **Cryptography**: Analyzes the linear complexity of sequences in stream ciphers to assess security.\n* **Sequence Analysis**: Identifies patterns in sequences for signal processing and data compression.\n\nExample\n\nFor the binary sequence \n\n0\n,\n0\n,\n1\n,\n1\n,\n0\n,\n1\n,\n0\n{\\displaystyle {\\displaystyle 0,0,1,1,0,1,0}}\n over \n\nG\nF\n(\n2\n)\n{\\displaystyle {\\displaystyle GF(2)}}\n, the algorithm yields the connection polynomial \n\nC\n(\nx\n)\n=\n1\n+\nx\n+\n\nx\n\n3\n{\\displaystyle {\\displaystyle C(x)=1+x+x^{3}}}\n, indicating a linear complexity of 3."}, {"role": "assistant", "content": "**Translation of**: Python\n\n```\n# 20250510 Raku programming solution\n\nconstant MOD = 2;\n\nsub berlekamp_massey(@a) {\n   my ($n, $w, $delta, @ans_coef, @lst) = @a.elems - 1, 0;\n   for 1 .. $n -> $i {\n      my $tmp = 0;\n      for ^@ans_coef.elems -> $j {\n         if $i - 1 - $j >= 1 {\n            $tmp = ($tmp + @a[$i - 1 - $j] * @ans_coef[$j]) % MOD;\n         }\n      }\n      my $discrepancy = (@a[$i] - $tmp + MOD) % MOD;\n      next if $discrepancy == 0;\n      if $w == 0 {\n         @ans_coef = (0 xx $i);\n         $w = $i;\n         $delta = $discrepancy;\n         next;\n      }\n      my @now = @ans_coef;\n      my $mul = $discrepancy * expmod($delta, MOD - 2, MOD);\n      my $needed_len = @lst.elems + $i - $w;\n      if @ans_coef.elems < $needed_len {\n         @ans_coef.append: (0 xx ($needed_len - @ans_coef.elems));\n      }\n      if $i - $w - 1 >= 0 {\n         @ans_coef[$i - $w - 1] = (@ans_coef[$i - $w - 1] + $mul) % MOD;\n      }\n      for ^@lst.elems -> $j {\n         my $idx = $i - $w + $j;\n         if $idx < @ans_coef.elems {\n            my $term_to_subtract = ($mul * @lst[$j]) % MOD;\n            @ans_coef[$idx] = (@ans_coef[$idx] - $term_to_subtract + MOD) % MOD;\n         }\n      }\n      if @ans_coef.elems > @now.elems {\n         @lst = @now;\n         $w = $i;\n         $delta = $discrepancy;\n      }\n   }\n   return @ans_coef.map: { ($^x + MOD) % MOD };\n}\n\nsub calculate_term($m, @coef, @h) {\n   if $m < @h.elems                { return (@h[$m] + MOD) % MOD }\n   if ( my $k = @coef.elems ) == 0 { return 0 } \n   my @p_coeffs = (1, |@coef);\n   sub poly_mul(@a, @b, $degree_k, @p_poly) {\n      my @res = (0 xx (2 * $degree_k));\n      for ^$degree_k X ^$degree_k -> ($i, $j) {\n         next if @a[$i] == 0;\n         @res[$i + $j] = (@res[$i + $j] + @a[$i] * @b[$j]) % MOD;\n      }\n      for ( 2 * $degree_k - 1 ... $degree_k ) -> $i {\n         next if @res[$i] == 0; \n         my $term = @res[$i];\n         @res[$i] = 0;\n         for 0 .. $degree_k -> $j {\n            if ( my $idx = $i - $j ) >= 0 { \n               @res[$idx] = (@res[$idx] + $term * @p_poly[$j]) % MOD; \n            }\n         }\n      }\n      return @res[0 ... ^$degree_k];\n   }\n   my @f = (1, |(0 xx ($k - 1)));\n   my @g = $k == 1 ?? (@p_coeffs[1],) !! (0, 1, |(0 xx ($k - 2)));\n   my $power = $m;\n   while $power > 0 {\n      unless $power %% 2 { @f = poly_mul(@f, @g, $k, @p_coeffs) }\n      @g = poly_mul(@g, @g, $k, @p_coeffs);\n      $power div= 2;\n   }\n   my $final_ans = 0;\n   for ^$k -> \\k {\n      if k+1 < @h.elems { $final_ans = ($final_ans + @h[k+1] * @f[k]) % MOD }\n   } \n   return ($final_ans + MOD) % MOD;\n}\n\nsub solve {\n   my @h_input = 0,0,1,1,0,1,0;\n   my $n = @h_input.elems;\n   my @h = 0, |@h_input;\n   my @ans_coef = berlekamp_massey(@h);\n   say @ans_coef.map({ ($^x + MOD) % MOD }).Str;\n   my $m = 10;\n   my $result = calculate_term($m, @ans_coef, @h);\n   say ($result + MOD) % MOD;\n}\n\nsolve();\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Bernoulli numbers are used in some series expansions of several functions   (trigonometric, hyperbolic, gamma, etc.),   and are extremely important in number theory and analysis.\n\nNote that there are two definitions of Bernoulli numbers;   this task will be using the modern usage   (as per   *The National Institute of Standards and Technology convention*).\n\nThe   nth   Bernoulli number is expressed as   **B**n.\n\nTask\n\n:   * show the Bernoulli numbers   **B**0   through   **B**60.\n    * suppress the output of values which are equal to zero.   (Other than   **B**1 , all   *odd*   Bernoulli numbers have a value of zero.)\n    * express the Bernoulli numbers as fractions  (most are improper fractions).\n    * the fractions should be reduced.\n    * index each number in some way so that it can be discerned which Bernoulli number is being displayed.\n    * align the solidi   (**/**)   if used  (extra credit).\n\nAn algorithm\n\nThe Akiyama–Tanigawa algorithm for the \"second Bernoulli numbers\" as taken from wikipedia is as follows:\n\n```\n for m from 0 by 1 to n do\n    A[m] ← 1/(m+1)\n    for j from m by -1 to 1 do\n      A[j-1] ← j×(A[j-1] - A[j])\n  return A[0] (which is Bn)\n\n```\n\nSee also\n\n* Sequence A027641 Numerator of Bernoulli number B\\_n on The On-Line Encyclopedia of Integer Sequences.\n* Sequence A027642 Denominator of Bernoulli number B\\_n on The On-Line Encyclopedia of Integer Sequences.\n* Entry Bernoulli number on The Eric Weisstein's World of Mathematics (TM).\n* Luschny's The Bernoulli Manifesto for a discussion on    **B1   =   -½**   versus   **+½**."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Simple\n\nFirst, a straighforward implementation of the naïve algorithm in the task description.\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub bernoulli($n) {\n    my @a;\n    for 0..$n -> $m {\n        @a[$m] = FatRat.new(1, $m + 1);\n        for reverse 1..$m -> $j {\n          @a[$j - 1] = $j * (@a[$j - 1] - @a[$j]);\n        }\n    }\n    return @a[0];\n}\n\nconstant @bpairs = grep *.value.so, ($_ => bernoulli($_) for 0..60);\n\nmy $width = max @bpairs.map: *.value.numerator.chars;\nmy $form = \"B(%2d) = \\%{$width}d/%d\\n\";\n\nprintf $form, .key, .value.nude for @bpairs;\n\n```\n\nOutput:\n\n```\nB( 0) =                                            1/1\nB( 1) =                                            1/2\nB( 2) =                                            1/6\nB( 4) =                                           -1/30\nB( 6) =                                            1/42\nB( 8) =                                           -1/30\nB(10) =                                            5/66\nB(12) =                                         -691/2730\nB(14) =                                            7/6\nB(16) =                                        -3617/510\nB(18) =                                        43867/798\nB(20) =                                      -174611/330\nB(22) =                                       854513/138\nB(24) =                                   -236364091/2730\nB(26) =                                      8553103/6\nB(28) =                                 -23749461029/870\nB(30) =                                8615841276005/14322\nB(32) =                               -7709321041217/510\nB(34) =                                2577687858367/6\nB(36) =                        -26315271553053477373/1919190\nB(38) =                             2929993913841559/6\nB(40) =                       -261082718496449122051/13530\nB(42) =                       1520097643918070802691/1806\nB(44) =                     -27833269579301024235023/690\nB(46) =                     596451111593912163277961/282\nB(48) =                -5609403368997817686249127547/46410\nB(50) =                  495057205241079648212477525/66\nB(52) =              -801165718135489957347924991853/1590\nB(54) =             29149963634884862421418123812691/798\nB(56) =          -2479392929313226753685415739663229/870\nB(58) =          84483613348880041862046775994036021/354\nB(60) = -1215233140483755572040304994079820246041491/56786730\n```\n\n### With memoization\n\nHere is a much faster way, following the Perl solution that avoids recalculating previous values each time through the function. We do this in Raku by not defining it as a function at all, but by defining it as an infinite sequence that we can read however many values we like from (52, in this case, to get up to B(100)). In this solution we've also avoided subscripting operations; rather we use a sequence operator (...) iterated over the list of the previous solution to find the next solution. We reverse the array in this case to make reference to the previous value in the list more natural, which means we take the last value of the list rather than the first value, and do so conditionally to avoid 0 values.\n\n**Works with**: Rakudo version 2015.12\n\n```\nconstant bernoulli = gather {\n    my @a;\n    for 0..* -> $m {\n        @a = FatRat.new(1, $m + 1),\n                -> $prev {\n                    my $j = @a.elems;\n                    $j * (@a.shift - $prev);\n                } ... { not @a.elems }\n        take $m => @a[*-1] if @a[*-1];\n    }\n}\n\nconstant @bpairs = bernoulli[^52];\n\nmy $width = max @bpairs.map: *.value.numerator.chars;\nmy $form = \"B(%d)\\t= \\%{$width}d/%d\\n\";\n\nprintf $form, .key, .value.nude for @bpairs;\n\n```\n\nOutput:\n\n```\nB(0)\t=                                                                                    1/1\nB(1)\t=                                                                                    1/2\nB(2)\t=                                                                                    1/6\nB(4)\t=                                                                                   -1/30\nB(6)\t=                                                                                    1/42\nB(8)\t=                                                                                   -1/30\nB(10)\t=                                                                                    5/66\nB(12)\t=                                                                                 -691/2730\nB(14)\t=                                                                                    7/6\nB(16)\t=                                                                                -3617/510\nB(18)\t=                                                                                43867/798\nB(20)\t=                                                                              -174611/330\nB(22)\t=                                                                               854513/138\nB(24)\t=                                                                           -236364091/2730\nB(26)\t=                                                                              8553103/6\nB(28)\t=                                                                         -23749461029/870\nB(30)\t=                                                                        8615841276005/14322\nB(32)\t=                                                                       -7709321041217/510\nB(34)\t=                                                                        2577687858367/6\nB(36)\t=                                                                -26315271553053477373/1919190\nB(38)\t=                                                                     2929993913841559/6\nB(40)\t=                                                               -261082718496449122051/13530\nB(42)\t=                                                               1520097643918070802691/1806\nB(44)\t=                                                             -27833269579301024235023/690\nB(46)\t=                                                             596451111593912163277961/282\nB(48)\t=                                                        -5609403368997817686249127547/46410\nB(50)\t=                                                          495057205241079648212477525/66\nB(52)\t=                                                      -801165718135489957347924991853/1590\nB(54)\t=                                                     29149963634884862421418123812691/798\nB(56)\t=                                                  -2479392929313226753685415739663229/870\nB(58)\t=                                                  84483613348880041862046775994036021/354\nB(60)\t=                                         -1215233140483755572040304994079820246041491/56786730\nB(62)\t=                                               12300585434086858541953039857403386151/6\nB(64)\t=                                          -106783830147866529886385444979142647942017/510\nB(66)\t=                                       1472600022126335654051619428551932342241899101/64722\nB(68)\t=                                        -78773130858718728141909149208474606244347001/30\nB(70)\t=                                    1505381347333367003803076567377857208511438160235/4686\nB(72)\t=                             -5827954961669944110438277244641067365282488301844260429/140100870\nB(74)\t=                                   34152417289221168014330073731472635186688307783087/6\nB(76)\t=                               -24655088825935372707687196040585199904365267828865801/30\nB(78)\t=                            414846365575400828295179035549542073492199375372400483487/3318\nB(80)\t=                       -4603784299479457646935574969019046849794257872751288919656867/230010\nB(82)\t=                        1677014149185145836823154509786269900207736027570253414881613/498\nB(84)\t=                 -2024576195935290360231131160111731009989917391198090877281083932477/3404310\nB(86)\t=                      660714619417678653573847847426261496277830686653388931761996983/6\nB(88)\t=              -1311426488674017507995511424019311843345750275572028644296919890574047/61410\nB(90)\t=            1179057279021082799884123351249215083775254949669647116231545215727922535/272118\nB(92)\t=           -1295585948207537527989427828538576749659341483719435143023316326829946247/1410\nB(94)\t=            1220813806579744469607301679413201203958508415202696621436215105284649447/6\nB(96)\t=   -211600449597266513097597728109824233673043954389060234150638733420050668349987259/4501770\nB(98)\t=        67908260672905495624051117546403605607342195728504487509073961249992947058239/6\nB(100)\t= -94598037819122125295227433069493721872702841533066936133385696204311395415197247711/33330\n```\n\n### Functional\n\nAnd if you're a pure enough FP programmer to dislike destroying and reconstructing the array each time, here's the same algorithm without side effects. We use zip with the pair constructor => to keep values associated with their indices. This provides sufficient local information that we can define our own binary operator \"bop\" to reduce between each two terms, using the \"triangle\" form (called \"scan\" in Haskell) to return the intermediate results that will be important to compute the next Bernoulli number.\n\n**Works with**: Rakudo version 2016.12\n\n```\nsub infix:<bop>(\\prev, \\this) {\n    this.key => this.key * (this.value - prev.value)\n}\n\nsub next-bernoulli ( (:key($pm), :value(@pa)) ) {\n    $pm + 1 => [\n        map *.value,\n        [\\bop] ($pm + 2 ... 1) Z=> FatRat.new(1, $pm + 2), |@pa\n    ]\n}\n\nconstant bernoulli =\n    grep *.value,\n    map { .key => .value[*-1] },\n    (0 => [FatRat.new(1,1)], &next-bernoulli ... *)\n;\n\nconstant @bpairs = bernoulli[^52];\n \nmy $width = max @bpairs.map: *.value.numerator.chars;\nmy $form = \"B(%d)\\t= \\%{$width}d/%d\\n\";\n \nprintf $form, .key, .value.nude for @bpairs;\n\n```\n\nSame output as memoization example"}]}
{"messages": [{"role": "user", "content": "The \n\nn\n+\n1\n{\\displaystyle {\\displaystyle n+1}}\n Bernstein basis polynomials of degree \n\nn\n{\\displaystyle {\\displaystyle n}}\n are defined as\n\n:   b\n\n    k\n    ,\n    n\n    (\n    t\n    )\n    =\n\n    (\n\n    n\n    k\n\n    )\n\n    t\n\n    k\n\n\n    (\n\n    1\n    −\n    t\n    )\n\n    n\n    −\n    k\n    ,\n\n    k\n    =\n    0\n    ,\n    …\n    ,\n    n\n    {\\displaystyle {\\displaystyle b\\_{k,n}(t)={\\binom {n}{k}}t^{k}\\left(1-t\\right)^{n-k},\\quad k=0,\\ldots ,n}}\n\nAny real polynomial can written as a linear combination of such Bernstein basis polynomials. Let us call the coefficients in such linear combinations *Bernstein coefficients*.\n\nThe goal of this task is to write subprograms for working with degree-2 and degree-3 Bernstein coefficients. A programmer is likely to have to deal with such representations. For example, OpenType fonts store glyph outline data as as either degree-2 or degree-3 Bernstein coefficients.\n\nThe task is as follows:\n\n1. Write a subprogram (which we will call *Subprogram (1)*) to transform the ordinary monomial coefficients of a real polynomial, of degree 2 or less, to Bernstein coefficients for the degree-2 basis.\n2. Write *Subprogram (2)* to evaluate, at a given point, a real polynomial written in degree-2 Bernstein coefficients. For this use de Casteljau's algorithm.\n3. Write *Subprogram (3)* to transform the monomial coefficients of a real polynomial, of degree 3 or less, to Bernstein coefficients for degree 3.\n4. Write *Subprogram (4)* to evaluate, at a given point, a real polynomial written in degree-3 Bernstein coefficients. Use de Casteljau's algorithm.\n5. Write *Subprogram (5)* to transform Bernstein coefficients for degree 2 to Bernstein coefficients for degree 3.\n6. For the following polynomials, use *Subprogram (1)* to find Bernstein coefficients for the degree-2 basis: \n\n   p\n   (\n   x\n   )\n   =\n   1\n   {\\displaystyle {\\displaystyle p(x)=1}}\n   , \n\n   q\n   (\n   x\n   )\n   =\n   1\n   +\n   2\n   x\n   +\n   3\n\n   x\n\n   2\n   {\\displaystyle {\\displaystyle q(x)=1+2x+3x^{2}}}\n   . Display the results.\n7. Use *Subprogram (2)* to evaluate \n\n   p\n   (\n   x\n   )\n   {\\displaystyle {\\displaystyle p(x)}}\n    and \n\n   q\n   (\n   x\n   )\n   {\\displaystyle {\\displaystyle q(x)}}\n    at \n\n   x\n   =\n   0.25\n   {\\displaystyle {\\displaystyle x=0.25}}\n    and at \n\n   x\n   =\n   7.50\n   {\\displaystyle {\\displaystyle x=7.50}}\n   . Display the results. Optionally also evaluate the polynomials in the monomial basis and display the results. (For the monomial basis it is best to use a Horner scheme.)\n8. Use *Subprogram (3)* to find degree-3 Bernstein coefficients for \n\n   p\n   (\n   x\n   )\n   {\\displaystyle {\\displaystyle p(x)}}\n    and \n\n   q\n   (\n   x\n   )\n   {\\displaystyle {\\displaystyle q(x)}}\n   , and additionally also for \n\n   r\n   (\n   x\n   )\n   =\n   1\n   +\n   2\n   x\n   +\n   3\n\n   x\n\n   2\n   +\n   4\n\n   x\n\n   3\n   {\\displaystyle {\\displaystyle r(x)=1+2x+3x^{2}+4x^{3}}}\n   . Display the results.\n9. Use *Subprogram (4)* to evaluate \n\n   p\n   (\n   x\n   )\n   {\\displaystyle {\\displaystyle p(x)}}\n   , \n\n   q\n   (\n   x\n   )\n   {\\displaystyle {\\displaystyle q(x)}}\n   , and \n\n   r\n   (\n   x\n   )\n   {\\displaystyle {\\displaystyle r(x)}}\n    at \n\n   x\n   =\n   0.25\n   {\\displaystyle {\\displaystyle x=0.25}}\n    and \n\n   x\n   =\n   7.50\n   {\\displaystyle {\\displaystyle x=7.50}}\n   . Display the results. Optionally also evaluate them in the monomial basis and display the results. (You may have done that already for \n\n   p\n   (\n   x\n   )\n   {\\displaystyle {\\displaystyle p(x)}}\n    and \n\n   q\n   (\n   x\n   )\n   {\\displaystyle {\\displaystyle q(x)}}\n   .)\n10. Use *Subprogram (5)* to get degree-3 Bernstein coefficients for \n\n    p\n    (\n    x\n    )\n    {\\displaystyle {\\displaystyle p(x)}}\n     and \n\n    q\n    (\n    x\n    )\n    {\\displaystyle {\\displaystyle q(x)}}\n     from their degree-2 Bernstein coefficients. Display the results.\n\nALGOL 60 and Python implementations are provided as initial examples. The latter does the optional monomial-basis evaluations.\n\nYou can use the following algorithms. They are written in unambiguous Algol 60 reference language instead of a made up pseudo-language. The ALGOL 60 example was necessary to check my work, but these reference versions are in the actual standard language designed for the printing of algorithms.\n\n```\nprocedure tobern2 (a0, a1, a2, b0, b1, b2);\n value a0, a1, a2; comment pass by value;\n real a0, a1, a2;\n real b0, b1, b2;\ncomment Subprogram (1): transform monomial coefficients a0, a1, a2 to Bernstein coefficients b0, b1, b2;\nbegin\n b0 := a0;\n b1 := a0 + ((1/2) × a1);\n b2 := a0 + a1 + a2\nend tobern2;\n\n```\n\n```\nreal procedure evalbern2 (b0, b1, b2, t);\n value b0, b1, b2, t;\n real b0, b1, b2, t;\ncomment Subprogram (2): evaluate, at t, the polynomial with Bernstein coefficients b0, b1, b2. Use de Casteljau’s algorithm;\nbegin\n real s, b01, b12, b012;\n s := 1 - t;\n b01 := (s × b0) + (t × b1);\n b12 := (s × b1) + (t × b2);\n b012 := (s × b01) + (t × b12);\n evalbern2 := b012\nend evalbern2;\n\n```\n\n```\nprocedure tobern3 (a0, a1, a2, a3, b0, b1, b2, b3);\n value a0, a1, a2, a3;\n real a0, a1, a2, a3;\n real b0, b1, b2, b3;\ncomment Subprogram (3): transform monomial coefficients a0, a1, a2, a3 to Bernstein coefficients b0, b1, b2, b3;\nbegin\n b0 := a0;\n b1 := a0 + ((1/3) × a1);\n b2 := a0 + ((2/3) × a1) + ((1/3) × a2);\n b3 := a0 + a1 + a2 + a3\nend tobern3;  \n\n```\n\n```\nreal procedure evalbern3 (b0, b1, b2, b3, t);\n value b0, b1, b2, b3, t;\n real b0, b1, b2, b3, t;\ncomment Subprogram (4): evaluate, at t, the polynomial with Bernstein coefficients b0, b1, b2, b3. Use de Casteljau's algorithm;\nbegin\n real s, b01, b12, b23, b012, b123, b0123;\n s := 1 - t;\n b01 := (s × b0) + (t × b1);\n b12 := (s × b1) + (t × b2);\n b23 := (s × b2) + (t × b3);\n b012 := (s × b01) + (t × b12);\n b123 := (s × b12) + (t × b23);\n b0123 := (s × b012) + (t × b123);\n evalbern3 := b0123\nend evalbern3;\n\n```\n\n```\nprocedure bern2to3 (q0, q1, q2, c0, c1, c2, c3);\n value q0, q1, q2;\n real q0, q1, q2;\n real c0, c1, c2, c3;\ncomment Subprogram (5): transform the quadratic Bernstein coefficients q0, q1, q2 to the cubic Bernstein coefficients c0, c1, c2, c3;\nbegin\n c0 := q0;\n c1 := ((1/3) × q0) + ((2/3) × q1);\n c2 := ((2/3) × q1) + ((1/3) × q2);\n c3 := q2\nend bern2to3;\n\n```"}, {"role": "assistant", "content": "**Translation of**: Wren\n\n```\n# 20230601 Raku programming solution\n\nsub toBern2 { [ @_[0], @_[0]+@_[1]/2, @_[0..2].sum ] }\n\nsub toBern3 (@a) { @a[0], @a[0]+@a[1]/3, @a[0]+@a[1]*2/3+@a[2]/3, @a[0..3].sum }\n\nsub evalBern-N (@b, $t) { # uses de Casteljau's algorithm\n   my ($s, @bern) = 1 - $t, @b.Slip;\n   while ( @bern.elems > 2 ) { \n      @bern = @bern.rotor(2 => -1).map: { $s * .[0] + $t * .[1] };\n   }\n   return $s * @bern[0] + $t * @bern[1] \n}\n\nsub evaluations (@m, @b, $x) {\n   my $m = ([o] map { $_ + $x * * }, @m)(0); # Horner's rule\n   return \"p({$x.fmt: '%.2f'}) = { evalBern-N @b, $x } (mono $m)\";\n}\n\nsub bern2to3 (@a) { @a[0], @a[0]/3+@a[1]*2/3, @a[1]*2/3+@a[2]/3, @a[2] }\n\nmy (@pm,@qm,@rm) := ([1, 0, 0], [1, 2, 3], [1, 2, 3, 4]);\n\nsay \"Subprogram(1) examples:\";\n\nmy (@pb2,@qb2) := (@pm,@qm).map: { toBern2 $_ };\nsay \"mono [{.[0]}] --> bern [{.[1]}]\" for (@pm,@pb2,@qm,@qb2).rotor: 2;\n\nsay \"\\nSubprogram(2) examples:\";\n\nfor (@pm,@pb2,@qm,@qb2).rotor(2) X (0.25,7.5) -> [[@m,@b], $x] {\n   say evaluations @m, @b, $x \n}\n\nsay \"\\nSubprogram(3) examples:\";\n\n.push(0) for (@pm,@qm);\nmy (@pb3,@qb3,@rb3) := (@pm,@qm,@rm).map: { toBern3 $_ };\nsay \"mono [{.[0]}] --> bern [{.[1]}]\" for (@pm,@pb3,@qm,@qb3,@rm,@rb3).rotor: 2;\n\nsay \"\\nSubprogram(4) examples:\";\n\nfor (@pm,@pb3,@qm,@qb3,@rm,@rb3).rotor(2) X (0.25,7.5) -> [[@m,@b], $x] {\n   say evaluations @m, @b, $x\n}\n\nsay \"\\nSubprogram(5) examples:\";\n\nmy (@pc,@qc) := (@pb2,@qb2).map: { bern2to3 $_ };\nsay  \"mono [{.[1]}] --> bern [{.[0]}]\" for (@pc,@pb2,@qc,@qb2).rotor: 2;\n\n```\n\nOutput:\n\n```\nSubprogram(1) examples:\nmono [1 0 0] --> bern [1 1 1]\nmono [1 2 3] --> bern [1 2 6]\n\nSubprogram(2) examples:\np(0.25) = 1 (mono 1)\np(7.50) = 1 (mono 1)\np(0.25) = 1.6875 (mono 1.6875)\np(7.50) = 184.75 (mono 184.75)\n\nSubprogram(3) examples:\nmono [1 0 0 0] --> bern [1 1 1 1]\nmono [1 2 3 0] --> bern [1 1.666667 3.333333 6]\nmono [1 2 3 4] --> bern [1 1.666667 3.333333 10]\n\nSubprogram(4) examples:\np(0.25) = 1 (mono 1)\np(7.50) = 1 (mono 1)\np(0.25) = 1.6875 (mono 1.6875)\np(7.50) = 184.75 (mono 184.75)\np(0.25) = 1.75 (mono 1.75)\np(7.50) = 1872.25 (mono 1872.25)\n\nSubprogram(5) examples:\nmono [1 1 1] --> bern [1 1 1 1]\nmono [1 2 6] --> bern [1 1.666667 3.333333 6]\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task\n\nShuffle the characters of a string in such a way that as many of the character values are in a different position as possible.\n\nA shuffle that produces a randomized result among the best choices is to be preferred. A deterministic approach that produces the same sequence every time is acceptable as an alternative.\n\nDisplay the result as follows:\n\n```\noriginal string, shuffled string, (score) \n\n```\n\nThe score gives the number of positions whose character value did *not* change.\n\nExample\n\n```\ntree, eetr, (0)\n\n```\n\nTest cases\n\n```\nabracadabra\nseesaw\nelk\ngrrrrrr\nup\na\n\n```\n\nRelated tasks\n\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Sidef\n\n```\nsub best-shuffle(Str $orig) {\n    my @s = $orig.comb;\n    my @t = @s.pick(*);\n\n    for flat ^@s X ^@s -> \\i,\\j {\n        if i != j and @t[i] ne @s[j] and @t[j] ne @s[i] {\n            @t[i,j] = @t[j,i] and last\n        }\n    }\n\n    my $count = 0;\n    for @t.kv -> $k,$v {\n        ++$count if $v eq @s[$k]\n    }\n\n    @t.join, $count;\n}\n\nprintf \"%s, %s, (%d)\\n\", $_, best-shuffle $_  for <abracadabra seesaw elk grrrrrr up a>;\n\n```\n\nOutput:\n\n```\nabracadabra, raacarabadb, (0)\nseesaw, wssaee, (0)\nelk, lke, (0)\ngrrrrrr, rrrgrrr, (5)\nup, pu, (0)\na, a, (1)\n```"}]}
{"messages": [{"role": "user", "content": "Description\n\nThe Bifid cipher is a polygraphic substitution cipher which was invented by Félix Delastelle in around 1901. It uses a 5 x 5 Polybius square combined with transposition and fractionation to encrypt a message. Any 5 x 5 Polybius square can be used but, as it only has 25 cells and there are 26 letters of the (English) alphabet, one cell needs to represent two letters - I and J being a common choice.\n\nOperation\n\nSuppose we want to encrypt the message \"ATTACKATDAWN\".\n\nWe use this archetypal Polybius square where I and J share the same position.\n\n```\nx/y 1 2 3 4 5\n-------------\n1 | A B C D E\n2 | F G H I K\n3 | L M N O P\n4 | Q R S T U \n5 | V W X Y Z\n\n```\n\nThe message is first converted to its x, y coordinates, but they are written vertically beneath.\n\n```\nA T T A C K A T D A W N\n1 4 4 1 1 2 1 4 1 1 5 3\n1 4 4 1 3 5 1 4 4 1 2 3\n\n```\n\nThey are then arranged in a row.\n\n```\n1 4 4 1 1 2 1 4 1 1 5 3 1 4 4 1 3 5 1 4 4 1 2 3\n\n```\n\nFinally, they are divided up into pairs which are used to look up the encrypted letters in the square.\n\n```\n14 41 12 14 11 53 14 41 35 14 41 23\nD  Q  B  D  A  X  D  Q  P  D  Q  H\n\n```\n\nThe encrypted message is therefore \"DQBDAXDQPDQH\".\n\nDecryption can be achieved by simply reversing these steps.\n\nTask\n\nWrite routines in your language to encrypt and descrypt a message using the Bifid cipher.\n\nUse them to verify (including subsequent decryption):\n\n1. The above example.\n\n2. The example in the Wikipedia article using the message and Polybius square therein.\n\n3. The above example but using the Polybius square in the Wikipedia article to illustrate that it doesn't matter which square you use as long, of course, as the same one is used for both encryption and decryption.\n\nIn addition, encrypt and decrypt the message \"The invasion will start on the first of January\" using any Polybius square you like. Convert the message to upper case and ignore spaces.\n\nBonus\n\nSuggest a way in which the cipher could be modified so that ALL 26 letters can be uniquely encrypted.\n\nRelated task\n\nPlayfair cipher"}, {"role": "assistant", "content": "Technically incorrect as the third part doesn't \"Convert ... to upper case and ignore spaces\".\n\n```\nsub polybius ($text) {\n    my $n = $text.chars.sqrt.narrow;\n    $text.comb.kv.map: { $^v => ($^k % $n, $k div $n).join: ' ' }\n}\n\nsub encrypt ($message, %poly) {\n    %poly.invert.hash{(flat reverse [Z] %poly{$message.comb}».words).batch(2)».reverse».join: ' '}.join\n}\n\nsub decrypt ($message, %poly) {\n   %poly.invert.hash{reverse [Z] (reverse flat %poly{$message.comb}».words».reverse).batch($message.chars)}.join\n}\n\n\nfor 'ABCDEFGHIKLMNOPQRSTUVWXYZ', 'ATTACKATDAWN',\n    'BGWKZQPNDSIOAXEFCLUMTHYVR', 'FLEEATONCE',\n    (flat '_', '.', 'A'..'Z', 'a'..'z', 0..9).pick(*).join, 'The invasion will start on the first of January 2023.'.subst(/' '/, '_', :g)\n -> $polybius, $message {\n    my %polybius = polybius $polybius;\n    say \"\\nUsing polybius:\\n\\t\" ~ $polybius.comb.batch($polybius.chars.sqrt.narrow).join: \"\\n\\t\";\n    say \"\\n  Message : $message\";\n    say \"Encrypted : \" ~ my $encrypted = encrypt $message, %polybius;\n    say \"Decrypted : \" ~ decrypt $encrypted, %polybius;\n}\n\n```\n\nOutput:\n\n```\nUsing polybius:\n\tA B C D E\n\tF G H I K\n\tL M N O P\n\tQ R S T U\n\tV W X Y Z\n\n  Message : ATTACKATDAWN\nEncrypted : DQBDAXDQPDQH\nDecrypted : ATTACKATDAWN\n\nUsing polybius:\n\tB G W K Z\n\tQ P N D S\n\tI O A X E\n\tF C L U M\n\tT H Y V R\n\n  Message : FLEEATONCE\nEncrypted : UAEOLWRINS\nDecrypted : FLEEATONCE\n\nUsing polybius:\n\tH c F T N 5 f i\n\t_ U k R B Z V W\n\t3 G e v s w j x\n\tq S 2 8 y Q . O\n\tm 0 E d h D r u\n\tM p 7 Y 4 A 9 a\n\tt X l I 6 g b z\n\tJ P n 1 K L C o\n\n  Message : The_invasion_will_start_on_the_first_of_January_2023.\nEncrypted : NGiw3okfXj4XoVE_NjWcLK4Sy28EivKo3aeNiti3N3z6HCHno6Fkf\nDecrypted : The_invasion_will_start_on_the_first_of_January_2023.\n```"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nBilinear interpolation is linear interpolation in 2 dimensions, and is typically used for image scaling and for 2D finite element analysis.\n\nTask\n\nOpen an image file, enlarge it by 60% using bilinear interpolation, then either display the result or save the result to a file."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n#!/usr/bin/env perl6\n\nuse v6;\nuse GD::Raw;\n\n# Reference:\n# https://github.com/dagurval/perl6-gd-raw\n\nmy $fh1 = fopen('./Lenna100.jpg', \"rb\") or die;\nmy $img1 = gdImageCreateFromJpeg($fh1);\n\nmy $fh2 = fopen('./Lenna100-larger.jpg',\"wb\") or die;\n\nmy $img1X = gdImageSX($img1);\nmy $img1Y = gdImageSY($img1);\n\nmy $NewX = $img1X * 1.6;\nmy $NewY = $img1Y * 1.6;\n\ngdImageSetInterpolationMethod($img1, +GD_BILINEAR_FIXED);\n\nmy $img2 = gdImageScale($img1, $NewX.ceiling, $NewY.ceiling);\n\ngdImageJpeg($img2,$fh2,-1);\n\ngdImageDestroy($img1);\ngdImageDestroy($img2);\n\nfclose($fh1);\nfclose($fh2);\n\n```\n\nOutput:\n\n```\nfile Lenna100*\nLenna100.jpg:        JPEG image data, JFIF standard 1.01, resolution (DPI), density 72x72, segment length 16, baseline, precision 8, 512x512, frames 3\nLenna100-larger.jpg: JPEG image data, JFIF standard 1.01, resolution (DPI), density 96x96, segment length 16, comment: \"CREATOR: gd-jpeg v1.0 (using IJG JPEG v80), default quality\", baseline, precision 8, 820x820, frames 3\n```"}]}
{"messages": [{"role": "user", "content": "You are given a list of n ascending, unique numbers which are to form limits\nfor n+1 bins which count how many of a large set of input numbers fall in the\nrange of each bin.\n\n(Assuming zero-based indexing)\n\n```\n   bin[0] counts how many inputs are < limit[0]\n   bin[1] counts how many inputs are >= limit[0] and < limit[1]\n   ..\n   bin[n-1] counts how many inputs are >= limit[n-2] and < limit[n-1]\n   bin[n] counts how many inputs are >= limit[n-1]\n\n```\n\nTask\n\nThe task is to create a function that given the ascending limits and a stream/\nlist of numbers, will return the bins; together with another function that\ngiven the same list of limits and the binning will *print the limit of each bin*\ntogether with the count of items that fell in the range*.*\n\nAssume the numbers to bin are too large to practically sort.\n\nTask examples\n\nPart 1: Bin using the following limits the given input data\n\n```\n   limits  = [23, 37, 43, 53, 67, 83]\n   data = [95,21,94,12,99,4,70,75,83,93,52,80,57,5,53,86,65,17,92,83,71,61,54,58,47,\n           16, 8, 9,32,84,7,87,46,19,30,37,96,6,98,40,79,97,45,64,60,29,49,36,43,55]\n\n```\n\nPart 2: Bin using the following limits the given input data\n\n```\n   limits = [14, 18, 249, 312, 389, 392, 513, 591, 634, 720]\n   data = [445,814,519,697,700,130,255,889,481,122,932, 77,323,525,570,219,367,523,442,933,\n           416,589,930,373,202,253,775, 47,731,685,293,126,133,450,545,100,741,583,763,306,\n           655,267,248,477,549,238, 62,678, 98,534,622,907,406,714,184,391,913, 42,560,247,\n           346,860, 56,138,546, 38,985,948, 58,213,799,319,390,634,458,945,733,507,916,123,\n           345,110,720,917,313,845,426,  9,457,628,410,723,354,895,881,953,677,137,397, 97,\n           854,740, 83,216,421, 94,517,479,292,963,376,981,480, 39,257,272,157,  5,316,395,\n           787,942,456,242,759,898,576, 67,298,425,894,435,831,241,989,614,987,770,384,692,\n           698,765,331,487,251,600,879,342,982,527,736,795,585, 40, 54,901,408,359,577,237,\n           605,847,353,968,832,205,838,427,876,959,686,646,835,127,621,892,443,198,988,791,\n           466, 23,707,467, 33,670,921,180,991,396,160,436,717,918,  8,374,101,684,727,749]\n\n```\n\nShow output here, on this page."}, {"role": "assistant", "content": "```\nsub bin_it ( @limits, @data ) {\n    my @ranges = ( -Inf, |@limits, Inf ).rotor( 2 => -1 ).map: { .[0] ..^ .[1] };\n    my @binned = @data.classify(-> $d { @ranges.grep(-> $r { $d ~~ $r }) });\n    my %counts = @binned.map: { .key => .value.elems };\n    return @ranges.map: { $_ => ( %counts{$_} // 0 ) };\n}\nsub bin_format ( @bins ) {\n    return @bins.map: { .key.gist.fmt('%9s => ') ~ .value.fmt('%2d') };\n}\n\nmy @tests =\n    {\n        limits => (23, 37, 43, 53, 67, 83),\n        data   => (95,21,94,12,99,4,70,75,83,93,52,80,57,5,53,86,65,17,92,83,71,61,54,58,47,16,8,9,32,84,7,87,46,19,30,37,96,6,98,40,79,97,45,64,60,29,49,36,43,55),\n    },\n    {\n        limits => (14, 18, 249, 312, 389, 392, 513, 591, 634, 720),\n        data   => (\n            445,814,519,697,700,130,255,889,481,122,932, 77,323,525,570,219,367,523,442,933,416,589,930,373,202,253,775, 47,731,685,293,126,133,450,545,100,741,583,763,306,\n            655,267,248,477,549,238, 62,678, 98,534,622,907,406,714,184,391,913, 42,560,247,346,860, 56,138,546, 38,985,948, 58,213,799,319,390,634,458,945,733,507,916,123,\n            345,110,720,917,313,845,426,  9,457,628,410,723,354,895,881,953,677,137,397, 97,854,740, 83,216,421, 94,517,479,292,963,376,981,480, 39,257,272,157,  5,316,395,\n            787,942,456,242,759,898,576, 67,298,425,894,435,831,241,989,614,987,770,384,692,698,765,331,487,251,600,879,342,982,527,736,795,585, 40, 54,901,408,359,577,237,\n            605,847,353,968,832,205,838,427,876,959,686,646,835,127,621,892,443,198,988,791,466, 23,707,467, 33,670,921,180,991,396,160,436,717,918,  8,374,101,684,727,749\n        ),\n    },\n;\nfor @tests -> ( :@limits, :@data ) {\n    my @bins = bin_it( @limits, @data );\n    .say for bin_format(@bins);\n    say '';\n}\n\n```\n\nOutput:\n\n```\n-Inf..^23 => 11\n  23..^37 =>  4\n  37..^43 =>  2\n  43..^53 =>  6\n  53..^67 =>  9\n  67..^83 =>  5\n 83..^Inf => 13\n\n-Inf..^14 =>  3\n  14..^18 =>  0\n 18..^249 => 44\n249..^312 => 10\n312..^389 => 16\n389..^392 =>  2\n392..^513 => 28\n513..^591 => 16\n591..^634 =>  6\n634..^720 => 16\n720..^Inf => 59\n\n```"}]}
{"messages": [{"role": "user", "content": "Binary-Coded Decimal (or BCD for short) is a method of representing decimal numbers by storing what appears to be a decimal number but is actually stored as hexadecimal. Many CISC CPUs (e.g. X86 Assembly have special hardware routines for displaying these kinds of numbers.) On low-level hardware, such as 7-segment displays, binary-coded decimal is very important for outputting data in a format the end user can understand.\n\nTask\n\nUse your language's built-in BCD functions, OR create your own conversion function, that converts an addition of hexadecimal numbers to binary-coded decimal. You should get the following results with these test cases:\n\n* 0x19 + 1 = 0x20\n* 0x30 - 1 = 0x29\n* 0x99 + 1 = 0x100\n\nBonus Points\n\nDemonstrate the above test cases in both \"packed BCD\" (two digits per byte) and \"unpacked BCD\" (one digit per byte)."}, {"role": "assistant", "content": "**Translation of**: Rust\n\n```\n# 20220930 Raku programming solution\n\nclass Bcd64 { has uint64 $.bits }\n\nmulti infix:<⊞> (Bcd64 \\p, Bcd64 \\q) {\n   my $t1 = p.bits + 0x0666_6666_6666_6666;\n   my $t2 = ( $t1 + q.bits ) % uint64.Range.max ; \n   my $t3 = $t1 +^ q.bits; \n   my $t4 = +^($t2 +^ $t3) +& 0x1111_1111_1111_1110;\n   my $t5 = ($t4 +> 2) +| ($t4 +> 3);\n   Bcd64.new: bits => ($t2 - $t5)\n}\n\nmulti prefix:<⊟> (Bcd64 \\p) {\n   my $t1 = uint64.Range.max + 1 - p.bits ;\n   my $t2 = ( $t1 + 0xFFFF_FFFF_FFFF_FFFF ) % uint64.Range.max;\n   my $t3 = $t2 +^ 1;\n   my $t4 = +^($t2 +^ $t3) +& 0x1111_1111_1111_1110;\n   my $t5 = ($t4 +> 2) +| ($t4 +> 3);\n   Bcd64.new: bits => ($t1 - $t5)\n}\n\nmulti infix:<⊟> (Bcd64 \\p, Bcd64 \\q) { p ⊞ ( ⊟q ) }\n\nmy ($one,$n19,$n30,$n99) = (0x01,0x19,0x30,0x99).map: { Bcd64.new: bits=>$_ };\n\n{ .bits.base(16).say } for ($n19 ⊞ $one,$n30 ⊟ $one,$n99 ⊞ $one);\n\n```\n\nOutput:\n\n```\n20\n29\n100\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate and display the sequence of binary digits for a given   non-negative integer.\n\n```\n   The decimal value      5   should produce an output of               101\n   The decimal value     50   should produce an output of            110010\n   The decimal value   9000   should produce an output of    10001100101000\n\n```\n\nThe results can be achieved using built-in radix functions within the language   (if these are available),   or alternatively a user defined function can be used.\n\nThe output produced should consist just of the binary digits of each number followed by a   *newline*.\n\nThere should be no other whitespace, radix or sign markers in the produced output, and leading zeros should not appear in the results."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nsay .fmt(\"%b\") for 5, 50, 9000;\n```\n\n```\n101\n110010\n10001100101000\n\n```\n\nAlternatively:\n\n```\nsay .base(2) for 5, 50, 9000;\n```\n\n```\n101\n110010\n10001100101000\n```"}]}
{"messages": [{"role": "user", "content": "A binary search divides a range of values into halves, and continues to narrow down the field of search until the unknown value is found. It is the classic example of a \"divide and conquer\" algorithm.\n\nAs an analogy, consider the children's game \"guess a number.\" The scorer has a secret number, and will only tell the player if their guessed number is higher than, lower than, or equal to the secret number. The player then uses this information to guess a new number.\n\nAs the player, an optimal strategy for the general case is to start by choosing the range's midpoint as the guess, and then asking whether the guess was higher, lower, or equal to the secret number. If the guess was too high, one would select the point exactly between the range midpoint and the beginning of the range. If the original guess was too low, one would ask about the point exactly between the range midpoint and the end of the range. This process repeats until one has reached the secret number.\n\nTask\n\nGiven the starting point of a range, the ending point of a range, and the \"secret value\", implement a binary search through a sorted integer array for a certain number. Implementations can be recursive or iterative (both if you can). Print out whether or not the number was in the array afterwards. If it was, print the index also.\n\nThere are several binary search algorithms commonly seen. They differ by how they treat multiple values equal to the given value, and whether they indicate whether the element was found or not. For completeness we will present pseudocode for all of them.\n\nAll of the following code examples use an \"inclusive\" upper bound (i.e. `high = N-1` initially). Any of the examples can be converted into an equivalent example using \"exclusive\" upper bound (i.e. `high = N` initially) by making the following simple changes (which simply increase `high` by 1):\n\n* change `high = N-1` to `high = N`\n* change `high = mid-1` to `high = mid`\n* (for recursive algorithm) change `if (high < low)` to `if (high <= low)`\n* (for iterative algorithm) change `while (low <= high)` to `while (low < high)`\n\nTraditional algorithm\n\nThe algorithms are as follows (from Wikipedia). The algorithms return the index of some element that equals the given value (if there are multiple such elements, it returns some arbitrary one). It is also possible, when the element is not found, to return the \"insertion point\" for it (the index that the value would have if it were inserted into the array).\n\n**Recursive Pseudocode**:\n\n```\n  // initially called with low = 0, high = N-1\n  BinarySearch(A[0..N-1], value, low, high) {\n      // invariants: value > A[i] for all i < low\n                     value < A[i] for all i > high\n      if (high < low)\n          return not_found // value would be inserted at index \"low\"\n      mid = (low + high) / 2\n      if (A[mid] > value)\n          return BinarySearch(A, value, low, mid-1)\n      else if (A[mid] < value)\n          return BinarySearch(A, value, mid+1, high)\n      else\n          return mid\n  }\n\n```\n\n**Iterative Pseudocode**:\n\n```\n  BinarySearch(A[0..N-1], value) {\n      low = 0\n      high = N - 1\n      while (low <= high) {\n          // invariants: value > A[i] for all i < low\n                         value < A[i] for all i > high\n          mid = (low + high) / 2\n          if (A[mid] > value)\n              high = mid - 1\n          else if (A[mid] < value)\n              low = mid + 1\n          else\n              return mid\n      }\n      return not_found // value would be inserted at index \"low\"\n  }\n\n```\n\nLeftmost insertion point\n\nThe following algorithms return the leftmost place where the given element can be correctly inserted (and still maintain the sorted order). This is the lower (inclusive) bound of the range of elements that are equal to the given value (if any). Equivalently, this is the lowest index where the element is greater than or equal to the given value (since if it were any lower, it would violate the ordering), or 1 past the last index if such an element does not exist. This algorithm does not determine if the element is actually found. This algorithm only requires one comparison per level.\n\n**Recursive Pseudocode**:\n\n```\n  // initially called with low = 0, high = N - 1\n  BinarySearch_Left(A[0..N-1], value, low, high) {\n      // invariants: value > A[i] for all i < low\n                     value <= A[i] for all i > high\n      if (high < low)\n          return low\n      mid = (low + high) / 2\n      if (A[mid] >= value)\n          return BinarySearch_Left(A, value, low, mid-1)\n      else\n          return BinarySearch_Left(A, value, mid+1, high)\n  }\n\n```\n\n**Iterative Pseudocode**:\n\n```\n  BinarySearch_Left(A[0..N-1], value) {\n      low = 0\n      high = N - 1\n      while (low <= high) {\n          // invariants: value > A[i] for all i < low\n                         value <= A[i] for all i > high\n          mid = (low + high) / 2\n          if (A[mid] >= value)\n              high = mid - 1\n          else\n              low = mid + 1\n      }\n      return low\n  }\n\n```\n\nRightmost insertion point\n\nThe following algorithms return the rightmost place where the given element can be correctly inserted (and still maintain the sorted order). This is the upper (exclusive) bound of the range of elements that are equal to the given value (if any). Equivalently, this is the lowest index where the element is greater than the given value, or 1 past the last index if such an element does not exist. This algorithm does not determine if the element is actually found. This algorithm only requires one comparison per level. Note that these algorithms are almost exactly the same as the leftmost-insertion-point algorithms, except for how the inequality treats equal values.\n\n**Recursive Pseudocode**:\n\n```\n  // initially called with low = 0, high = N - 1\n  BinarySearch_Right(A[0..N-1], value, low, high) {\n      // invariants: value >= A[i] for all i < low\n                     value < A[i] for all i > high\n      if (high < low)\n          return low\n      mid = (low + high) / 2\n      if (A[mid] > value)\n          return BinarySearch_Right(A, value, low, mid-1)\n      else\n          return BinarySearch_Right(A, value, mid+1, high)\n  }\n\n```\n\n**Iterative Pseudocode**:\n\n```\n  BinarySearch_Right(A[0..N-1], value) {\n      low = 0\n      high = N - 1\n      while (low <= high) {\n          // invariants: value >= A[i] for all i < low\n                         value < A[i] for all i > high\n          mid = (low + high) / 2\n          if (A[mid] > value)\n              high = mid - 1\n          else\n              low = mid + 1\n      }\n      return low\n  }\n\n```\n\nExtra credit\n\nMake sure it does not have overflow bugs.\n\nThe line in the pseudo-code above to calculate the mean of two integers:\n\n```\nmid = (low + high) / 2\n```\n\ncould produce the wrong result in some programming languages when used with a bounded integer type, if the addition causes an overflow. (This can occur if the array size is greater than half the maximum integer value.) If signed integers are used, and `low + high` overflows, it becomes a negative number, and dividing by 2 will still result in a negative number. Indexing an array with a negative number could produce an out-of-bounds exception, or other undefined behavior. If unsigned integers are used, an overflow will result in losing the largest bit, which will produce the wrong result.\n\nOne way to fix it is to manually add half the range to the low number:\n\n```\nmid = low + (high - low) / 2\n```\n\nEven though this is mathematically equivalent to the above, it is not susceptible to overflow.\n\nAnother way for signed integers, possibly faster, is the following:\n\n```\nmid = (low + high) >>> 1\n```\n\nwhere  `>>>`  is the logical right shift operator. The reason why this works is that, for signed integers, even though it overflows, when viewed as an unsigned number, the value is still the correct sum. To divide an unsigned number by 2, simply do a logical right shift.\n\nRelated task\n:   * Guess the number/With Feedback (Player)\n\nSee also\n:   * wp:Binary search algorithm\n    * Extra, Extra - Read All About It: Nearly All Binary Searches and Mergesorts are Broken."}, {"role": "assistant", "content": "(formerly Perl 6)\nWith either of the below implementations of `binary_search`, one could write a function to search any object that does `Positional` this way:\n\n```\nsub search (@a, $x --> Int) {\n    binary_search { $x cmp @a[$^i] }, 0, @a.end\n}\n```\n\n**Iterative**\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub binary_search (&p, Int $lo is copy, Int $hi is copy --> Int) {\n    until $lo > $hi {\n        my Int $mid = ($lo + $hi) div 2;\n        given p $mid {\n            when -1 { $hi = $mid - 1; } \n            when  1 { $lo = $mid + 1; }\n            default { return $mid;    }\n        }\n    }\n    fail;\n}\n```\n\n**Recursive**\n\n**Translation of**: Haskell\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub binary_search (&p, Int $lo, Int $hi --> Int) {\n    $lo <= $hi or fail;\n    my Int $mid = ($lo + $hi) div 2;\n    given p $mid {\n        when -1 { binary_search &p, $lo,      $mid - 1 } \n        when  1 { binary_search &p, $mid + 1, $hi      }\n        default { $mid                                 }\n    }\n}\n```"}]}
{"messages": [{"role": "user", "content": "Many languages have powerful and useful (**binary safe**) string manipulation functions, while others don't, making it harder for these languages to accomplish some tasks.\n\nThis task is about creating functions to handle *binary* strings (strings made of arbitrary bytes, i.e. *byte strings* according to Wikipedia) for those languages that don't have built-in support for them.\n\nIf your language of choice does have this built-in support, show a possible alternative implementation for the *functions* or *abilities* already provided by the language.\n\nIn particular the functions you need to create are:\n\n* String creation and destruction (when needed and if there's no garbage collection or similar mechanism)\n* String assignment\n* String comparison\n* String cloning and copying\n* Check if a string is empty\n* Append a byte to a string\n* Extract a substring from a string\n* Replace every occurrence of a byte (or a string) in a string with another string\n* Join strings\n\nPossible contexts of use: compression algorithms (like LZW compression), L-systems (manipulation of symbols), many more."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n```\n# Raku is perfectly fine with NUL *characters* in strings:\nmy Str $s = 'nema' ~ 0.chr ~ 'problema!';\nsay $s;\n\n# However, Raku makes a clear distinction between strings\n# (i.e. sequences of characters), like your name, or …\nmy Str $str = \"My God, it's full of chars!\";\n# … and sequences of bytes (called Bufs), for example a PNG image, or …\nmy Buf $buf = Buf.new(255, 0, 1, 2, 3);\nsay $buf;\n\n# Strs can be encoded into Blobs …\nmy Blob $this = 'round-trip'.encode('ascii');\n# … and Blobs can be decoded into Strs …\nmy Str $that = $this.decode('ascii');\n\n# So it's all there. Nevertheless, let's solve this task explicitly\n# in order to see some nice language features:\n\n# We define a class …\nclass ByteStr {\n    # … that keeps an array of bytes, and we delegate some\n    # straight-forward stuff directly to this attribute:\n    # (Note: \"has byte @.bytes\" would be nicer, but that is\n    # not yet implemented in Rakudo.)\n    has Int @.bytes handles(< Bool elems gist push >);\n\n    # A handful of methods …\n    method clone() {\n        self.new(:@.bytes);\n    }\n\n    method substr(Int $pos, Int $length) {\n        self.new(:bytes(@.bytes[$pos .. $pos + $length - 1]));\n    }\n\n    method replace(*@substitutions) {\n        my %h = @substitutions;\n        @.bytes.=map: { %h{$_} // $_ }\n    }\n}\n\n# A couple of operators for our new type:\nmulti infix:<cmp>(ByteStr $x, ByteStr $y) { $x.bytes.join cmp $y.bytes.join }\nmulti infix:<~>  (ByteStr $x, ByteStr $y) { ByteStr.new(:bytes(|$x.bytes, |$y.bytes)) }\n\n# create some byte strings (destruction not needed due to garbage collection)\nmy ByteStr $b0 = ByteStr.new;\nmy ByteStr $b1 = ByteStr.new(:bytes( |'foo'.ords, 0, 10, |'bar'.ords ));\n\n# assignment ($b1 and $b2 contain the same ByteStr object afterwards):\nmy ByteStr $b2 = $b1;\n\n# comparing:\nsay 'b0 cmp b1 = ', $b0 cmp $b1;\nsay 'b1 cmp b2 = ', $b1 cmp $b2;\n\n# cloning:\nmy $clone = $b1.clone;\n$b1.replace('o'.ord => 0);\nsay 'b1 = ', $b1;\nsay 'b2 = ', $b2;\nsay 'clone = ', $clone;\n\n# to check for (non-)emptiness we evaluate the ByteStr in boolean context:\nsay 'b0 is ', $b0 ?? 'not empty' !! 'empty';\nsay 'b1 is ', $b1 ?? 'not empty' !! 'empty';\n\n# appending a byte:\n$b1.push: 123;\nsay 'appended = ', $b1;\n\n# extracting a substring:\nmy $sub = $b1.substr(2, 4);\nsay 'substr = ', $sub;\n\n# replacing a byte:\n$b2.replace(102 => 103);\nsay 'replaced = ', $b2;\n\n# joining:\nmy ByteStr $b3 = $b1 ~ $sub;\nsay 'joined = ', $b3;\n```\n\nOutput:\n\nNote: The ␀ represents a NUL byte.\n\n```\nnema␀problema!\nBuf:0x<ff 00 01 02 03>\nround-trip\nb0 cmp b1 = Less\nb1 cmp b2 = Same\nb1 = [102 0 0 0 10 98 97 114]\nb2 = [102 0 0 0 10 98 97 114]\nclone = [102 111 111 0 10 98 97 114]\nb0 is empty\nb1 is not empty\nappended = [102 0 0 0 10 98 97 114 123]\nsubstr = [0 0 10 98]\nreplaced = [103 0 0 0 10 98 97 114 123]\njoined = [103 0 0 0 10 98 97 114 123 0 0 10 98]\n```"}]}
{"messages": [{"role": "user", "content": "The binomial transform is a bijective sequence transform based on convolution with binomial coefficients.\n\nIt may be thought of as an *nth* forward difference with odd differences carrying a negative sign.\n\nThere are two common variants of binomial transforms, one of which is self-inverting; *reapplying the transform to a transformed sequence returns the original sequence,* and one which has separate \"forward\" and \"inverse\" transform operations.\n\nThe two variants only differ in placement and quantity of signs. The variant standardized on by OEIS, *with the 'forward' and 'inverse' complementary operations*, will be used here.\n\nIn this variant, to transform the sequence *a* to sequence *b* and back:\n\nthe forward binomial transform is defined as: \n\nb\n\nn\n=\n\n∑\n\nk\n=\n0\n\nn\n\n(\n\nn\nk\n\n)\n\na\n\nk\n.\n{\\displaystyle {\\displaystyle b\\_{n}=\\sum \\_{k=0}^{n}{n \\choose k}a\\_{k}.}}\n\nand the inverse binomial transform is defined as: \n\na\n\nn\n=\n\n∑\n\nk\n=\n0\n\nn\n(\n−\n1\n\n)\n\nn\n−\nk\n\n(\n\nn\nk\n\n)\n\nb\n\nk\n{\\displaystyle {\\displaystyle a\\_{n}=\\sum \\_{k=0}^{n}(-1)^{n-k}{n \\choose k}b\\_{k}}}\n\nwhere \n\n(\n\nn\nk\n\n)\n{\\displaystyle {\\displaystyle {n \\choose k}}}\n is the binomial operator 'n choose k'\n\n*For reference, the self inverting binomial transform is defined as:* \n\nb\n\nn\n=\n\n∑\n\nk\n=\n0\n\nn\n(\n−\n1\n\n)\n\nk\n\n(\n\nn\nk\n\n)\n\na\n\nk\n{\\displaystyle {\\displaystyle b\\_{n}=\\sum \\_{k=0}^{n}(-1)^{k}{n \\choose k}a\\_{k}}}\n\nTask\n\n* Implement both a forward, and inverse binomial transform routine.\n* Use those routines to compute the forward binomial transform, the inverse binomial transform, and the inverse of the forward transform *(should return original sequence)* of a few representative sequences.\n* Show at least the first 15 values in each sequence.\n\n:   *You may generate the sequences, or may choose to just hard code the values.*\n\n:   Use the following sequences for testing:\n\n    :   Catalan numbers: `1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440`\n    :   Prime flip flop sequence: (for an: 1 if prime, 0 otherwise): `0 1 1 0 1 0 1 0 0 0 1 0 1 0 0`\n    :   Fibonacci sequence: `0 1 1 2 3 5 8 13 21 34 55 89 144 233 377`\n    :   Padovan sequence: (starting with values 1,0,0): `1 0 0 1 0 1 1 1 2 2 3 4 5 7 9`\n\nSee also\n\n* Wikipedia: Binomial transform * OEIS wiki: Binomial transform * Related task: Evaluate binomial coefficients * Related task: Catalan numbers * Related task: Riordan numbers * Related task: Fibonacci sequence * Related task: Padovan sequence\n\n:   *first sequence*\n\n* OEIS:A007317 - Binomial transform of Catalan numbers * OEIS:A005043 - Riordan numbers (Inverse binomial transform of Catalan numbers)\n\n:   *second sequence*\n\n* OEIS:A052467 - Binomial transform of {b(n)}, where b(n)=1 for prime n and b(n)=0 otherwise (Binomial transform of Prime flip-flop sequence\n\n:   *third sequence*\n\n* OEIS:A001906 - F(2n) = bisection of Fibonacci sequence (Binomial transform of Fibonacci sequence) * OEIS:A039834 - a(n+2) = -a(n+1) + a(n) (signed Fibonacci numbers) with a(-2) = a(-1) = 1 (Inverse binomial transform of Fibonacci sequence)\n\n:   *fourth sequence*\n\n* OEIS:A034943 - Binomial transform of Padovan sequence * OEIS:A144413 - a(n) = Sum\\_{k=0..n} (-1)^k \\* binomial(n, k) \\* A000931(n-k+4) (Inverse binomial transform of Padovan sequence)"}, {"role": "assistant", "content": "Generates the sequences on the fly.\n\n```\nsub binomial { [×] ($^n … 0) Z/ 1 .. $^p }\n\nsub binomial-transform (*@seq) {\n    @seq.keys.map: -> \\n { sum (0..n).map: -> \\k { binomial(n,k) × @seq[k] } }\n}\n\nsub inverse-binomial-transform (*@seq) {\n    @seq.keys.map: -> \\n { sum (0..n).map: -> \\k { binomial(n,k) × @seq[k] × exp(n - k, -1) } }\n}\n\nsub si-binomial-transform (*@seq) { #self inverting\n    @seq.keys.map: -> \\n { sum (0..n).map: -> \\k { binomial(n,k) × @seq[k] × exp(k, -1) } }\n}\n\nmy $upto = 20;\n\nfor 'Catalan number',   (1, {[+] @_ Z× @_.reverse}…*),\n    'Prime flip-flop',  (1..*).map({.is-prime ?? 1 !! 0}),\n    'Fibonacci number', (0,1,*+*…*),\n    'Padovan number',   (1,0,0, -> $c,$b,$ {$b+$c}…*)\n  -> $name, @seq {\n    say qq:to/BIN/;\n    $name sequence:\n    {@seq[^$upto]}\n    Forward binomial transform:\n    {binomial-transform(@seq)[^$upto]}\n    Inverse binomial transform:\n    {inverse-binomial-transform(@seq)[^$upto]}\n    Round trip:\n    {inverse-binomial-transform(binomial-transform(@seq))[^$upto]}\n    Self inverting:\n    {si-binomial-transform(@seq)[^$upto]}\n    Re inverted:\n    {si-binomial-transform(si-binomial-transform(@seq))[^$upto]}\n    BIN\n}\n\n```\n\nOutput:\n\n```\nCatalan number sequence:\n1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190\nForward binomial transform:\n1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 1777495635 8140539950 37463689775 173164232965\nInverse binomial transform:\n1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 227475 625992 1730787 4805595\nRound trip:\n1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190\nSelf inverting:\n1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 227475 -625992 1730787 -4805595\nRe inverted:\n1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190\n\nPrime flip-flop sequence:\n0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0\nForward binomial transform:\n0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952\nInverse binomial transform:\n0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914\nRound trip:\n0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0\nSelf inverting:\n0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914\nRe inverted:\n0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0\n\nFibonacci number sequence:\n0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181\nForward binomial transform:\n0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169\nInverse binomial transform:\n0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181\nRound trip:\n0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181\nSelf inverting:\n0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181\nRe inverted:\n0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181\n\nPadovan number sequence:\n1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37\nForward binomial transform:\n1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192\nInverse binomial transform:\n1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926\nRound trip:\n1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37\nSelf inverting:\n1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926\nRe inverted:\n1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Given this string representing ordered DNA bases:\n\n```\nCGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG\nCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG\nAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT\nGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT\nCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG\nTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA\nTTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT\nCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG\nTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC\nGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT\n\n```\n\nTask\n:   * \"Pretty print\" the sequence followed by a summary of the counts of each of the bases:   (**A**, **C**, **G**, and **T**)   in the sequence\n    * print the total count of each base in the string.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nIt's the Letter frequency task all over again, just simpler and dressed up in different clothes.\n\nThe specs for what \"pretty print\" means are sadly lacking. Ah well, just makes it easily defensible if I do *anything at all*.\n\n```\nmy $dna = join '', lines q:to/END/;\n    CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG\n    CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG\n    AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT\n    GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT\n    CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG\n    TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA\n    TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT\n    CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG\n    TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC\n    GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT\n    END\n\n\nput pretty($dna, 80);\nput \"\\nTotal bases: \", +my $bases = $dna.comb.Bag;\nput $bases.sort(~*.key).join: \"\\n\";\n\nsub pretty ($string, $wrap = 50) {\n    $string.comb($wrap).map( { sprintf \"%8d: %s\", $++ * $wrap, $_ } ).join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\n       0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCG\n      80: AGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTC\n     160: GTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGT\n     240: TCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCG\n     320: ATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG\n     400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTT\n     480: TGTTAAACTACGAACGTAAT\n\nTotal bases: 500\nA\t129\nC\t97\nG\t119\nT\t155\n```"}]}
{"messages": [{"role": "user", "content": "Global alignment is designed to search for highly similar regions in two or more DNA sequences, where the\nsequences appear in the same order and orientation, fitting the sequences in as pieces in a puzzle.\n\nCurrent DNA sequencers find the sequence for multiple small segments of DNA which have mostly randomly formed by splitting a much larger DNA molecule into shorter segments. When re-assembling such segments of DNA sequences into a larger sequence to form, for example, the DNA coding for the relevant gene, the overlaps between multiple shorter sequences are commonly used to decide how the longer sequence is to be assembled. For example, \"AAGATGGA\", GGAGCGCATC\", and \"ATCGCAATAAGGA\" can be assembled into the sequence \"AAGATGGAGCGCATCGCAATAAGGA\" by noting that \"GGA\" is at the tail of the first string and head of the second string and \"ATC\" likewise is at the tail\nof the second and head of the third string.\n\nWhen looking for the best global alignment in the output strings produced by DNA sequences, there are\ntypically a large number of such overlaps among a large number of sequences. In such a case, the ordering\nthat results in the shortest common superstring is generrally preferred.\n\nFinding such a supersequence is an NP-hard problem, and many algorithms have been proposed to\nshorten calculations, especially when many very long sequences are matched.\n\nThe shortest common superstring as used in bioinfomatics here differs from the string task\nShortest\\_common\\_supersequence. In that task, a supersequence\nmay have other characters interposed as long as the characters of each subsequence appear in order,\nso that (abcbdab, abdcaba) -> abdcabdab. In this task, (abcbdab, abdcaba) -> abcbdabdcaba.\n\nTask\n:   * Given N non-identical strings of characters A, C, G, and T representing N DNA sequences, find the shortest DNA sequence containing all N sequences.\n\n:   * Handle cases where two sequences are identical or one sequence is entirely contained in another.\n\n:   * Print the resulting sequence along with its size (its base count) and a count of each base in the sequence.\n\n:   * Find the shortest common superstring for the following four examples:\n\n```\n(\"TA\", \"AAG\", \"TA\", \"GAA\", \"TA\")\n\n```\n\n```\n(\"CATTAGGG\", \"ATTAG\", \"GGG\", \"TA\")\n\n```\n\n```\n(\"AAGAUGGA\", \"GGAGCGCAUC\", \"AUCGCAAUAAGGA\")\n\n```\n\n```\n(\"ATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTAT\",\n\"GGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGT\",\n\"CTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA\",\n\"TGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATC\",\n\"AACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT\",\n\"GCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTC\",\n\"CGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCT\",\n\"TGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATC\",\n\"CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGC\",\n\"GATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATT\",\n\"TTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATC\",\n\"CTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA\",\n\"TCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGA\")\n\n```\n\nRelated tasks\n:   * Bioinformatics base count.\n    * Bioinformatics sequence mutation."}, {"role": "assistant", "content": "**Translation of**: Go\n\n**Translation of**: Julia\n\n```\n# 20210209 Raku programming solution\n\nsub printCounts(\\seq) {\n   my $bases = seq.comb.Bag ;\n   say \"\\nNucleotide counts for \", seq, \" :\";\n   say $bases.kv, \" and total length = \", $bases.total\n}\n\nsub stringCentipede(\\s1, \\s2) {\n   loop ( my $offset = 0, my \\S1 = $ = '' ; ; $offset++ ) {\n      S1 = s1.substr: $offset ;\n      with S1.index(s2.substr(0,1)) -> $p { $offset += $p } else { return False }\n      return s1.chars - $offset if s2.starts-with: s1.substr: $offset\n   }\n}\n\nsub deduplicate {\n   my @sorted = @_.unique.sort: *.chars; # by length   \n   gather while ( my $target = shift @sorted ) {\n      take $target unless @sorted.grep: { .contains: $target }  \n   }\n}\n\nsub shortestCommonSuperstring {\n   my \\ß = $ = [~] my @ss = deduplicate @_ ;           # ShortestSuper\n   for @ss.permutations -> @perm {\n      my \\sup = $ = @perm[0];\n      for @perm.rotor(2 => -1) { sup ~= @_[1].substr: stringCentipede |@_ }\n      ß = sup if sup.chars < ß.chars ;\n   }\n   ß\n}\n\n.&shortestCommonSuperstring.&printCounts for ( \n\n   <TA AAG TA GAA TA>,\n\n   <CATTAGGG ATTAG GGG TA>,\n\n   <AAGAUGGA GGAGCGCAUC AUCGCAAUAAGGA> ,\n\n   <ATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTAT \n    GGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGT\n    CTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA\n    TGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATC\n    AACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT\n    GCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTC\n    CGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCT\n    TGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATC\n    CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGC\n    GATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATT\n    TTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATC\n    CTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA\n    TCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGA\n   >,\n)\n\n```\n\nOutput:\n\n```\n\n\nNucleotide counts for TAAGAA :\n(T 1 A 4 G 1) and total length = 6\n\nNucleotide counts for CATTAGGG :\n(G 3 A 2 T 2 C 1) and total length = 8\n\nNucleotide counts for AAGAUGGAGCGCAUCGCAAUAAGGA :\n(A 10 U 3 C 4 G 8) and total length = 25\n\nNucleotide counts for CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA :\n(C 57 G 75 A 74 T 94) and total length = 300\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a string of characters A, C, G, and T representing a DNA sequence write a routine to mutate the sequence, (string) by:\n\n1. Choosing a random base position in the sequence.\n2. Mutate the sequence by doing one of either:\n   1. **S**wap the base at that position by changing it to one of A, C, G, or T. (which has a chance of swapping the base for the same base)\n   2. **D**elete the chosen base at the position.\n   3. **I**nsert another base randomly chosen from A,C, G, or T into the sequence at that position.\n3. Randomly generate a test DNA sequence of at least 200 bases\n4. \"Pretty print\" the sequence and a count of its size, and the count of each base in the sequence\n5. Mutate the sequence ten times.\n6. \"Pretty print\" the sequence after all mutations, and a count of its size, and the count of each base in the sequence.\n\nExtra credit\n\n* Give more information on the individual mutations applied.\n* Allow mutations to be weighted and/or chosen."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nUnweighted mutations at this point. The mutated DNA strand has a \"diff\" operation performed on it which (in this specific case) renders the mutated base in lower case so it may be picked out more easily.\n\n```\nmy @bases = <A C G T>;\n\n# The DNA strand\nmy $dna = @bases.roll(200).join;\n\n\n# The Task\nput \"ORIGINAL DNA STRAND:\";\nput pretty $dna;\nput \"\\nTotal bases: \", +my $bases = $dna.comb.Bag;\nput $bases.sort( ~*.key ).join: \"\\n\";\n\nput \"\\nMUTATED DNA STRAND:\";\nmy $mutate = $dna.&mutate(10);\nput pretty diff $dna, $mutate;\nput \"\\nTotal bases: \", +my $mutated = $mutate.comb.Bag;\nput $mutated.sort( ~*.key ).join: \"\\n\";\n\n\n# Helper subs\nsub pretty ($string, $wrap = 50) {\n    $string.comb($wrap).map( { sprintf \"%8d: %s\", $++ * $wrap, $_ } ).join: \"\\n\"\n}\n\nsub mutate ($dna is copy, $count = 1) {\n    $dna.substr-rw((^$dna.chars).roll, 1) = @bases.roll for ^$count;\n    $dna\n}\n\nsub diff ($orig, $repl) {\n    ($orig.comb Z $repl.comb).map( -> ($o, $r) { $o eq $r ?? $o !! $r.lc }).join\n}\n\n```\n\nOutput:\n\n```\nORIGINAL DNA STRAND:\n       0: ACGGATAGACCGTTCCTGCAAGCTGGTACGGTTCGAATGTTGACCTTATT\n      50: CTCCGCAGCGCACTACCCGATCGGGTAACGTACTCTATATGATGCCTATT\n     100: TTCCCCGCCTTACATCGGCGATCAATGTTCTTTTACGCTAACTAGGCGCA\n     150: CGTCGTGCCTTACCGAGAGCCAGTTCGAAATCGTGCTGAAAATATCTGGA\n\nTotal bases: 200\nA\t45\nC\t55\nG\t45\nT\t55\n\nMUTATED DNA STRAND:\n       0: ACGGATAGcCCGTTCCTGCAAGCTGGTACGGTTCGAATGTTGACCTTATT\n      50: CTCCGCAGCGCACTACCCGATCGGGTcACtcACTCTATATGAcGCCTAaT\n     100: TTCCCCGCCTTACATCGGCGATCAATGTTCTTTTACGCTAACTAGGCGCA\n     150: CGTCGTGCCTTACCcAGAGCCAGTTCGAAATCGTGCTGAAAATATCTGGA\n\nTotal bases: 200\nA\t44\nC\t60\nG\t43\nT\t53\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nRandomly generate a string of   **200**   DNA bases   (represented by   **A,  C,  G,**  and  **T**).\n\nWrite a routine to find all the positions of a randomly generated subsequence   (four letters)."}, {"role": "assistant", "content": "Chances are actually pretty small that a random 4 codon string will show up at all in a random 200 codon sequence. Bump up the sequence size to get a reasonable chance of multiple matches.\n\n```\nuse String::Splice:ver<0.0.3+>;\n\nmy $line = 80;\n\nmy $haystack = [~] <A C G T>.roll($line * 8);\n\nsay 'Needle: ' ~ my $needle = [~] <A C G T>.roll(4);\n\nmy $these = $haystack ~~ m:g/<$needle>/;\n\nmy @match = $these.map: { .from, .pos }\n\nprintf \"From: %3s to %3s\\n\", |$_ for @match;\n\nmy $disp = $haystack.comb.batch($line)».join.join(\"\\n\");\n\nfor @match.reverse {\n    $disp.=&splice(.[1] + .[1] div $line, \"\\e[0m\" );\n    $disp.=&splice(.[0] + .[0] div $line, \"\\e[31m\");\n}\n\nsay $disp;\n\n```\n\nOutput:\n\nShow in custom div to better display highlighting.\n\nNeedle: TAGC  \nFrom: 159 to 163  \nFrom: 262 to 266  \nFrom: 315 to 319  \nFrom: 505 to 509  \nFrom: 632 to 636  \nCATATGTGACACTGACAGCTCGCGCGAAAATCCGTGTGACGGTCTGAACACTATACTATAGGCCCGGTCGGCATTTGTGG  \nCTCCCCAGTGGAGAGACCACTCGTCAATTGCTGACGACTTAACACAAATCGAGTCGCCCTTAGTGCCAGACGGGACTCCT  \nAGCAAAGGGCGGCACGTGGTGACTCCCAATATGTGAGCATGCCATCTAATTGATCTGGGGGGTTTCGCGGGAATACCTAG  \nGGGCGTTCTGTCCATGGATCTCTAGCCCTGCGAAGAGATACCCGCAGTGAGTTGCACGTGCAAAGAACTTGTAACTAGCG  \nTATTCTGTATCCGCCGCGCGATATGCTTCTGCGGGATGTACTTCTTGTGACTAAGACTTTGTTATCCAAATTGACCAATA  \nTTCAACGGTCGACTCTCCGAGGCAGTATCGGTACGCCGAAAAATGGTTACTTCGGCCATACGTAACCTCTCAAGTCACGA  \nTTACAGCCCACGGGGGCTTACAGCATAGCTCCAAAGACATTCCAATTGAGCTACAACGTGTTCAGTGCGGAGCAGTATCC  \nAGTACTCGACTGTTATGGTAAAAGGGCATCGTGATCGTTTATATTAATCATTGGGACAGGTGGTTAATGTCATAGCTTAG"}]}
{"messages": [{"role": "user", "content": "For a while in the late 70s, the pseudoscience of biorhythms was popular enough to rival astrology, with kiosks in malls that would give you your weekly printout. It was also a popular entry in \"Things to Do with your Pocket Calculator\" lists. You can read up on the history at Wikipedia, but the main takeaway is that unlike astrology, the math behind biorhythms is dead simple.\n\nIt's based on the number of days since your birth. The premise is that three cycles of unspecified provenance govern certain aspects of everyone's lives – specifically, how they're feeling physically, emotionally, and mentally. The best part is that not only do these cycles somehow have the same respective lengths for all humans of any age, gender, weight, genetic background, etc, but those lengths are an exact number of days. And the pattern is in each case a perfect sine curve. Absolutely miraculous!\n\nTo compute your biorhythmic profile for a given day, the first thing you need is the number of days between that day and your birth, so the answers in Days between dates are probably a good starting point. (Strictly speaking, the biorhythms start at 0 at the moment of your birth, so if you know time of day you can narrow things down further, but in general these operate at whole-day granularity.) Then take the residue of that day count modulo each of the the cycle lengths to calculate where the day falls on each of the three sinusoidal journeys.\n\nThe three cycles and their lengths are as follows:\n\n:   :   :   | Cycle | Length |\n            | --- | --- |\n            | Physical | 23 days |\n            | Emotional | 28 days |\n            | Mental | 33 days |\n\nThe first half of each cycle is in \"plus\" territory, with a peak at the quarter-way point; the second half in \"minus\" territory, with a valley at the three-quarters mark. You can calculate a specific value between -1 and +1 for the *k*th day of an *n*-day cycle by computing **sin( 2π*k* / *n* )**. The days where a cycle crosses the axis in either direction are called \"critical\" days, although with a cycle value of 0 they're also said to be the most neutral, which seems contradictory.\n\nThe task: write a subroutine, function, or program that will, given a birthdate and a target date, output the three biorhythmic values for the day. You may optionally include a text description of the position and the trend (e.g. \"up and rising\", \"peak\", \"up but falling\", \"critical\", \"down and falling\", \"valley\", \"down but rising\"), an indication of the date on which the next notable event (peak, valley, or crossing) falls, or even a graph of the cycles around the target date. Demonstrate the functionality for dates of your choice.\n\nExample run of my Raku implementation:\n\n```\nraku br.raku 1943-03-09 1972-07-11\n\n```\n\nOutput:\n\n```\nDay 10717:\nPhysical day 22: -27% (down but rising, next transition 1972-07-12)\nEmotional day 21: valley\nMental day 25: valley\n\n```\n\nDouble valley! This was apparently not a good day for Mr. Fischer to begin a chess tournament..."}, {"role": "assistant", "content": "```\n#!/usr/bin/env raku\nunit sub MAIN($birthday=%*ENV<BIRTHDAY>, $date = Date.today()) {\n\nmy %cycles = ( :23Physical, :28Emotional, :33Mental );\nmy @quadrants = [ ('up and rising',    'peak'),\n                  ('up but falling',   'transition'),\n                  ('down and falling', 'valley'),\n                  ('down but rising',  'transition') ];\n\nif !$birthday {\n    die \"Birthday not specified.\\n\" ~\n        \"Supply --birthday option or set \\$BIRTHDAY in environment.\\n\";\n}\n\nmy ($bday, $target) = ($birthday, $date).map: { Date.new($_) };\nmy $days = $target - $bday;\n\nsay \"Day $days:\";\nfor %cycles.sort(+*.value)».kv -> ($label, $length) {\n    my $position = $days % $length;\n    my $quadrant = floor($position / $length * 4);\n    my $percentage = floor(sin($position / $length * 2 * π )*1000)/10;\n    my $description;\n    if $percentage > 95 {\n        $description = 'peak';\n    } elsif $percentage < -95 {\n        $description = 'valley'; \n    } elsif abs($percentage) < 5 {\n        $description = 'critical transition'\n    } else {\n        my $transition = $target + floor(($quadrant + 1)/4 * $length) - $position;\n        my ($trend, $next) = @quadrants[$quadrant];\n        $description = \"$percentage% ($trend, next $next $transition)\";\n    }\n    say \"$label day $position: $description\";\n  }\n}\n\n```\n\nOutput:\n\n```\n$ br 1809-01-12 1863-11-19\nDay 20034:\nPhysical day 1: 26.9% (up and rising, next peak 1863-11-23)\nEmotional day 14: critical transition\nMental day 3: 54% (up and rising, next peak 1863-11-24)\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The current wikipedia article is at Birthday Problem. The original RosettaCode article was extracted from the wikipedia article № 296054030 of 21:44, 12 June 2009 . The list of authors can be seen in the page history. As with Rosetta Code, the pre **5 June 2009** text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn probability theory, the **birthday problem**, or **birthday paradox** This is not a paradox in the sense of leading to a logical contradiction, but is called a paradox because the mathematical truth contradicts naïve intuition: most people estimate that the chance is much lower than 50%. pertains to the probability that in a set of randomly chosen people some pair of them will have the same birthday. In a group of at least 23 randomly chosen people, there is more than 50% probability that some pair of them will both have been born on the same day. For 57 or more people, the probability is more than 99%, and it reaches 100% when the number of people reaches 366 (by the pigeon hole principle, ignoring leap years). The mathematics behind this problem leads to a well-known cryptographic attack called the birthday attack.\n\nTask\n\nUsing simulation, estimate the number of independent people required in a group before we can expect a *better than even chance* that at least 2 independent people in a group share a common birthday. Furthermore: Simulate and thus estimate when we can expect a *better than even chance* that at least 3, 4 & 5 independent people of the group share a common birthday. For simplicity assume that all of the people are alive...\n\nSuggestions for improvement\n\n* Estimating the error in the estimate to help ensure the estimate is accurate to 4 decimal places.\n* Converging to the \n\n  n\n  {\\displaystyle {\\displaystyle n}}\n  th solution using a root finding method, as opposed to using an extensive search.\n* Kudos (κῦδος) for finding the solution by proof (in a programming language) rather than by construction and simulation.\n\nSee also\n\n* Wolfram entry:   Birthday Problem"}, {"role": "assistant", "content": "(formerly Perl 6)\nGives correct answers, but more of a proof-of-concept at this point, even with max-trials at 250K it is too slow to be practical.\n\n```\nsub simulation ($c) {\n    my $max-trials = 250_000;\n    my $min-trials =   5_000;\n    my $n = floor 47 * ($c-1.5)**1.5; # OEIS/A050256: 16 86 185 307\n    my $N = min $max-trials, max $min-trials, 1000 * sqrt $n;\n\n    loop {\n        my $p = $N R/ elems grep { .elems > 0 }, ((grep { $_>=$c }, values bag (^365).roll($n)) xx $N);\n        return($n, $p) if $p > 0.5;\n        $N = min $max-trials, max $min-trials, floor 1000/(0.5-$p);\n        $n++;\n   }\n}\n\nprintf \"$_ people in a group of %s share a common birthday. (%.3f)\\n\", simulation($_) for 2..5;\n\n```\n\nOutput:\n\n```\n2 people in a group of 23 share a common birthday. (0.506)\n3 people in a group of 88 share a common birthday. (0.511)\n4 people in a group of 187 share a common birthday. (0.500)\n5 people in a group of 313 share a common birthday. (0.507)\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| **Warning:** Many of these snippets are incomplete. It is recommended that you use an established library for any projects that are likely to see external use |\n\nTask\n\nWrite a program that takes a bitcoin address as argument,\nand checks whether or not this address is valid.\n\nA bitcoin address uses a base58 encoding, which uses an alphabet of the characters 0 .. 9, A ..Z, a .. z, but without the four characters:\n\n:   :   :   * 0   zero\n            * O   uppercase oh\n            * I   uppercase eye\n            * l   lowercase ell\n\nWith this encoding, a bitcoin address encodes 25 bytes:\n\n* the first byte is the version number, which will be zero for this task ;\n* the next twenty bytes are a RIPEMD-160 digest, but you don't have to know that for this task: you can consider them a pure arbitrary data ;\n* the last four bytes are a checksum check. They are the first four bytes of a double SHA-256 digest of the previous 21 bytes.\n\nTo check the bitcoin address, you must read the first twenty-one bytes, compute the checksum, and check that it corresponds to the last four bytes.\n\nThe program can either return a boolean value or throw an exception when not valid.\n\nYou can use a digest library for SHA-256.\n\nExample of a bitcoin address\n\n```\n1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i\n\n```\n\nIt doesn't belong to anyone and is part of the test suite of the bitcoin software.\n  \nYou can change a few characters in this string and check that it'll fail the test."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub sha256(blob8 $b) returns blob8 {\n  given run <openssl dgst -sha256 -binary>, :in, :out, :bin {\n    .in.write: $b;\n    .in.close;\n    return .out.slurp;\n  }\n}\n\nmy $bitcoin-address = rx/\n    << <+alnum-[0IOl]> ** 26..* >>  # an address is at least 26 characters long\n    <?{\n        .subbuf(21, 4) eq sha256(sha256 .subbuf(0, 21)).subbuf(0, 4) given\n        blob8.new: <\n            1 2 3 4 5 6 7 8 9\n            A B C D E F G H   J K L M N   P Q R S T U V W X Y Z\n            a b c d e f g h i j k   m n o p q r s t u v w x y z\n        >.pairs.invert.hash{$/.comb}\n        .reduce(* * 58 + *)\n        .polymod(256 xx 24)\n        .reverse;\n    }>\n/;\n \nsay \"Here is a bitcoin address: 1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i\" ~~ $bitcoin-address;\n\n```\n\nOutput:\n\n```\n｢1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i｣\n```"}]}
{"messages": [{"role": "user", "content": "Bitcoin uses a specific encoding format to encode the digest of an elliptic curve public point into a short ASCII string. The purpose of this task is to perform such a conversion.\n\nThe encoding steps are:\n\n* take the X and Y coordinates of the given public point, and concatenate them in order to have a 64 byte-longed string ;\n* add one byte prefix equal to 4 (it is a convention for this way of encoding a public point) ;\n* compute the SHA-256 of this string ;\n* compute the RIPEMD-160 of this SHA-256 digest ;\n* compute the checksum of the concatenation of the version number digit (a single zero byte) and this RIPEMD-160 digest, as described in bitcoin/address validation ;\n* Base-58 encode (see below) the concatenation of the version number (zero in this case), the ripemd digest and the checksum\n\nThe base-58 encoding is based on an alphabet of alphanumeric characters (numbers, upper case and lower case, in that order) but without the four characters 0, O, l and I.\n\nHere is an example public point:\n\n```\nX = 0x50863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352\nY = 0x2CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6\n```\n\nThe corresponding address should be:\n16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM\n\nNb. The leading '1' is not significant as 1 is zero in base-58. It is however often added to the bitcoin address for various reasons. There can actually be several of them. You can ignore this and output an address without the leading 1.\n\n*Extra credit:* add a verification procedure about the public point, making sure it belongs to the secp256k1 elliptic curve"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub dgst(blob8 $b, Str :$dgst) returns blob8 {\n  given run «openssl dgst \"-$dgst\" -binary», :in, :out, :bin {\n    .in.write: $b;\n    .in.close;\n    return .out.slurp;\n  }\n}\nsub sha256($b) { dgst $b, :dgst<sha256> }\nsub rmd160($b) { dgst $b, :dgst<rmd160> }\n \nsub public_point_to_address( UInt $x, UInt $y ) {\n    my @bytes = flat ($y,$x).map: *.polymod( 256 xx * )[^32];\n    my $hash = rmd160 sha256 blob8.new: 4, @bytes.reverse;\n    my $checksum = sha256(sha256 blob8.new: 0, $hash.list).subbuf: 0, 4;\n    [R~] <\n        1 2 3 4 5 6 7 8 9\n      A B C D E F G H   J K L M N   P Q R S T U V W X Y Z\n      a b c d e f g h i j k   m n o p q r s t u v w x y z\n    >[ .polymod: 58 xx * ] given\n    reduce * * 256 + * , flat 0, ($hash, $checksum)».list \n}\n \nsay public_point_to_address\n  0x50863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352,\n  0x2CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6;\n\n```\n\nOutput:\n\n```\n6UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM\n```"}]}
{"messages": [{"role": "user", "content": "Show a basic storage type to handle a simple RGB raster graphics image,\nand some primitive associated functions.\n\nIf possible provide a function to allocate an uninitialised image,\ngiven its width and height, and provide 3 additional functions:\n\n:   :   * one to fill an image with a plain RGB color,\n        * one to set a given pixel with a color,\n        * one to get the color of a pixel.\n\n(If there are specificities about the storage or the allocation, explain those.)\n\n*These functions are used as a base for the articles in the category raster graphics operations,* \nand a basic output function to check the results\nis available in the article write ppm file."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nclass Pixel { has UInt ($.R, $.G, $.B) }\nclass Bitmap {\n    has UInt ($.width, $.height);\n    has Pixel @!data;\n\n    method fill(Pixel $p) {\n        @!data = $p.clone xx ($!width*$!height)\n    }\n    method pixel(\n\t$i where ^$!width,\n\t$j where ^$!height\n\t--> Pixel\n    ) is rw { @!data[$i + $j * $!width] }\n\n    method set-pixel ($i, $j, Pixel $p) {\n\tself.pixel($i, $j) = $p.clone;\n    }\n    method get-pixel ($i, $j) returns Pixel {\n\tself.pixel($i, $j);\n    }\n}\n\nmy Bitmap $b = Bitmap.new( width => 10, height => 10);\n\n$b.fill( Pixel.new( R => 0, G => 0, B => 200) );\n\n$b.set-pixel( 7, 5, Pixel.new( R => 100, G => 200, B => 0) );\n\nsay $b.perl;\n\n```\n\nThanks to the rw trait on the pixel method, we don't actually need to define two separate methods, set-pixel and get-pixel, but that is an explicit requirement of the task. (Beware your presuppositions! In Raku, accessors only determine identity, not use. In particular, identity is considered orthogonal to lvalue/rvalue context.)"}]}
{"messages": [{"role": "user", "content": "Task\n\nUsing the data storage type defined on the Bitmap page for raster graphics images,\n  \ndraw a line given two points with Bresenham's line algorithm."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nBitmap class from Bitmap task.\n\n```\nclass Pixel { has UInt ($.R, $.G, $.B) }\nclass Bitmap {\n    has UInt ($.width, $.height);\n    has Pixel @!data;\n \n    method fill(Pixel $p) {\n        @!data = $p.clone xx ($!width*$!height)\n    }\n    method pixel(\n\t$i where ^$!width,\n\t$j where ^$!height\n\t--> Pixel\n    ) is rw { @!data[$i + $j * $!width] }\n \n    method set-pixel ($i, $j, Pixel $p) {\n\tself.pixel($i, $j) = $p.clone;\n    }\n    method get-pixel ($i, $j) returns Pixel {\n\tself.pixel($i, $j);\n    }\n}\n \nsub line(Bitmap $bitmap, $x0 is copy, $x1 is copy, $y0 is copy, $y1 is copy) {\n    my $steep = abs($y1 - $y0) > abs($x1 - $x0);\n    if $steep {\n        ($x0, $y0) = ($y0, $x0);\n        ($x1, $y1) = ($y1, $x1);\n    } \n    if $x0 > $x1 {\n        ($x0, $x1) = ($x1, $x0);\n        ($y0, $y1) = ($y1, $y0);\n    }\n    my $Δx = $x1 - $x0;\n    my $Δy = abs($y1 - $y0);\n    my $error = 0;\n    my $Δerror = $Δy / $Δx;\n    my $y-step = $y0 < $y1 ?? 1 !! -1;\n    my $y = $y0;\n    for $x0 .. $x1 -> $x {\n        my $pix = Pixel.new(R => 100, G => 200, B => 0); \n        if $steep {\n            $bitmap.set-pixel($y, $x, $pix);\n        } else {\n            $bitmap.set-pixel($x, $y, $pix);\n        } \n        $error += $Δerror;\n        if $error >= 0.5 {\n            $y += $y-step;\n            $error -= 1.0;\n        } \n    } \n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Using the data storage type defined on this page for raster images, and the draw\\_line function defined in this other one, draw a **cubic bezier curve**\n(definition on Wikipedia)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nUses pieces from Bitmap, and Bresenham's line algorithm tasks. They are included here to make a complete, runnable program.\n\n```\nclass Pixel { has UInt ($.R, $.G, $.B) }\nclass Bitmap {\n    has UInt ($.width, $.height);\n    has Pixel @!data;\n\n    method fill(Pixel $p) {\n        @!data = $p.clone xx ($!width*$!height)\n    }\n    method pixel(\n\t  $i where ^$!width,\n\t  $j where ^$!height\n\t  --> Pixel\n    ) is rw { @!data[$i + $j * $!width] }\n\n    method set-pixel ($i, $j, Pixel $p) {\n        self.pixel($i, $j) = $p.clone;\n    }\n    method get-pixel ($i, $j) returns Pixel {\n\t    self.pixel($i, $j);\n    }\n\n    method line(($x0 is copy, $y0 is copy), ($x1 is copy, $y1 is copy), $pix) {\n        my $steep = abs($y1 - $y0) > abs($x1 - $x0);\n        if $steep {\n            ($x0, $y0) = ($y0, $x0);\n            ($x1, $y1) = ($y1, $x1);\n        }\n        if $x0 > $x1 {\n            ($x0, $x1) = ($x1, $x0);\n            ($y0, $y1) = ($y1, $y0);\n        }\n        my $Δx = $x1 - $x0;\n        my $Δy = abs($y1 - $y0);\n        my $error = 0;\n        my $Δerror = $Δy / $Δx;\n        my $y-step = $y0 < $y1 ?? 1 !! -1;\n        my $y = $y0;\n        for $x0 .. $x1 -> $x {\n            if $steep {\n                self.set-pixel($y, $x, $pix);\n            } else {\n                self.set-pixel($x, $y, $pix);\n            }\n            $error += $Δerror;\n            if $error >= 0.5 {\n                $y += $y-step;\n                $error -= 1.0;\n            }\n        }\n    }\n\n    method dot (($px, $py), $pix, $radius = 2) {\n        for $px - $radius .. $px + $radius -> $x {\n            for $py - $radius .. $py + $radius -> $y {\n                self.set-pixel($x, $y, $pix) if ( $px - $x + ($py - $y) * i ).abs <= $radius;\n            }\n        }\n    }\n\n    method cubic ( ($x1, $y1), ($x2, $y2), ($x3, $y3), ($x4, $y4), $pix, $segments = 30 ) {\n        my @line-segments = map -> $t {\n            my \\a = (1-$t)³;\n            my \\b = $t  * (1-$t)² * 3;\n            my \\c = $t² * (1-$t)  * 3;\n            my \\d = $t³;\n            (a*$x1 + b*$x2 + c*$x3 + d*$x4).round(1),(a*$y1 + b*$y2 + c*$y3 + d*$y4).round(1)\n        }, (0, 1/$segments, 2/$segments ... 1);\n        for @line-segments.rotor(2=>-1) -> ($p1, $p2) { self.line( $p1, $p2, $pix) };\n    }\n\n    method data { @!data }\n}\n\nrole PPM {\n    method P6 returns Blob {\n\t\"P6\\n{self.width} {self.height}\\n255\\n\".encode('ascii')\n\t~ Blob.new: flat map { .R, .G, .B }, self.data\n    }\n}\n\nsub color( $r, $g, $b) { Pixel.new(R => $r, G => $g, B => $b) }\n\nmy Bitmap $b = Bitmap.new( width => 600, height => 400) but PPM;\n\n$b.fill( color(2,2,2) );\n\nmy @points = (85,390), (5,5), (580,370), (270,10);\n\nmy %seen;\nmy $c = 0;\nfor @points.permutations -> @this {\n    %seen{@this.reverse.join.Str}++;\n    next if %seen{@this.join.Str};\n    $b.cubic( |@this, color(255-$c,127,$c+=22) );\n}\n\n@points.map: { $b.dot( $_, color(255,0,0), 3 )}\n\n$*OUT.write: $b.P6;\n\n```\n\nSee example image here, (converted to a .png as .ppm format is not widely supported)."}]}
{"messages": [{"role": "user", "content": "Using the data storage type defined on this page for raster images, and the draw\\_line function defined in this one, draw a *quadratic bezier curve*\n(definition on Wikipedia)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nUses pieces from Bitmap, and Bresenham's line algorithm tasks. They are included here to make a complete, runnable program.\n\n```\nclass Pixel { has UInt ($.R, $.G, $.B) }\nclass Bitmap {\n    has UInt ($.width, $.height);\n    has Pixel @!data;\n\n    method fill(Pixel $p) {\n        @!data = $p.clone xx ($!width*$!height)\n    }\n    method pixel(\n\t  $i where ^$!width,\n\t  $j where ^$!height\n\t  --> Pixel\n    ) is rw { @!data[$i + $j * $!width] }\n\n    method set-pixel ($i, $j, Pixel $p) {\n        return if $j >= $!height;\n        self.pixel($i, $j) = $p.clone;\n    }\n    method get-pixel ($i, $j) returns Pixel {\n\t    self.pixel($i, $j);\n    }\n\n    method line(($x0 is copy, $y0 is copy), ($x1 is copy, $y1 is copy), $pix) {\n        my $steep = abs($y1 - $y0) > abs($x1 - $x0);\n        if $steep {\n            ($x0, $y0) = ($y0, $x0);\n            ($x1, $y1) = ($y1, $x1);\n        }\n        if $x0 > $x1 {\n            ($x0, $x1) = ($x1, $x0);\n            ($y0, $y1) = ($y1, $y0);\n        }\n        my $Δx = $x1 - $x0;\n        my $Δy = abs($y1 - $y0);\n        my $error = 0;\n        my $Δerror = $Δy / $Δx;\n        my $y-step = $y0 < $y1 ?? 1 !! -1;\n        my $y = $y0;\n        for $x0 .. $x1 -> $x {\n            if $steep {\n                self.set-pixel($y, $x, $pix);\n            } else {\n                self.set-pixel($x, $y, $pix);\n            }\n            $error += $Δerror;\n            if $error >= 0.5 {\n                $y += $y-step;\n                $error -= 1.0;\n            }\n        }\n    }\n\n    method dot (($px, $py), $pix, $radius = 2) {\n        for $px - $radius .. $px + $radius -> $x {\n            for $py - $radius .. $py + $radius -> $y {\n                self.set-pixel($x, $y, $pix) if ( $px - $x + ($py - $y) * i ).abs <= $radius;\n            }\n        }\n    }\n\n    method quadratic ( ($x1, $y1), ($x2, $y2), ($x3, $y3), $pix, $segments = 30 ) {\n        my @line-segments = map -> $t {\n            my \\a = (1-$t)²;\n            my \\b = $t * (1-$t) * 2;\n            my \\c = $t²;\n            (a*$x1 + b*$x2 + c*$x3).round(1),(a*$y1 + b*$y2 + c*$y3).round(1)\n        }, (0, 1/$segments, 2/$segments ... 1);\n        for @line-segments.rotor(2=>-1) -> ($p1, $p2) { self.line( $p1, $p2, $pix) };\n    }\n\n    method data { @!data }\n}\n\nrole PPM {\n    method P6 returns Blob {\n\t\"P6\\n{self.width} {self.height}\\n255\\n\".encode('ascii')\n\t~ Blob.new: flat map { .R, .G, .B }, self.data\n    }\n}\n\nsub color( $r, $g, $b) { Pixel.new(R => $r, G => $g, B => $b) }\n\nmy Bitmap $b = Bitmap.new( width => 600, height => 400) but PPM;\n\n$b.fill( color(2,2,2) );\n\nmy @points = (65,25), (85,380), (570,15);\n\nmy %seen;\nmy $c = 0;\nfor @points.permutations -> @this {\n    %seen{@this.reverse.join.Str}++;\n    next if %seen{@this.join.Str};\n    $b.quadratic( |@this, color(255-$c,127,$c+=80) );\n}\n\n@points.map: { $b.dot( $_, color(255,0,0), 3 )}\n\n$*OUT.write: $b.P6;\n\n```\n\nSee example image here, (converted to a .png as .ppm format is not widely supported)."}]}
{"messages": [{"role": "user", "content": "Implement a flood fill.\n\nA flood fill is a way of filling an area using *color banks* to define the contained area or a *target color* which \"determines\" the area (the *valley* that can be flooded; Wikipedia uses the term *target color*). It works almost like a water flooding from a point towards the banks (or: inside the valley): if there's a hole in the banks, the flood is not contained and all the image (or all the \"connected valleys\") get filled.\n\nTo accomplish the task, you need to implement just one of the possible algorithms (examples are on Wikipedia). Variations on the *theme* are allowed (e.g. adding a tolerance parameter or argument for color-matching of the *banks* or *target* color).\n\n**Testing**: the basic algorithm is not suitable for *truecolor* images; a possible test image is the one shown on the right box; you can try to fill the white area, or the black inner circle."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\nUsing bits and pieces from various other bitmap tasks.\n\n```\nclass Pixel { has Int ($.R, $.G, $.B) }\nclass Bitmap {\n    has Int ($.width, $.height);\n    has Pixel @.data;\n\n    method pixel(\n\t    $i where ^$!width,\n\t    $j where ^$!height\n\t    --> Pixel\n      ) is rw { @!data[$i + $j * $!width] }\n}\n\nrole PPM {\n    method P6 returns Blob {\n\t\"P6\\n{self.width} {self.height}\\n255\\n\".encode('ascii')\n\t~ Blob.new: flat map { .R, .G, .B }, self.data\n    }\n}\n\nsub load-ppm ( $ppm ) {\n    my $fh    = $ppm.IO.open( :enc('ISO-8859-1') );\n    my $type  = $fh.get;\n    my ($width, $height) = $fh.get.split: ' ';\n    my $depth = $fh.get;\n    Bitmap.new( width => $width.Int, height => $height.Int,\n      data => ( $fh.slurp.ords.rotor(3).map:\n        { Pixel.new(R => $_[0], G => $_[1], B => $_[2]) } )\n    )\n}\n\nsub color-distance (Pixel $c1, Pixel $c2) {\n    sqrt( ( ($c1.R - $c2.R)² + ($c1.G - $c2.G)² + ($c1.B - $c2.B)² ) / ( 255 * sqrt(3) ) );\n}\n\nsub flood ($img, $x, $y, $c1) {\n    my $c2 = $img.pixel($x, $y);\n    my $max-distance = 10;\n    my @queue;\n    my %checked;\n    check($x, $y);\n    for @queue -> [$x, $y] {\n        $img.pixel($x, $y) = $c1.clone;\n    }\n\n    sub check ($x, $y) {\n        my $c3 = $img.pixel($x, $y);\n\n        if color-distance($c2, $c3) < $max-distance {\n            @queue.push: [$x,$y];\n            @queue.elems;\n            %checked{\"$x,$y\"} = 1;\n            check($x - 1, $y) if $x > 0               and %checked{\"{$x - 1},$y\"}:!exists;\n            check($x + 1, $y) if $x < $img.width - 1  and %checked{\"{$x + 1},$y\"}:!exists;\n            check($x, $y - 1) if $y > 0               and %checked{\"$x,{$y - 1}\"}:!exists;\n            check($x, $y + 1) if $y < $img.height - 1 and %checked{\"$x,{$y + 1}\"}:!exists;\n        }\n    }\n}\n\nmy $infile = './Unfilled-Circle.ppm';\n\nmy Bitmap $b = load-ppm( $infile ) but PPM;\n\nflood($b, 5,     5, Pixel.new(:255R, :0G, :0B));\nflood($b, 5,   125, Pixel.new(:255R, :0G, :0B));\nflood($b, 125,   5, Pixel.new(:255R, :0G, :0B));\nflood($b, 125, 125, Pixel.new(:255R, :0G, :0B));\nflood($b, 50,   50, Pixel.new(:0R, :0G, :255B));\n\nmy $outfile = open('./Bitmap-flood-perl6.ppm', :w, :bin);\n\n$outfile.write: $b.P6;\n\n```\n\nSee output image Bitmap-flood-perl6 (offsite image file, converted to PNG for ease of viewing)"}]}
{"messages": [{"role": "user", "content": "Extend the basic bitmap storage defined on this page to support dealing with image histograms. The image histogram contains for each luminance the count of image pixels having this luminance. Choosing a histogram representation take care about the data type used for the counts. It must have range of at least 0..NxM, where N is the image width and M is the image height.\n\n**Test task**\n\nHistogram is useful for many image processing operations. As an example, use it to convert an image into black and white art. The method works as follows:\n\n* Convert image to grayscale;\n* Compute the histogram\n* Find the median: defined as the luminance such that the image has an approximately equal number of pixels with lesser and greater luminance.\n* Replace each pixel of luminance lesser than the median to black, and others to white.\n\nUse read/write ppm file, and grayscale image solutions."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nUses pieces from Bitmap, Write a PPM file and Grayscale image tasks. Included here to make a complete, runnable program.\n\n```\nclass Pixel { has UInt ($.R, $.G, $.B) }\nclass Bitmap {\n    has UInt ($.width, $.height);\n    has Pixel @.data;\n}\n\nrole PBM {\n    has @.BM;\n    method P4 returns Blob {\n\t\"P4\\n{self.width} {self.height}\\n\".encode('ascii')\n\t~ Blob.new: self.BM\n    }\n}\n\nsub getline ( $fh ) {\n    my $line = '#'; # skip comments when reading image file\n    $line = $fh.get while $line.substr(0,1) eq '#';\n    $line;\n}\n\nsub load-ppm ( $ppm ) {\n    my $fh    = $ppm.IO.open( :enc('ISO-8859-1') );\n    my $type  = $fh.&getline;\n    my ($width, $height) = $fh.&getline.split: ' ';\n    my $depth = $fh.&getline;\n    Bitmap.new( width => $width.Int, height => $height.Int,\n      data => ( $fh.slurp.ords.rotor(3).map:\n        { Pixel.new(R => $_[0], G => $_[1], B => $_[2]) } )\n    )\n}\n\nsub grayscale ( Bitmap $bmp ) {\n    map { (.R*0.2126 + .G*0.7152 + .B*0.0722).round(1) min 255 }, $bmp.data;\n}\n\nsub histogram ( Bitmap $bmp ) {\n    my @gray = grayscale($bmp);\n    my $threshold = @gray.sum / @gray;\n    for @gray.rotor($bmp.width) {\n        my @row = $_.list;\n        @row.push(0) while @row % 8;\n        $bmp.BM.append: @row.rotor(8).map: { :2(($_ X< $threshold)».Numeric.join) }\n    }\n}\n\nmy $filename = './Lenna.ppm';\n\nmy Bitmap $b = load-ppm( $filename ) but PBM;\n\nhistogram($b);\n\n'./Lenna-bw.pbm'.IO.open(:bin, :w).write: $b.P4;\n\n```\n\nSee Lenna, and Lenna-bw images. (converted to .png as .ppm format is not widely supported)."}]}
{"messages": [{"role": "user", "content": "Task\n\nUsing the data storage type defined on this page for raster images,\nwrite an implementation of the **midpoint circle algorithm**   (also known as **Bresenham's circle algorithm**).\n\n(definition on Wikipedia)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: C\n\nWe'll augment the Pixel and Bitmap classes from the Bitmap task.\n\n```\nuse MONKEY-TYPING;\n\nclass Pixel { has UInt ($.R, $.G, $.B) }\nclass Bitmap {\n    has UInt ($.width, $.height);\n    has Pixel @!data;\n\n    method fill(Pixel \\p) {\n        @!data = p xx ($!width × $!height)\n    }\n\n    method pixel( \\i where ^$!width, \\j where ^$!height --> Pixel) is rw {\n        @!data[i × $!width + j]\n    }\n\n    method set-pixel (\\i, \\j, Pixel \\p) {\n        self.pixel(i, j) = p;\n    }\n\n    method get-pixel (\\i, \\j) returns Pixel {\n        self.pixel(i, j);\n    }\n}\n\naugment class Pixel  { method Str { \"$.R $.G $.B\" } }\naugment class Bitmap {\n    method P3 {\n        join \"\\n\", «P3 \"$.width $.height\" 255»,\n        do for ^($.width × $.height) { join ' ', @!data[$_] }\n    }\n\n    method raster-circle ( \\x0, \\y0, \\r, Pixel \\value ) {\n        my $ddF_x   =  0;\n        my $ddF_y   = -2 × r;\n        my $f       =  1 - r;\n        my ($x, $y) =  0,  r;\n        for flat (0 X 1,-1),(1,-1 X 0) -> \\i, \\j {\n            self.set-pixel(x0 + i×r, y0 + j×r, value)\n        }\n\n        while $x < $y {\n            ($y--; $f +=     ($ddF_y += 2)) if $f ≥ 0;\n             $x++; $f += 1 + ($ddF_x += 2);\n            for flat (1,-1) X (1,-1) -> \\i, \\j {\n                self.set-pixel(x0 + i×$x, y0 + j×$y, value);\n                self.set-pixel(x0 + i×$y, y0 + j×$x, value);\n            }\n        }\n    }\n}\n\nmy Bitmap $b = Bitmap.new( width => 32, height => 32);\n$b.fill( Pixel.new( R => 0, G => 0, B => 0) );\n$b.raster-circle(16, 16, 15, Pixel.new(R=>0, G=>0, B=>100));\nsay $b.P3;\n\n```"}]}
{"messages": [{"role": "user", "content": "Using the data storage type defined on this page for raster images, delegate writing a JPEG file through a **pipe** using the output\\_ppm function defined on this other page.\n\nThere are various utilities that can be used for this task, for example: **cjpeg** (package *\"jpeg-progs\"* on Linux, or *\"media-libs/libjpeg-turbo\"* on Gentoo), **ppmtojpeg** (package *\"netpbm\"* on Linux), **convert** (from *ImageMagick*, multi-platform)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# Reference:\n# https://rosettacode.org/wiki/Bitmap/Write_a_PPM_file#Raku\n\nuse v6;\n\nclass Pixel { has uint8 ($.R, $.G, $.B) }\nclass Bitmap {\n    has UInt ($.width, $.height);\n    has Pixel @!data;\n\n    method fill(Pixel $p) {\n        @!data = $p.clone xx ($!width*$!height)\n    }\n    method pixel(\n          $i where ^$!width,\n          $j where ^$!height\n          --> Pixel\n      ) is rw { @!data[$i*$!height + $j] }\n\n    method data { @!data }\n}\n\nrole PPM {\n    method P6 returns Blob {\n        \"P6\\n{self.width} {self.height}\\n255\\n\".encode('ascii')\n        ~ Blob.new: flat map { .R, .G, .B }, self.data\n    }\n}\n\nmy Bitmap $b = Bitmap.new(width => 125, height => 125) but PPM;\nfor flat ^$b.height X ^$b.width -> $i, $j {\n    $b.pixel($i, $j) = Pixel.new: :R($i*2), :G($j*2), :B(255-$i*2);\n}\n\nmy $proc = run '/usr/bin/convert','-','output_piped.jpg', :in;\n$proc.in.write: $b.P6;\n$proc.in.close;\n\n```\n\nOutput:\n\n```\nfile output_piped.jpg\noutput_piped.jpg: JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 125x125, frames 3\n```"}]}
{"messages": [{"role": "user", "content": "Using the data storage type defined on this page for raster images, read an image from a PPM file (binary P6 prefered).\n(Read the definition of PPM file on Wikipedia.)\n\n**Task**: Use write ppm file solution and grayscale image solution with this one in order to convert a color image to grayscale one."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nUses pieces from Bitmap, Write a PPM file and Grayscale image tasks. Included here to make a complete, runnable program.\n\n```\nclass Pixel { has UInt ($.R, $.G, $.B) }\nclass Bitmap {\n    has UInt ($.width, $.height);\n    has Pixel @.data;\n}\n\nrole PGM {\n    has @.GS;\n    method P5 returns Blob {\n\t\"P5\\n{self.width} {self.height}\\n255\\n\".encode('ascii')\n\t~ Blob.new: self.GS\n    }\n}\n\nsub load-ppm ( $ppm ) {\n    my $fh    = $ppm.IO.open( :enc('ISO-8859-1') );\n    my $type  = $fh.get;\n    my ($width, $height) = $fh.get.split: ' ';\n    my $depth = $fh.get;\n    Bitmap.new( width => $width.Int, height => $height.Int,\n      data => ( $fh.slurp.ords.rotor(3).map:\n        { Pixel.new(R => $_[0], G => $_[1], B => $_[2]) } )\n    )\n}\n\nsub grayscale ( Bitmap $bmp ) {\n    $bmp.GS = map { (.R*0.2126 + .G*0.7152 + .B*0.0722).round(1) min 255 }, $bmp.data;\n}\n\nmy $filename = './camelia.ppm';\n\nmy Bitmap $b = load-ppm( $filename ) but PGM;\n\ngrayscale($b);\n\n'./camelia-gs.pgm'.IO.open(:bin, :w).write: $b.P5;\n\n```\n\nSee camelia, and camelia-gs images. (converted to .png as .ppm format is not widely supported)."}]}
{"messages": [{"role": "user", "content": "This task is the *opposite* of the PPM conversion through a pipe. In this task, using a delegate tool (like **cjpeg**, one of the netpbm package, or **convert** of the ImageMagick package) we read an image file and load it into the data storage type defined here. We can also use the code from Read ppm file, so that we can use PPM format like a (natural) bridge between the foreign image format and our simple data storage."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nUses pieces from Bitmap and Read a PPM file tasks. Included here to make a complete, runnable program.\n\nUses imagemagick convert to pipe the image in.\n\n```\nclass Pixel { has UInt ($.R, $.G, $.B) }\nclass Bitmap {\n    has UInt ($.width, $.height);\n    has Pixel @.data;\n}\n\nrole PPM {\n    method P6 returns Blob {\n\t\"P6\\n{self.width} {self.height}\\n255\\n\".encode('ascii')\n\t~ Blob.new: flat map { .R, .G, .B }, self.data\n    }\n}\n\nsub getline ( $proc ) {\n    my $line = '#'; # skip comment when reading a .png\n    $line = $proc.out.get while $line.substr(0,1) eq '#';\n    $line;\n}\n\nmy $filename = './camelia.png';\n\nmy $proc = run 'convert', $filename, 'ppm:-', :enc('ISO-8859-1'), :out;\n\nmy $type = getline($proc);\nmy ($width, $height) = getline($proc).split: ' ';\nmy $depth = getline($proc);\n\nmy Bitmap $b = Bitmap.new( width => $width.Int, height => $height.Int) but PPM;\n\n$b.data = $proc.out.slurp.ords.rotor(3).map:\n  { Pixel.new(R => .[0], G => .[1], B => .[2]) };\n\n'./camelia.ppm'.IO.open(:bin, :w).write: $b.P6;\n\n```\n\nSee camelia image here."}]}
{"messages": [{"role": "user", "content": "Using the data storage type defined on this page for raster images, write the image to a PPM file (binary P6 preferred).\n\n(Read the definition of PPM file on Wikipedia.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016-01\n\n```\nclass Pixel { has uint8 ($.R, $.G, $.B) }\nclass Bitmap {\n    has UInt ($.width, $.height);\n    has Pixel @!data;\n\n    method fill(Pixel $p) {\n        @!data = $p.clone xx ($!width*$!height)\n    }\n    method pixel(\n\t  $i where ^$!width,\n\t  $j where ^$!height\n\t  --> Pixel\n      ) is rw { @!data[$i*$!height + $j] }\n\n    method data { @!data }\n}\n\nrole PPM {\n    method P6 returns Blob {\n\t\"P6\\n{self.width} {self.height}\\n255\\n\".encode('ascii')\n\t~ Blob.new: flat map { .R, .G, .B }, self.data\n    }\n}\n\nmy Bitmap $b = Bitmap.new(width => 125, height => 125) but PPM;\nfor flat ^$b.height X ^$b.width -> $i, $j {\n    $b.pixel($i, $j) = Pixel.new: :R($i*2), :G($j*2), :B(255-$i*2);\n}\n\n$*OUT.write: $b.P6;\n\n```\n\nConverted to a png. (ppm files not locally supported)"}]}
{"messages": [{"role": "user", "content": "The aim of this task is to write functions (or create a class if your\n\nlanguage is Object Oriented and you prefer) for reading and writing sequences of\nbits, most significant bit first. While the output of a asciiprint \"STRING\" is the ASCII byte sequence\n\"S\", \"T\", \"R\", \"I\", \"N\", \"G\", the output of a \"print\" of the bits sequence\n0101011101010 (13 bits) must be 0101011101010; real I/O is performed always\n*quantized* by byte (avoiding endianness issues and relying on underlying\nbuffering for performance), therefore you must obtain as output the bytes\n0101 0111 0101 0**000** (bold bits are padding bits), i.e. in hexadecimal 57 50.\n\nAs test, you can implement a **rough** (e.g. don't care about error handling or\nother issues) compression/decompression program for ASCII sequences\nof bytes, i.e. bytes for which the most significant bit is always unused, so that you can write\nseven bits instead of eight (each 8 bytes of input, we write 7 bytes of output).\n\nThese bit oriented I/O functions can be used to implement compressors and\ndecompressors; e.g. Dynamic and Static Huffman encodings use variable length\nbits sequences, while LZW (see LZW compression) use fixed or variable *words*\nnine (or more) bits long.\n\n* Limits in the maximum number of bits that can be written/read in a single read/write operation are allowed.\n* Errors handling is not mandatory"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub encode-ascii(Str $s) {\n    my @b = flat $s.ords».fmt(\"%07b\")».comb;\n    @b.push(0) until @b %% 8;   # padding\n    Buf.new: gather while @b { take reduce * *2+*, (@b.pop for ^8) }\n}\n\nsub decode-ascii(Buf $b) {\n    my @b = flat $b.list».fmt(\"%08b\")».comb;\n    @b.shift until @b %% 7;   # remove padding\n    @b = gather while @b { take reduce * *2+*, (@b.pop for ^7) }\n    return [~] @b».chr;\n}\nsay my $encode = encode-ascii 'STRING';\nsay decode-ascii $encode;\n\n```\n\nOutput:\n\n```\nBuf:0x<03 8b 99 29 4a e5>\nSTRING\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a routine to perform a bitwise AND, OR, and XOR on two integers, a bitwise NOT on the first integer, a left shift, right shift, right arithmetic shift, left rotate, and right rotate.\n\nAll shifts and rotates should be done on the first integer with a shift/rotate amount of the second integer.\n\nIf any operation is not available in your language, note it."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.05\n\n```\nconstant MAXINT = uint.Range.max;\nconstant BITS = MAXINT.base(2).chars;\n\n# define rotate ops for the fun of it\nmulti sub infix:<⥁>(Int:D \\a, Int:D \\b) { :2[(a +& MAXINT).polymod(2 xx BITS-1).list.rotate(b).reverse] }\nmulti sub infix:<⥀>(Int:D \\a, Int:D \\b) { :2[(a +& MAXINT).polymod(2 xx BITS-1).reverse.list.rotate(b)] }\n\nsub int-bits (Int $a, Int $b) {\n    say '';\n    say_bit \"$a\", $a;\n    say '';\n    say_bit \"1's complement (not) $a\", +^$a;\n    say_bit \"2's complement $a\", +^$a + 1;\n    say_bit \"$a and $b\", $a +& $b;\n    say_bit \"$a or $b\",  $a +| $b;\n    say_bit \"$a xor $b\", $a +^ $b;\n    say_bit \"$a unsigned shift right $b\", ($a +& MAXINT) +> $b;\n    say_bit \"$a signed shift right $b\", $a +> $b;\n    say_bit \"$a rotate right $b\", $a ⥁ $b;\n    say_bit \"$a shift left $b\", $a +< $b;\n    say_bit \"$a rotate left $b\", $a ⥀ $b;\n}\n\nint-bits(7,2);\nint-bits(-65432,31);\n\nsub say_bit ($message, $value) {\n    printf(\"%30s: %{'0' ~ BITS}b\\n\", $message, $value +& MAXINT);\n}\n```\n\nOutput:\n\n```\n                             7: 0000000000000000000000000000000000000000000000000000000000000111\n\n        1's complement (not) 7: 1111111111111111111111111111111111111111111111111111111111111000\n              2's complement 7: 1111111111111111111111111111111111111111111111111111111111111001\n                       7 and 2: 0000000000000000000000000000000000000000000000000000000000000010\n                        7 or 2: 0000000000000000000000000000000000000000000000000000000000000111\n                       7 xor 2: 0000000000000000000000000000000000000000000000000000000000000101\n      7 unsigned shift right 2: 0000000000000000000000000000000000000000000000000000000000000001\n        7 signed shift right 2: 0000000000000000000000000000000000000000000000000000000000000001\n              7 rotate right 2: 1100000000000000000000000000000000000000000000000000000000000001\n                7 shift left 2: 0000000000000000000000000000000000000000000000000000000000011100\n               7 rotate left 2: 0000000000000000000000000000000000000000000000000000000000011100\n\n                        -65432: 1111111111111111111111111111111111111111111111110000000001101000\n\n   1's complement (not) -65432: 0000000000000000000000000000000000000000000000001111111110010111\n         2's complement -65432: 0000000000000000000000000000000000000000000000001111111110011000\n                 -65432 and 31: 0000000000000000000000000000000000000000000000000000000000001000\n                  -65432 or 31: 1111111111111111111111111111111111111111111111110000000001111111\n                 -65432 xor 31: 1111111111111111111111111111111111111111111111110000000001110111\n-65432 unsigned shift right 31: 0000000000000000000000000000000111111111111111111111111111111111\n  -65432 signed shift right 31: 1111111111111111111111111111111111111111111111111111111111111111\n        -65432 rotate right 31: 1111111111111110000000001101000111111111111111111111111111111111\n          -65432 shift left 31: 1111111111111111100000000011010000000000000000000000000000000000\n         -65432 rotate left 31: 1111111111111111100000000011010001111111111111111111111111111111\n```"}]}
{"messages": [{"role": "user", "content": "The Blossom Algorithm\n:   The Blossom algorithm, developed by Jack Edmonds in 1965, is a seminal algorithm that solves the maximum matching problem for general graphs by extending the augmenting path concept to handle odd cycles.\n\nCore Idea\n:   Shrinking Blossoms\n:   The key insight of the Blossom algorithm is to identify an odd cycle (a blossom) when encountered during the search for an augmenting path. When a blossom is detected, the algorithm *contracts* or *shrinks* the entire cycle into a single \"pseudo-vertex\". This creates a smaller, auxiliary graph.\n:   The search for an augmenting path then continues in this contracted graph. If an augmenting path is found in the contracted graph that involves a pseudo-vertex (representing a shrunk blossom), this path can be \"lifted\" back to the original graph. The structure of the blossom allows the algorithm to find a corresponding augmenting path in the original graph that utilizes edges within the blossom.\n:   This process of shrinking blossoms, searching for augmenting paths in the contracted graph, and expanding blossoms to find paths in the original graph is repeated until no more augmenting paths are found, at which point the current matching is maximum.\n\nProblem\n:   Maximum Matching in General Graphs\n:   The problem addressed by the Blossom algorithm is finding a Maximum matching|maximum matching in a Graph (discrete mathematics)|general graph. Unlike Bipartite graph|bipartite graphs, general graphs can contain Cycle (graph theory)|odd-length cycles.\n\nGraph and Matching Definition\n:   A Graph (discrete mathematics)|graph **G** is formally defined by a set of Vertex (graph theory)|vertices **V** and a set of Edge (graph theory)|edges **E**, denoted as \n\n    G\n    =\n    (\n    V\n    ,\n    E\n    )\n    {\\displaystyle {\\displaystyle G=(V,E)}}\n    . An edge connects two vertices.\n:   A Matching (graph theory)|matching **M** in **G** is a subset of the edges **E** such that no two edges in **M** share a common vertex. That is, for any two distinct edges \n\n    e\n\n    1\n    =\n\n\n    u\n\n    1\n    ,\n\n    v\n\n    1\n    ∈\n    M\n    {\\displaystyle {\\displaystyle e\\_{1}={u\\_{1},v\\_{1}}\\in M}}\n     and \n\n    e\n\n    2\n    =\n\n\n    u\n\n    2\n    ,\n\n    v\n\n    2\n    ∈\n    M\n    {\\displaystyle {\\displaystyle e\\_{2}={u\\_{2},v\\_{2}}\\in M}}\n    , the sets of vertices \n\n    u\n\n    1\n    ,\n\n    v\n\n    1\n    {\\displaystyle {\\displaystyle {u\\_{1},v\\_{1}}}}\n     and \n\n    u\n\n    2\n    ,\n\n    v\n\n    2\n    {\\displaystyle {\\displaystyle {u\\_{2},v\\_{2}}}}\n     are disjoint.\n\nMaximum Matching\n:   A Maximum matching|maximum matching is a matching **M** with the largest possible number of edges among all possible matchings in the graph **G**. The size of the matching is \n\n    |\n    M\n\n    |\n    {\\displaystyle {\\displaystyle |M|}}\n    .\n:   The objective of the maximum matching problem is to find a matching **M** such that \n\n    |\n    M\n\n    |\n    {\\displaystyle {\\displaystyle |M|}}\n     is maximized.\n\nChallenge in General Graphs\n:   Odd Cycles\n:   For Bipartite graph|bipartite graphs, efficient algorithms exist (e.g., Hopcroft-Karp algorithm) that rely on finding Augmenting path|augmenting paths. An augmenting path with respect to a matching **M** is a path that starts and ends at unmatched vertex|unmatched vertices, and its edges alternate between being outside **M** and inside **M**. If such a path exists, the matching can be increased by one edge by flipping the edges along the path (taking edges not in **M** and removing edges in **M** along the path). Berge's lemma states that a matching is maximum if and only if it has no augmenting path.\n:   However, the presence of Cycle (graph theory)|odd-length cycles in general graphs complicates the search for augmenting paths. Standard Breadth-first search|BFS techniques used for bipartite graphs can get \"confused\" by odd cycles, which are sometimes called *blossoms* or *flowers* in this context. An odd cycle can contain an even number of matched edges and an odd number of unmatched edges with respect to an alternating path leading into it, potentially preventing the discovery of a true augmenting path using simple methods.\n\nObjective\n:   Given a general graph \n\n    G\n    =\n    (\n    V\n    ,\n    E\n    )\n    {\\displaystyle {\\displaystyle G=(V,E)}}\n    , the problem is to compute a matching \n\n    M\n    ⊆\n    E\n    {\\displaystyle {\\displaystyle M\\subseteq E}}\n     such that its size \n\n    |\n    M\n\n    |\n    {\\displaystyle {\\displaystyle |M|}}\n     is maximum. The Blossom algorithm provides a polynomial-time solution to this problem.\n\nComplexity\n:   The original Blossom algorithm by Edmonds has a time complexity of \n\n    O\n    (\n\n    |\n    V\n\n\n    |\n\n    2\n\n    |\n    E\n\n    |\n    )\n    {\\displaystyle {\\displaystyle O(|V|^{2}|E|)}}\n    . Subsequent improvements by Edmonds and others, including Robert Tarjan|Tarjan, led to more efficient versions. Modern implementations using advanced data structures achieve a time complexity of \n\n    O\n    (\n\n    |\n    E\n\n    |\n\n    |\n    V\n\n    |\n    )\n    {\\displaystyle {\\displaystyle O(|E|{\\sqrt {|V|}})}}\n    , which is generally considered very efficient for this problem. An \n\n    O\n    (\n\n    |\n    V\n\n\n    |\n\n    3\n    )\n    {\\displaystyle {\\displaystyle O(|V|^{3})}}\n     variant is also commonly cited and easier to implement."}, {"role": "assistant", "content": "**Translation of**: Phix\n\n**Translation of**: Python\n\n```\n# 20250512 Raku programming solution\n\n# least common ancestor of x and y in the alternating forest\nsub lca($x is copy, $y is copy, @bases, @matches, @paths, $n) {\n   my @usedPath = False xx $n;\n   loop {\n      @usedPath[$x = @bases[$x]] = True;\n      @matches[$x] < 0 ?? ( last ) !! $x = @paths[@matches[$x]]\n   }\n   loop {\n      @usedPath[$y = @bases[$y]].Bool ?? ( last ) !! $y = @paths[@matches[$y]]     \n   }\n   return $y;\n}\n\n# mark path from v up to base0, setting parents to x\nsub markPath($v is copy, $base0, $x is copy, @bases, @matches, @paths, @blossom) {\n   while @bases[$v] != $base0 {\n      my $mv = @matches[$v];\n      @blossom[@bases[$mv]] = @blossom[@bases[$v]] = True;\n      @paths[$v] = $x;\n      $v = @paths[ $x = $mv ];\n   }\n}\n\n# attempt to find an augmenting path from root\nsub findPath(@adj, $root, $n, @matches is copy) {\n   my @paths = -1 xx $n;\n   my @bases = ^$n;\n   my @queue = ($root);\n   my (@used, @blossom) is default( False );\n   @used[$root] = True;\n\n   while my $v = @queue.shift {\n      for @adj[$v].flat -> $u {\n         next unless @bases[$v] != @bases[$u] && @matches[$v] != $u;\n         if $u == $root || (@matches[$u] != -1 && @paths[@matches[$u]] != -1) {\n            # Found a blossom; contract it\n            my $curbase = lca($v, $u, @bases, @matches, @paths, $n);\n            markPath($v, $curbase, $u, @bases, @matches, @paths, @blossom);\n            markPath($u, $curbase, $v, @bases, @matches, @paths, @blossom);\n            @queue.push: gather for ^$n -> $i {\n               if @blossom[@bases[$i]] {\n                  @bases[$i] = $curbase;\n                  unless @used[$i] { @used[take $i] = True }\n               }\n            }\n         } elsif @paths[$u] == -1 { # extend tree\n            @paths[$u] = $v;\n            if @matches[$u] == -1 { # augmenting path found\n               my $v = $u;\n               while $v != -1 {\n                  my $prev = @paths[$v];\n                  my $next = ( $prev != -1 ) ?? @matches[$prev] !! -1;\n                  @matches[$v] = $prev;\n                  @matches[$prev] = $v if $prev != -1;\n                  $v = $next;\n               }\n               return (@matches, True);\n            }\n            @used[@matches[$u]] = True;\n            @queue.push: @matches[$u];\n         }\n      }\n   }\n   return (@matches, False);\n}\n\n# find and return the matching array and the size of the matching\nsub solve(@adj) {\n   my @matches = -1 xx ( my $n = @adj.elems ); \n   my $res = 0;\n\n   for ^$n -> $v {\n      if @matches[$v] == -1 {\n         my ($new_matches, $found) = findPath(@adj, $v, $n, @matches);\n         if $found {\n            @matches = @$new_matches;\n            $res++;\n         }\n      }\n   }\n   return (@matches, $res);\n}\n\n# Example: 5-cycle (0–1–2–3–4–0)\nmy $n = 5;\nmy @edges = (0,1), (1,2), (2,3), (3,4), (4,0);\nmy @adj = [ [] xx $n ];\nfor @edges -> ($u, $v) {\n   @adj[$u].push($v);\n   @adj[$v].push($u);\n}\n\nmy ($matches, $msize) = solve(@adj);\nsay \"Maximum matching size: $msize\";\nsay \"Matched pairs:\";\nfor $matches.kv -> $u, $v { say \"  $u – $v\" if $v != -1 && $u < $v }\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Definition\n\nA positive integer **n** is a **Blum integer** if *n = p x q* is a semi-prime for which *p* and *q* are distinct primes congruent to 3 mod 4. In other words, *p* and *q* must be of the form 4*t* + 3 where *t* is some non-negative integer.\n\nExample\n\n21 is a Blum integer because it has two prime factors: 3 (= 4 x 0 + 3) and 7 (= 4 x 1 + 3).\n\nTask\n\nFind and show on this page the first **50** Blum integers.\n\nAlso show the **26,828**th.\n\nStretch\n\nFind and show the **100,000**th, **200,000**th, **300,000**th and **400,000**th Blum integers.\n\nFor the first **400,000** Blum integers, show the percentage distribution by final decimal digit (to 3 decimal places). Clearly, such integers can only end in 1, 3, 7 or 9.\n\nRelated task\n\n* Semiprime\n\nReferences\n\n* Wikipedia article Blum integer\n* OEIS sequence A016105: Blum integers"}, {"role": "assistant", "content": "```\nuse List::Divvy;\nuse Lingua::EN::Numbers;\n\nsub is-blum(Int $n ) {\n    return False if $n.is-prime;\n    my $factor = find-factor($n);\n    return True if ($factor.is-prime && ( my $div = $n div $factor ).is-prime && ($div != $factor)\n    && ($factor % 4 == 3) && ($div % 4 == 3));\n    False;\n}\n\nsub find-factor ( Int $n, $constant = 1 ) {\n    my $x      = 2;\n    my $rho    = 1;\n    my $factor = 1;\n    while $factor == 1 {\n        $rho *= 2;\n        my $fixed = $x;\n        for ^$rho {\n            $x = ( $x * $x + $constant ) % $n;\n            $factor = ( $x - $fixed ) gcd $n;\n            last if 1 < $factor;\n        }\n    }\n    $factor = find-factor( $n, $constant + 1 ) if $n == $factor;\n    $factor;\n}\n\nmy @blum = lazy (2..Inf).hyper(:1000batch).grep: &is-blum;\nsay \"The first fifty Blum integers:\\n\" ~\n  @blum[^50].batch(10)».fmt(\"%3d\").join: \"\\n\";\nsay '';\n\nprintf \"The %9s Blum integer: %9s\\n\", .&ordinal-digit(:c), comma @blum[$_-1] for 26828, 1e5, 2e5, 3e5, 4e5;\n\nsay \"\\nBreakdown by last digit:\";\nprintf \"%d => %%%7.4f:\\n\", .key, +.value / 4e3 for sort @blum[^4e5].categorize: {.substr(*-1)}\n\n```\n\nOutput:\n\n```\nThe first fifty Blum integers:\n 21  33  57  69  77  93 129 133 141 161\n177 201 209 213 217 237 249 253 301 309\n321 329 341 381 393 413 417 437 453 469\n473 489 497 501 517 537 553 573 581 589\n597 633 649 669 681 713 717 721 737 749\n\nThe  26,828th Blum integer:   524,273\nThe 100,000th Blum integer: 2,075,217\nThe 200,000th Blum integer: 4,275,533\nThe 300,000th Blum integer: 6,521,629\nThe 400,000th Blum integer: 8,802,377\n\nBreakdown by last digit:\n1 => %25.0013:\n3 => %25.0168:\n7 => %24.9973:\n9 => %24.9848:\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow how to represent the boolean states \"**true**\" and \"**false**\" in a language.\n\nIf other objects represent \"**true**\" or \"**false**\" in conditionals, note it.\n\nRelated tasks\n\n* Logical operations"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\nRaku provides an enumeration `Bool` with two values, `True` and `False`. Values of enumerations can be used as ordinary values or as mixins:\n\n```\nmy Bool $crashed = False;\nmy $val = 0 but True;\n\n```\n\nFor a discussion of Boolean context (how Raku decides whether something is True or False): https://docs.raku.org/language/contexts#index-entry-Boolean\\_context."}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Boustrophedon transform. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nA boustrophedon transform is a procedure which maps one sequence to another using a series of integer additions.\n\nGenerally speaking, given a sequence: \n\n(\n\na\n\n0\n,\n\na\n\n1\n,\n\na\n\n2\n,\n…\n)\n{\\displaystyle {\\displaystyle (a\\_{0},a\\_{1},a\\_{2},\\ldots )}}\n, the boustrophedon transform yields another sequence: \n\n(\n\nb\n\n0\n,\n\nb\n\n1\n,\n\nb\n\n2\n,\n…\n)\n{\\displaystyle {\\displaystyle (b\\_{0},b\\_{1},b\\_{2},\\ldots )}}\n, where \n\nb\n\n0\n{\\displaystyle {\\displaystyle b\\_{0}}}\n is likely defined equivalent to \n\na\n\n0\n{\\displaystyle {\\displaystyle a\\_{0}}}\n.\n\nThere are a few different ways to effect the transform. You may construct a boustrophedon triangle and read off the edge values, or, may use the recurrence relationship:\n\n:   T\n\n    k\n    ,\n    0\n    =\n\n    a\n\n    k\n    {\\displaystyle {\\displaystyle T\\_{k,0}=a\\_{k}}}\n:   T\n\n    k\n    ,\n    n\n    =\n\n    T\n\n    k\n    ,\n    n\n    −\n    1\n    +\n\n    T\n\n    k\n    −\n    1\n    ,\n    k\n    −\n    n\n    {\\displaystyle {\\displaystyle T\\_{k,n}=T\\_{k,n-1}+T\\_{k-1,k-n}}}\n:   with \n    {\\displaystyle {\\displaystyle {\\text{with }}}}\n:   k\n    ,\n    n\n    ∈\n\n    N\n    {\\displaystyle {\\displaystyle \\quad k,n\\in \\mathbb {N} }}\n:   k\n    ≥\n    n\n    >\n    0\n    {\\displaystyle {\\displaystyle \\quad k\\geq n>0}}\n    .\n\nThe transformed sequence is defined by \n\nb\n\nn\n=\n\nT\n\nn\n,\nn\n{\\displaystyle {\\displaystyle b\\_{n}=T\\_{n,n}}}\n (for \n\nT\n\n2\n,\n2\n{\\displaystyle {\\displaystyle T\\_{2,2}}}\n and greater indices).\n\nYou are free to use a method most convenient for your language. If the boustrophedon transform is provided by a built-in, or easily and freely available library, it is acceptable to use that (with a pointer to where it may be obtained).\n\nTask\n\n* Write a procedure (routine, function, subroutine, whatever it may be called in your language) to perform a boustrophedon transform to a given sequence.\n* Use that routine to perform a boustrophedon transform on a few representative sequences. Show the first fifteen values from the transformed sequence.\n\n:   *Use the following sequences for demonstration:*\n\n    * (\n      1\n      ,\n      0\n      ,\n      0\n      ,\n      0\n      ,\n      …\n      )\n      {\\displaystyle {\\displaystyle (1,0,0,0,\\ldots )}}\n       ( one followed by an infinite series of zeros )\n    * (\n      1\n      ,\n      1\n      ,\n      1\n      ,\n      1\n      ,\n      …\n      )\n      {\\displaystyle {\\displaystyle (1,1,1,1,\\ldots )}}\n       ( an infinite series of ones )\n    * (\n      1\n      ,\n      −\n      1\n      ,\n      1\n      ,\n      −\n      1\n      ,\n      …\n      )\n      {\\displaystyle {\\displaystyle (1,-1,1,-1,\\ldots )}}\n       ( (-1)^n: alternating 1, -1, 1, -1 )\n    * (\n      2\n      ,\n      3\n      ,\n      5\n      ,\n      7\n      ,\n      11\n      ,\n      …\n      )\n      {\\displaystyle {\\displaystyle (2,3,5,7,11,\\ldots )}}\n       ( sequence of prime numbers )\n    * (\n      1\n      ,\n      1\n      ,\n      2\n      ,\n      3\n      ,\n      5\n      ,\n      …\n      )\n      {\\displaystyle {\\displaystyle (1,1,2,3,5,\\ldots )}}\n       ( sequence of Fibonacci numbers )\n    * (\n      1\n      ,\n      1\n      ,\n      2\n      ,\n      6\n      ,\n      24\n      ,\n      …\n      )\n      {\\displaystyle {\\displaystyle (1,1,2,6,24,\\ldots )}}\n       ( sequence of factorial numbers )\n\nStretch\n\nIf your language supports big integers, show the first and last 20 digits, and the digit count of the 1000th element of each sequence.\n\nSee also\n\n* Wikipedia - Boustrophedon transform * OEIS:A000111 - Euler, or up/down numbers * OEIS:A000667 - Boustrophedon transform of all-1's sequence * OEIS:A062162 - Boustrophedon transform of (-1)^n * OEIS:A000747 - Boustrophedon transform of primes * OEIS:A000744 - Boustrophedon transform of Fibonacci numbers * OEIS:A230960 - Boustrophedon transform of factorials"}, {"role": "assistant", "content": "```\nsub boustrophedon-transform (@seq) { map *.tail, (@seq[0], {[[\\+] flat @seq[++$ ], .reverse]}…*) }\n\nsub abbr ($_) { .chars < 41 ?? $_ !! .substr(0,20) ~ '…' ~ .substr(*-20) ~ \" ({.chars} digits)\" }\n\nfor '1 followed by 0\\'s A000111', (flat 1, 0 xx *),\n    'All-1\\'s           A000667', (flat 1 xx *),\n    '(-1)^n             A062162', (flat 1, [\\×] -1 xx *),\n    'Primes             A000747', (^∞ .grep: &is-prime),\n    'Fibonaccis         A000744', (1,1,*+*…*),\n    'Factorials         A230960', (1,|[\\×] 1..∞)\n  -> $name, $seq\n{ say \"\\n$name:\\n\" ~ (my $b-seq = boustrophedon-transform $seq)[^15] ~ \"\\n1000th term: \" ~ abbr $b-seq[999] }\n\n```\n\nOutput:\n\n```\n1 followed by 0's A000111:\n1 1 1 2 5 16 61 272 1385 7936 50521 353792 2702765 22368256 199360981\n1000th term: 61065678604283283233…63588348134248415232 (2369 digits)\n\nAll-1's           A000667:\n1 2 4 9 24 77 294 1309 6664 38177 243034 1701909 13001604 107601977 959021574\n1000th term: 29375506567920455903…86575529609495110509 (2370 digits)\n\n(-1)^n             A062162:\n1 0 0 1 0 5 10 61 280 1665 10470 73621 561660 4650425 41441530\n1000th term: 12694307397830194676…15354198638855512941 (2369 digits)\n\nPrimes             A000747:\n2 5 13 35 103 345 1325 5911 30067 172237 1096319 7677155 58648421 485377457 4326008691\n1000th term: 13250869953362054385…82450325540640498987 (2371 digits)\n\nFibonaccis         A000744:\n1 2 5 14 42 144 563 2526 12877 73778 469616 3288428 25121097 207902202 1852961189\n1000th term: 56757474139659741321…66135597559209657242 (2370 digits)\n\nFactorials         A230960:\n1 2 5 17 73 381 2347 16701 134993 1222873 12279251 135425553 1627809401 21183890469 296773827547\n1000th term: 13714256926920345740…19230014799151339821 (2566 digits)\n```"}]}
{"messages": [{"role": "user", "content": "Avast me hearties!\n\nThere be many a land lubber that knows naught of the pirate ways and gives direction by degree!\nThey know not how to box the compass!\n\nTask description\n\n1. Create a function that takes a heading in degrees and returns the correct 32-point compass heading.\n2. Use the function to print and display a table of Index, Compass point, and Degree; rather like the corresponding columns from, the first table of the wikipedia article, but use only the following 33 headings as input:\n\n:   `[0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38]`. (They should give the same order of points but are spread throughout the ranges of acceptance).\n\nNotes;\n\n* The headings and indices can be calculated from this pseudocode:\n\n```\nfor i in 0..32 inclusive:\n    heading = i * 11.25\n    case i %3:\n      if 1: heading += 5.62; break\n      if 2: heading -= 5.62; break\n    end\n    index = ( i mod 32) + 1\n```\n\n* The column of indices can be thought of as an enumeration of the thirty two cardinal points (see talk page).."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub point (Int $index) {\n    my $ix = $index % 32;\n    if $ix +& 1\n        { \"&point(($ix + 1) +& 28) by &point(((2 - ($ix +& 2)) * 4) + $ix +& 24)\" }\n    elsif $ix +& 2\n        { \"&point(($ix + 2) +& 24)-&point(($ix +| 4) +& 28)\" }\n    elsif $ix +& 4\n        { \"&point(($ix + 8) +& 16)&point(($ix +| 8) +& 24)\" }\n    else\n        { <north east south west>[$ix div 8]; }\n}\n\nsub test-angle ($ix) { $ix * 11.25 + (0, 5.62, -5.62)[ $ix % 3 ] }\nsub angle-to-point(\\𝜽) { floor 𝜽 / 360 * 32 + 0.5 }\n\nfor 0 .. 32 -> $ix {\n    my \\𝜽 = test-angle($ix);\n    printf \"  %2d %6.2f° %s\\n\",\n              $ix % 32 + 1,\n                  𝜽,\n                         tc point angle-to-point 𝜽;\n}\n\n```\n\nOutput:\n\n```\n   1   0.00° North\n   2  16.87° North by east\n   3  16.88° North-northeast\n   4  33.75° Northeast by north\n   5  50.62° Northeast\n   6  50.63° Northeast by east\n   7  67.50° East-northeast\n   8  84.37° East by north\n   9  84.38° East\n  10 101.25° East by south\n  11 118.12° East-southeast\n  12 118.13° Southeast by east\n  13 135.00° Southeast\n  14 151.87° Southeast by south\n  15 151.88° South-southeast\n  16 168.75° South by east\n  17 185.62° South\n  18 185.63° South by west\n  19 202.50° South-southwest\n  20 219.37° Southwest by south\n  21 219.38° Southwest\n  22 236.25° Southwest by west\n  23 253.12° West-southwest\n  24 253.13° West by south\n  25 270.00° West\n  26 286.87° West by north\n  27 286.88° West-northwest\n  28 303.75° Northwest by west\n  29 320.62° Northwest\n  30 320.63° Northwest by north\n  31 337.50° North-northwest\n  32 354.37° North by west\n   1 354.38° North\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nThis algorithm is designed for pattern searching on certain types of devices which are backtracking-unfriendly such as Tape drives and Hard disks.\n\nIt works by first caching a segment of data from storage and match it against the pattern from the highest position backward to the lowest. If the matching fails, it will cache next segment of data and move the start point forward to skip the portion of data which will definitely fail to match. This continues until we successfully match the pattern or the pointer exceeds the data length.\n\nFollow this link for more information about this algorithm.\n\nTo properly test this algorithm, it would be good to search for a string which contains repeated subsequences, such as `alfalfa` and the text being searched should not only include a match but that match should be preceded by words which partially match, such as `alfredo`, `behalf`, `calfskin`, `halfhearted`, `malfunction` or `severalfold`."}, {"role": "assistant", "content": "**Translation of**: Phix\n\n```\n# 20220818 Raku programming solution\n\nsub suffixes (@pat,\\m) {\n   loop (my ($i,$f,$g,@suff)=m-2, 0, m-1, |flat 0 xx m-1,m; $i >= 0; --$i) {\n      if $i > $g and @suff[$i + m - 1 - $f] < $i - $g {\n         @suff[$i] = @suff[$i + m - 1 - $f]\n      } else {\n\t $g = $i if $i < $g;\n         $f = $i;\n\t while $g >= 0 and @pat[$g] eq @pat[$g + m - 1 - $f] { $g-- }\n         @suff[$i] = $f - $g\n      }\n   }\n   return @suff;\n}\n\nsub preBmGs (@pat,\\m) {\n   my (@suff, @bmGs) := suffixes(@pat,m), [m xx m]; \n\n   for m-1 ... 0 -> \\k {\n      if @suff[k] == k + 1 {\n         loop (my $j=0; $j < m-1-k; $j++) { @bmGs[k]=m-1-k if @bmGs[$j] == m }\n      }\n   }\n   for ^(m-1) { @bmGs[m - 1 - @suff[$_]] = m - 1 - $_ }\n   return @bmGs;\n}\n\nsub BM (@txt,@pat) {\n   my (\\m, \\n, $j)    = +@pat, +@txt, 0;\n   my (@bmGs, %bmBc) := preBmGs(@pat,m), hash @pat Z=> ( m-1 ... 1 );\n\n   return gather while $j <= n - m {\n      loop (my $i = m - 1; $i >= 0 and @pat[$i] eq @txt[$i + $j]; ) { $i-- }\n      if $i < 0 {\n\t take $j;\n         $j += @bmGs[0]\n      } else {\n         $j += max @bmGs[$i], (%bmBc{@txt[$i + $j]} // m)-m+$i\n      }\n   }\n}\n\nmy @texts = [\n   \"GCTAGCTCTACGAGTCTA\",\n   \"GGCTATAATGCGTA\",\n   \"there would have been a time for such a word\",\n   \"needle need noodle needle\",\n   \"BharôtভাৰতBharôtভারতIndiaBhāratભારતBhāratभारतBhārataಭಾರತBhāratभारतBhāratamഭാരതംBhāratभारतBhāratभारतBharôtôଭାରତBhāratਭਾਰਤBhāratamभारतम्Bārataபாரதம்BhāratamഭാരതംBhāratadēsamభారతదేశం\",\n   \"InhisbookseriesTheArtofComputerProgrammingpublishedbyAddisonWesleyDKnuthusesanimaginarycomputertheMIXanditsassociatedmachinecodeandassemblylanguagestoillustratetheconceptsandalgorithmsastheyarepresented\",\n   \"Nearby farms grew a half acre of alfalfa on the dairy's behalf, with bales of all that alfalfa exchanged for milk.\",\n];\n\nmy @pats = [ \"TCTA\", \"TAATAAA\", \"word\", \"needle\", \"ഭാരതം\", \"put\", \"and\", \"alfalfa\"];\n\nsay \"text$_ = @texts[$_]\" for @texts.keys ;\nsay();\n\nfor @pats.keys {\n   my \\j = $_ < 6 ?? $_ !! $_-1 ; # for searching text5 twice\n   say \"Found '@pats[$_]' in 'text{j}' at indices \", BM @texts[j].comb, @pats[$_].comb\n}\n\n```\n\nOutput is the same as the Knuth-Morris-Pratt\\_string\\_search#Raku entry."}]}
{"messages": [{"role": "user", "content": "Brace expansion is a type of parameter expansion made popular by Unix shells, where it allows users to specify multiple similar string parameters without having to type them all out. E.g. the parameter `enable_{audio,video}` would be interpreted as if both `enable_audio` and `enable_video` had been specified.\n\nTask\n\nWrite a function that can perform brace expansion on any input string, according to the following specification.  \nDemonstrate how it would be used, and that it passes the four test cases given below.\n\nSpecification\n\nIn the input string, balanced pairs of braces containing comma-separated substrings (details below) represent *alternations* that specify multiple alternatives which are to appear at that position in the output. In general, one can imagine the information conveyed by the input string as a tree of nested alternations interspersed with literal substrings, as shown in the middle part of the following diagram:\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| It{{em,alic}iz,erat}e{d,} | *parse*  ―――――▶ ‌ | |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | It | |  |  |  |  |  |  |  |  | | --- | --- | --- | --- | --- | --- | --- | --- | | ⎧ ⎨ ⎩ | |  |  |  | | --- | --- | --- | | ⎧ ⎨ ⎩ | em | ⎫ ⎬ ⎭ | | alic | | iz | ⎫ ⎬ ⎭ | | erat | | | e | |  |  |  | | --- | --- | --- | | ⎧ ⎨ ⎩ | d | ⎫ ⎬ ⎭ | | ‌ | | | *expand*  ―――――▶ ‌ | Itemized Itemize Italicized Italicize  Iterated Iterate |\n| input string |  | alternation tree |  | output *(list of strings)* |\n\nThis tree can in turn be transformed into the intended list of output strings by, colloquially speaking, determining all the possible ways to walk through it from left to right while only descending into *one* branch of each alternation one comes across *(see the right part of the diagram)*. When implementing it, one can of course combine the parsing and expansion into a single algorithm, but this specification discusses them separately for the sake of clarity.\n\n**Expansion** of alternations can be more rigorously described by these rules:\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| |  |  |  |  |  |  |  |  |  |  |  |  |  |  | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | a | |  |  |  | | --- | --- | --- | | ⎧ ⎨ ⎩ | 2 | ⎫ ⎬ ⎭ | | 1 | | b | |  |  |  | | --- | --- | --- | | ⎧ ⎨ ⎩ | X | ⎫ ⎬ ⎭ | | Y | | X | | c | | ⟶ | |  | | --- | | a2bXc | | a2bYc | | a2bXc | | a1bXc | | a1bYc | | a1bXc | |\n\n* An alternation causes the list of alternatives that will be produced by its parent branch to be increased 𝑛-fold, each copy featuring one of the 𝑛 alternatives produced by the alternation's child branches, in turn, at that position.\n* This means that multiple alternations inside the same branch are cumulative  *(i.e. the complete list of alternatives produced by a branch is the string-concatenating \"Cartesian product\" of its parts)*.\n* All alternatives (even duplicate and empty ones) are preserved, and they are ordered like the examples demonstrate  *(i.e. \"lexicographically\" with regard to the alternations)*.\n* The alternatives produced by the root branch constitute the final output.\n\n**Parsing** the input string involves some additional complexity to deal with escaped characters and \"incomplete\" brace pairs:\n\n|  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| a\\\\{\\\\\\{b,c\\,d} | ⟶ | |  |  |  |  |  |  | | --- | --- | --- | --- | --- | --- | | a\\\\ | |  |  |  | | --- | --- | --- | | ⎧ ⎨ ⎩ | \\\\\\{b | ⎫ ⎬ ⎭ | | c\\,d | | |\n| {a,b{c{,{d}}e}f | ⟶ | |  |  |  |  |  |  |  | | --- | --- | --- | --- | --- | --- | --- | | {a,b{c | |  |  |  | | --- | --- | --- | | ⎧ ⎨ ⎩ | ‌ | ⎫ ⎬ ⎭ | | {d} | | e}f | |\n\n* An unescaped *backslash* which precedes another character, escapes that character (to force it to be treated as literal). The backslashes are passed along to the output unchanged.\n* Balanced *brace pairs* are identified by, conceptually, going through the string from left to right and associating each unescaped closing brace that is encountered with the nearest still unassociated unescaped opening brace to its left (if any). Furthermore, each unescaped *comma* is associated with the innermost brace pair that contains it (if any). With that in mind:\n  + Each brace pair that has at least one comma associated with it, forms an alternation (whose branches are the brace pair's contents split at its commas). The associated brace and comma characters themselves do not become part of the output.\n  + Brace characters from pairs without any associated comma, as well as unassociated brace and comma characters, as well as all characters that are not covered by the preceding rules, are instead treated as literals.\n\nFor every possible input string, your implementation should produce exactly the output which this specification mandates. Please comply with this even when it's inconvenient, to ensure that all implementations are comparable. However, none of the above should be interpreted as instructions (or even recommendations) for **how** to implement it. Try to come up with a solution that is idiomatic in your programming language. *(See #Perl for a reference implementation.)*\n\nTest Cases\n\n:   :   :   | Input *(single string)* | Ouput *(list/array of strings)* |\n            | --- | --- |\n            | `~/{Downloads,Pictures}/*.{jpg,gif,png}` | `~/Downloads/*.jpg`  `~/Downloads/*.gif`  `~/Downloads/*.png`  `~/Pictures/*.jpg`  `~/Pictures/*.gif`  `~/Pictures/*.png` |\n            | `It{{em,alic}iz,erat}e{d,}, please.` | `Itemized, please.`  `Itemize, please.`  `Italicized, please.`  `Italicize, please.`  `Iterated, please.`  `Iterate, please.` |\n            | `{,{,gotta have{ ,\\, again\\, }}more }cowbell!` | `cowbell!`  `more cowbell!`  `gotta have more cowbell!`  `gotta have\\, again\\, more cowbell!` |\n            | `{}} some }{,{\\\\{ edge, edge} \\,}{ cases, {here} \\\\\\\\\\}` | `{}} some }{,{\\\\ edge \\,}{ cases, {here} \\\\\\\\\\}`  `{}} some }{,{\\\\ edge \\,}{ cases, {here} \\\\\\\\\\}` |\n\n---\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet\n\n:   * Brace\\_expansion\\_using\\_ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\nThe task description allows the taking of shortcuts, but please note that we are not taking any shortcuts here. The solution is short because this particular problem happens to map quite naturally to the strengths of Raku.\n\nFirst, the parsing is handled with a grammar that can backtrack in the few places this problem needs it. The + quantifier matches one or more alternatives (we handle the case of a single alternative in the walk now), and the % modifier requires a comma between each quantified item to its left. Note that the \\* quantifiers do *not* backtrack here, because the token keyword suppresses that; all the backtracking here fails over to a different alternative in an outer alternation (that is, things separated by the | character in the grammar. Most of these failovers just nibble an uninteresting character and continue.)\n\nOn the other end, we recursively walk the parse tree returning expanded sublists, and we do the cartesian concatenation of sublists at each level by use of the X~ operator, which is a \"cross\" metaoperator used on a simple ~ concatenation. As a list infix operator, X~ does not care how many items are on either side, which is just what you want in this case, since some of the arguments are strings and some are lists. Here we use a fold or reduction form in square brackets to interpose the cross-concat between each value generated by the map, which returns a mixture of lists and literal strings. One other thing that might not be obvious: if we bind to the match variable, $/, we automatically get all the syntactic sugar for its submatches. In this case, $0 is short for $/[0], and represents all the submatches captured by 0th set of parens in either TOP or alt. $<meta> is likewise short for $/<meta>, and retrieves what was captured by that named submatch.\n\n```\ngrammar BraceExpansion {\n    token TOP  { ( <meta> | . )* }\n    token meta { '{' <alts> '}' | \\\\ .  }\n    token alts { <alt>+ % ',' }\n    token alt  { ( <meta> | <-[ , } ]> )* }\n}\n\nsub crosswalk($/) {\n    |[X~] flat '', $0.map: -> $/ { $<meta><alts><alt>.&alternatives or ~$/ }\n}\n\nsub alternatives($_) {\n    when :not { () }\n    when 1    { '{' X~ $_».&crosswalk X~ '}' }\n    default   { $_».&crosswalk }\n}\n\nsub brace-expand($s) { crosswalk BraceExpansion.parse($s) }\n\n# Testing:\n\nsub bxtest(*@s) {\n    for @s -> $s {\n        say \"\\n$s\";\n        for brace-expand($s) {\n            say \"    \", $_;\n        }\n    }\n}\n\nbxtest Q:to/END/.lines;\n    ~/{Downloads,Pictures}/*.{jpg,gif,png}\n    It{{em,alic}iz,erat}e{d,}, please.\n    {,{,gotta have{ ,\\, again\\, }}more }cowbell!\n    a{b{1,2}c\n    a{1,2}b}c\n    a{1,{2},3}b\n    more{ darn{ cowbell,},}\n    ab{c,d\\,e{f,g\\h},i\\,j{k,l\\,m}n,o\\,p}qr\n    {a,{\\,b}c\n    a{b,{{c}}\n    {a{\\}b,c}d\n    END\n\n```\n\nOutput:\n\n```\n~/{Downloads,Pictures}/*.{jpg,gif,png}\n    ~/Downloads/*.jpg\n    ~/Downloads/*.gif\n    ~/Downloads/*.png\n    ~/Pictures/*.jpg\n    ~/Pictures/*.gif\n    ~/Pictures/*.png\n\nIt{{em,alic}iz,erat}e{d,}, please.\n    Itemized, please.\n    Itemize, please.\n    Italicized, please.\n    Italicize, please.\n    Iterated, please.\n    Iterate, please.\n\n{,{,gotta have{ ,\\, again\\, }}more }cowbell!\n    cowbell!\n    more cowbell!\n    gotta have more cowbell!\n    gotta have\\, again\\, more cowbell!\n\n{}} some {\\\\{edge,edgy} }{ cases, here\\\\\\}\n    {}} some {\\\\edge }{ cases, here\\\\\\}\n    {}} some {\\\\edgy }{ cases, here\\\\\\}\n\na{b{1,2}c\n    a{b1c\n    a{b2c\n\na{1,2}b}c\n    a1b}c\n    a2b}c\n\na{1,{2},3}b\n    a1b\n    a{2}b\n    a3b\n\nmore{ darn{ cowbell,},}\n    more darn cowbell\n    more darn\n    more\n\nab{c,d\\,e{f,g\\h},i\\,j{k,l\\,m}n,o\\,p}qr\n    abcqr\n    abd\\,efqr\n    abd\\,eg\\hqr\n    abi\\,jknqr\n    abi\\,jl\\,mnqr\n    abo\\,pqr\n\n{a,{\\,b}c\n    {a,{\\,b}c\n\na{b,{{c}}\n    a{b,{{c}}\n\n{a{\\}b,c}d\n    {a\\}bd\n    {acd\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nTask\n\nWrite and test a function which expands one or more Unix-style **numeric and alphabetic range braces** embedded in a larger string.\n\nSpecification\n\nThe brace strings used by Unix shells permit expansion of both:\n\n1. Recursive comma-separated lists (covered by the **related task**: Brace\\_expansion, and can be ignored here)\n2. ordered numeric and alphabetic **ranges**, which are the object of this task.\n\nThe general pattern of brace ranges is:\n\n```\n{<START>..<END>}\n```\n\nand, in more recent shells:\n\n```\n{<START>..<END>..<INCR>}\n```\n\n(See https://wiki.bash-hackers.org/syntax/expansion/brace)\n\nExpandable ranges of this kind can be ascending or descending:\n\n```\nsimpleNumber{1..3}.txt\nsimpleAlpha-{Z..X}.txt\n```\n\nand may have a third INCR element specifying ordinal intervals larger than one.\nThe increment value can be preceded by a **-** minus sign, but not by a **+** sign.\n\nThe effect of the minus sign is to always to **reverse** the natural order suggested by the START and END values.\n\nAny level of zero-padding used in either the START or END value of a numeric range is adopted in the expansions.\n\n```\nsteppedDownAndPadded-{10..00..5}.txt\nminusSignFlipsSequence {030..20..-5}.txt\n```\n\nA single string may contain more than one expansion range:\n\n```\ncombined-{Q..P}{2..1}.txt\n```\n\nAlphabetic range values are limited to a single character for START and END\nbut these characters are not confined to the ASCII alphabet.\n\n```\nemoji{🌵..🌶}{🌽..🌾}etc\n```\n\nUnmatched braces are simply ignored, as are empty braces, and braces which contain no range (or list).\n\n```\nli{teral\nrangeless{}empty\nrangeless{random}string\n```\n\nTests\n\nGenerate and display here the expansion of (at least) each of the ten example lines shown below.\n\nThe JavaScript implementation below uses parser combinators, aiming to encode a more or less full and legible description of the\n\n```\n<PREAMBLE><AMBLE><POSTSCRIPT>\n```\n\nrange brace grammar, but you should use any resource that suggests itself in your language, including parser libraries.\n\n(The grammar of range expansion, unlike that of nested list expansion, is not recursive, so even regular expressions should prove serviceable here).\n\nThe output of the JS implementation, which aims to match the brace expansion behaviour of the default **zsh** shell on current versions of macOS:\n\n```\nsimpleNumberRising{1..3}.txt -> \n    simpleNumberRising1.txt\n    simpleNumberRising2.txt\n    simpleNumberRising3.txt\n\nsimpleAlphaDescending-{Z..X}.txt -> \n    simpleAlphaDescending-Z.txt\n    simpleAlphaDescending-Y.txt\n    simpleAlphaDescending-X.txt\n\nsteppedDownAndPadded-{10..00..5}.txt -> \n    steppedDownAndPadded-10.txt\n    steppedDownAndPadded-05.txt\n    steppedDownAndPadded-00.txt\n\nminusSignFlipsSequence {030..20..-5}.txt -> \n    minusSignFlipsSequence 020.txt\n    minusSignFlipsSequence 025.txt\n    minusSignFlipsSequence 030.txt\n\nreverseSteppedNumberRising{1..6..-2}.txt -> \n    reverseSteppedNumberRising5.txt\n    reverseSteppedNumberRising3.txt\n    reverseSteppedNumberRising1.txt\n\ncombined-{Q..P}{2..1}.txt -> \n    combined-Q2.txt\n    combined-Q1.txt\n    combined-P2.txt\n    combined-P1.txt\n\nemoji{🌵..🌶}{🌽..🌾}etc -> \n    emoji🌵🌽etc\n    emoji🌵🌾etc\n    emoji🌶🌽etc\n    emoji🌶🌾etc\n\nli{teral -> \n    li{teral\n\nrangeless{}empty -> \n    rangeless{}empty\n\nrangeless{random}string -> \n    rangeless{random}string\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet\n\n* range expansion"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.08.1\n\nAlso implements some of the string list functions described on the bash-hackers page.\n\n```\nmy $range = rx/ '{' $<start> = <-[.]>+? '..' $<end> = <-[.]>+? ['..' $<incr> = ['-'?\\d+] ]? '}' /;\nmy $list  = rx/ ^ $<prefix> = .*? '{' (<-[,}]>+) +%% ',' '}' $<postfix> = .* $/;\n\nsub expand (Str $string) {\n    my @return = $string;\n    if $string ~~ $range {\n        quietly my ($start, $end, $incr) = $/<start end incr>».Str;\n        $incr ||= 1;\n        ($end, $start) = $start, $end if $incr < 0;\n        $incr.=abs;\n\n        if try all( +$start, +$end ) ~~ Numeric {\n            $incr = - $incr if $start > $end;\n\n            my ($sl, $el) = 0, 0;\n            $sl = $start.chars if $start.starts-with('0');\n            $el = $end.chars   if   $end.starts-with('0');\n\n            my @this = $start < $end ?? (+$start, * + $incr …^ * > +$end) !! (+$start, * + $incr …^ * < +$end);\n            @return  = @this.map: { $string.subst($range, sprintf(\"%{'0' ~ max $sl, $el}d\", $_) ) }\n        }\n        elsif try +$start ~~ Numeric or +$end ~~ Numeric {\n            return $string #fail\n        }\n        else {\n            my @this;\n            if $start.chars + $end.chars > 2 {\n                return $string if $start.succ eq $start or $end.succ eq $end; # fail\n                @this = $start lt $end ?? ($start, (*.succ xx $incr).tail …^ * gt $end) !! ($start, (*.pred xx $incr).tail …^ * lt $end);\n            }\n            else {\n                $incr = -$incr if $start gt $end;\n                @this = $start lt $end ?? ($start, (*.ord + $incr).chr …^ * gt $end) !! ($start, (*.ord + $incr).chr …^ * lt $end);\n            }\n            @return = @this.map: { $string.subst($range, sprintf(\"%s\", $_) ) }\n        }\n    }\n    if $string ~~ $list {\n        my $these = $/[0]».Str;\n        my ($prefix, $postfix) = $/<prefix postfix>».Str;\n        if ($prefix ~ $postfix).chars {\n            @return = $these.map: { $string.subst($list, $prefix ~ $_ ~ $postfix) } if $these.elems > 1\n        }\n        else {\n            @return = $these.join: ' '\n        }\n    }\n    my $cnt = 1;\n    while $cnt != +@return {\n        $cnt = +@return;\n        @return.=map: { |.&expand }\n    }\n    @return\n}\n\nfor qww<\n    # Required tests\n\n    simpleNumberRising{1..3}.txt\n    simpleAlphaDescending-{Z..X}.txt\n    steppedDownAndPadded-{10..00..5}.txt\n    minusSignFlipsSequence{030..20..-5}.txt\n    combined-{Q..P}{2..1}.txt\n    emoji{🌵..🌶}{🌽..🌾}etc\n    li{teral\n    rangeless{}empty\n    rangeless{random}string\n\n    # Test some other features\n\n    'stop point not in sequence-{02..10..3}.txt'\n    steppedAlphaRising{P..Z..2}.txt\n    'simple {just,give,me,money} list'\n    {thatʼs,what,I,want}\n    'emoji {☃,☄}{★,🇺🇸,☆} lists'\n    'alphanumeric mix{ab7..ac1}.txt'\n    'alphanumeric mix{0A..0C}.txt'\n\n    # fail by design\n\n    'mixed terms fail {7..C}.txt'\n    'multi char emoji ranges fail {🌵🌵..🌵🌶}'\n  > -> $test {\n     say \"$test ->\";\n     say ('    ' xx * Z~ expand $test).join: \"\\n\";\n     say '';\n}\n\n```\n\nOutput:\n\n```\nsimpleNumberRising{1..3}.txt ->\n    simpleNumberRising1.txt\n    simpleNumberRising2.txt\n    simpleNumberRising3.txt\n\nsimpleAlphaDescending-{Z..X}.txt ->\n    simpleAlphaDescending-Z.txt\n    simpleAlphaDescending-Y.txt\n    simpleAlphaDescending-X.txt\n\nsteppedDownAndPadded-{10..00..5}.txt ->\n    steppedDownAndPadded-10.txt\n    steppedDownAndPadded-05.txt\n    steppedDownAndPadded-00.txt\n\nminusSignFlipsSequence{030..20..-5}.txt ->\n    minusSignFlipsSequence020.txt\n    minusSignFlipsSequence025.txt\n    minusSignFlipsSequence030.txt\n\ncombined-{Q..P}{2..1}.txt ->\n    combined-Q2.txt\n    combined-Q1.txt\n    combined-P2.txt\n    combined-P1.txt\n\nemoji{🌵..🌶}{🌽..🌾}etc ->\n    emoji🌵🌽etc\n    emoji🌵🌾etc\n    emoji🌶🌽etc\n    emoji🌶🌾etc\n\nli{teral ->\n    li{teral\n\nrangeless{}empty ->\n    rangeless{}empty\n\nrangeless{random}string ->\n    rangeless{random}string\n\nstop point not in sequence-{02..10..3}.txt ->\n    stop point not in sequence-02.txt\n    stop point not in sequence-05.txt\n    stop point not in sequence-08.txt\n\nsteppedAlphaRising{P..Z..2}.txt ->\n    steppedAlphaRisingP.txt\n    steppedAlphaRisingR.txt\n    steppedAlphaRisingT.txt\n    steppedAlphaRisingV.txt\n    steppedAlphaRisingX.txt\n    steppedAlphaRisingZ.txt\n\nsimple {just,give,me,money} list ->\n    simple just list\n    simple give list\n    simple me list\n    simple money list\n\n{thatʼs,what,I,want} ->\n    thatʼs what I want\n\nemoji {☃,☄}{★,🇺🇸,☆} lists ->\n    emoji ☃★ lists\n    emoji ☃🇺🇸 lists\n    emoji ☃☆ lists\n    emoji ☄★ lists\n    emoji ☄🇺🇸 lists\n    emoji ☄☆ lists\n\nalphanumeric mix{ab7..ac1}.txt ->\n    alphanumeric mixab7.txt\n    alphanumeric mixab8.txt\n    alphanumeric mixab9.txt\n    alphanumeric mixac0.txt\n    alphanumeric mixac1.txt\n\nalphanumeric mix{0A..0C}.txt ->\n    alphanumeric mix0A.txt\n    alphanumeric mix0B.txt\n    alphanumeric mix0C.txt\n\nmixed terms fail {7..C}.txt ->\n    mixed terms fail {7..C}.txt\n\nmulti char emoji ranges fail {🌵🌵..🌵🌶} ->\n    multi char emoji ranges fail {🌵🌵..🌵🌶}\n\n```"}]}
{"messages": [{"role": "user", "content": "Brazilian numbers are so called as they were first formally presented at the 1994 math Olympiad *Olimpiada Iberoamericana de Matematica* in Fortaleza, Brazil.\n\nBrazilian numbers are defined as:\n\nThe set of positive integer numbers where each number **N** has at least one natural number **B** where **1 < B < N-1** where the representation of **N** in **base B** has all equal digits.\n\nE.G.\n\n:   * **1, 2 & 3** can not be Brazilian; there is no base **B** that satisfies the condition **1 < B < N-1**.\n    * **4** is not Brazilian; **4** in **base 2** is **100**. The digits are not all the same.\n    * **5** is not Brazilian; **5** in **base 2** is **101**, in **base 3** is **12**. There is no representation where the digits are the same.\n    * **6** is not Brazilian; **6** in **base 2** is **110**, in **base 3** is **20**, in **base 4** is **12**. There is no representation where the digits are the same.\n    * **7** *is* Brazilian; **7** in **base 2** is **111**. There is at least one representation where the digits are all the same.\n    * **8** *is* Brazilian; **8** in **base 3** is **22**. There is at least one representation where the digits are all the same.\n    * *and so on...*\n\nAll even integers **2P >= 8** are Brazilian because **2P = 2(P-1) + 2**, which is **22** in **base P-1** when **P-1 > 2**. That becomes true when **P >= 4**.  \nMore common: for all all integers **R** and **S**, where **R > 1** and also **S-1 > R**, then **R\\*S** is Brazilian because **R\\*S = R(S-1) + R**, which is **RR** in **base S-1**  \nThe only problematic numbers are squares of primes, where R = S. Only 11^2 is brazilian to base 3.  \nAll prime integers, that are brazilian, can only have the digit **1**. Otherwise one could factor out the digit, therefore it cannot be a prime number. Mostly in form of **111** to base Integer(sqrt(prime number)). Must be an odd count of **1** to stay odd like primes > 2\n\nTask\n\nWrite a routine (function, whatever) to determine if a number is Brazilian and use the routine to show here, on this page;\n\n:   * the first **20** Brazilian numbers;\n    * the first **20 odd** Brazilian numbers;\n    * the first **20 prime** Brazilian numbers;\n\nSee also\n\n:   * **OEIS:A125134 - Brazilian numbers**\n    * **OEIS:A257521 - Odd Brazilian numbers**\n    * **OEIS:A085104 - Prime Brazilian numbers**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\n```\nmulti is-Brazilian (Int $n where $n %% 2 && $n > 6) { True }\n\nmulti is-Brazilian (Int $n) {\n    LOOP: loop (my int $base = 2; $base < $n - 1; ++$base) {\n        my $digit;\n        for $n.polymod( $base xx * ) {\n            $digit //= $_;\n            next LOOP if $digit != $_;\n        }\n        return True\n    }\n    False\n}\n\nmy $upto = 20;\n\nput \"First $upto Brazilian numbers:\\n\", (^Inf).hyper.grep( &is-Brazilian )[^$upto];\n\nput \"\\nFirst $upto odd Brazilian numbers:\\n\", (^Inf).hyper.map( * * 2 + 1 ).grep( &is-Brazilian )[^$upto];\n\nput \"\\nFirst $upto prime Brazilian numbers:\\n\", (^Inf).hyper(:8degree).grep( { .is-prime && .&is-Brazilian } )[^$upto];\n\n```\n\nOutput:\n\n```\nFirst 20 Brazilian numbers:\n7 8 10 12 13 14 15 16 18 20 21 22 24 26 27 28 30 31 32 33\n\nFirst 20 odd Brazilian numbers:\n7 13 15 21 27 31 33 35 39 43 45 51 55 57 63 65 69 73 75 77\n\nFirst 20 prime Brazilian numbers:\n7 13 31 43 73 127 157 211 241 307 421 463 601 757 1093 1123 1483 1723 2551 2801\n```"}]}
{"messages": [{"role": "user", "content": "Show how to access private or protected members of a class in an object-oriented language from outside an instance of the class, without calling non-private or non-protected members of the class as a proxy.\nThe intent is to show how a debugger, serializer, or other meta-programming tool might access information that is barred by normal access methods to the object but can nevertheless be accessed from within the language by some provided escape hatch or reflection mechanism.\nThe intent is specifically not to demonstrate heroic measures such as peeking and poking raw memory.\n\nNote that cheating on your type system is almost universally regarded\nas unidiomatic at best, and poor programming practice at worst.\nNonetheless, if your language intentionally maintains a double-standard for OO privacy, here's where you can show it off."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\nWe may call into the MOP (Meta-Object Protocol) via the .^ operator, and the MOP knows all about the object, including any supposedly private bits. We ask for its attributes, find the correct one, and get its value.\n\n```\nclass Foo {\n    has $!shyguy = 42;\n}\nmy Foo $foo .= new;\n\nsay $foo.^attributes.first('$!shyguy').get_value($foo);\n\n```\n\nOutput:\n\n```\n42\n```"}]}
{"messages": [{"role": "user", "content": "**Brilliant numbers** are a subset of semiprime numbers. Specifically, they are numbers that are the product of exactly two prime numbers **that both have the same number of digits when expressed in base 10**.\n\n*Brilliant numbers are useful in cryptography and when testing prime factoring algorithms.*\n\nE.G.\n\n* **3 × 3** (9) is a brilliant number.\n* **2 × 7** (14) is a brilliant number.\n* **113 × 691** (78083) is a brilliant number.\n* **2 × 31** (62) is semiprime, but is **not** a brilliant number (different number of digits in the two factors).\n\nTask\n\n* Find and display the first 100 brilliant numbers.\n* For the orders of magnitude 1 through 6, find and show the first brilliant number greater than or equal to the order of magnitude, and, its position in the series (or the count of brilliant numbers up to that point).\n\nStretch\n\n* Continue for larger orders of magnitude.\n\nSee also\n\n* Numbers Aplenty - Brilliant numbers * - Like the task upper Limit 1E201 * OEIS:A078972 - Brilliant numbers: semiprimes whose prime factors have the same number of decimal digits"}, {"role": "assistant", "content": "1 through 7 are fast. 8 and 9 take a bit longer.\n\n```\nuse Lingua::EN::Numbers;\n\n# Find an abundance of primes to use to generate brilliants\nmy %primes = (2..100000).grep( &is-prime ).categorize: { .chars };\n\n# Generate brilliant numbers\nmy @brilliant = lazy flat (1..*).map: -> $digits {\n    sort flat (^%primes{$digits}).race.map: { %primes{$digits}[$_] X× (flat %primes{$digits}[$_ .. *]) }\n};\n\n# The task\nput \"First 100 brilliant numbers:\\n\" ~ @brilliant[^100].batch(10)».fmt(\"%4d\").join(\"\\n\") ~ \"\\n\" ;\n\nfor 1 .. 7 -> $oom {\n    my $threshold = exp $oom, 10;\n    my $key = @brilliant.first: :k, * >= $threshold;\n    printf \"First >= %13s is %9s in the series: %13s\\n\", comma($threshold), ordinal-digit(1 + $key, :u), comma @brilliant[$key];\n}\n\n```\n\nOutput:\n\n```\nFirst 100 brilliant numbers:\n   4    6    9   10   14   15   21   25   35   49\n 121  143  169  187  209  221  247  253  289  299\n 319  323  341  361  377  391  403  407  437  451\n 473  481  493  517  527  529  533  551  559  583\n 589  611  629  649  667  671  689  697  703  713\n 731  737  767  779  781  793  799  803  817  841\n 851  869  871  893  899  901  913  923  943  949\n 961  979  989 1003 1007 1027 1037 1067 1073 1079\n1081 1121 1139 1147 1157 1159 1189 1207 1219 1241\n1247 1261 1271 1273 1333 1343 1349 1357 1363 1369\n\nFirst >=            10 is       4ᵗʰ in the series:            10\nFirst >=           100 is      11ᵗʰ in the series:           121\nFirst >=         1,000 is      74ᵗʰ in the series:         1,003\nFirst >=        10,000 is     242ⁿᵈ in the series:        10,201\nFirst >=       100,000 is    2505ᵗʰ in the series:       100,013\nFirst >=     1,000,000 is   10538ᵗʰ in the series:     1,018,081\nFirst >=    10,000,000 is  124364ᵗʰ in the series:    10,000,043\nFirst >=   100,000,000 is  573929ᵗʰ in the series:   100,140,049\nFirst >= 1,000,000,000 is 7407841ˢᵗ in the series: 1,000,000,081\n```"}]}
{"messages": [{"role": "user", "content": "Objective\n\nDevelop a program that identifies and lists all maximal cliques within an undirected graph. A *maximal clique* is a subset of vertices where every two distinct vertices are adjacent (i.e., there's an edge connecting them), and the clique cannot be extended by including any adjacent vertex not already in the clique.\n\nBackground\n\nIn graph theory, a *clique* is a subset of vertices of an undirected graph such that every two distinct vertices in the clique are connected by an edge. A *maximal clique* is a clique that cannot be extended by adding one more adjacent vertex, meaning it's not a subset of a larger clique.\n\nThe Bron-Kerbosch algorithm is a recursive backtracking algorithm used to find all maximal cliques in an undirected graph efficiently. The algorithm is particularly effective due to its use of pivot selection, which reduces the number of recursive calls and improves performance.\n\nProgram Functionality\n\n1. **Input Representation:**\n\n* The graph is represented as a list of edges, where each edge is a tuple of two vertices (e.g., `('a', 'b')` indicates an undirected edge between vertices `'a'` and `'b'`).\n\n1. **Graph Construction:**\n\n* Convert the list of edges into an adjacency list using a `HashMap<String, HashSet<String>>`. Each key in the hashmap represents a vertex, and its corresponding hash set contains all adjacent vertices (neighbors).\n\n1. **Bron-Kerbosch Algorithm Implementation:**\n\n* **Sets Used:**\n  + *R* (Current Clique): *A set representing the current clique being constructed.*\n  + *P* (Potential Candidates): *A set of vertices that can be added to* R *to form a larger clique.*\n  + *X* (Excluded Vertices): *A set of vertices that have already been processed and should not be reconsidered for the current clique.*\n\n* **Algorithm Steps:**\n  + If both *P* and *X* are empty, and *R* contains more than two vertices, *R* is a maximal clique and is added to the list of cliques.\n  + Otherwise, select a *pivot vertex* from the union of *P* and *X* that has the maximum number of neighbors. This pivot helps minimize the number of recursive calls.\n  + Iterate over all vertices in *P* that are \\*\\*not\\*\\* neighbors of the pivot. For each such vertex:\n    - Add the vertex to *R*.\n    - Update *P* and *X* to include only those vertices that are neighbors of the added vertex.\n    - Recursively call the Bron-Kerbosch function with the updated sets.\n    - After recursion, move the vertex from *P* to *X* to mark it as processed.\n\n1. **Output:**\n\n* After executing the algorithm, the program prints all maximal cliques with more than two vertices. Each clique is displayed as a comma-separated list of its constituent vertices.\n\nExample\n\nGiven the following edges:\n\n```\n('a', 'b'), ('b', 'a'), ('a', 'c'), ('c', 'a'), ('b', 'c'), ('c', 'b'),\n('d', 'e'), ('e', 'd'), ('d', 'f'), ('f', 'd'), ('e', 'f'), ('f', 'e')\n\n```\n\n**Expected Output:**\n\n```\na, b, c\nd, e, f\n\n```\n\nThese outputs represent the two maximal cliques in the graph: one comprising vertices `a`, `b`, and `c`, and the other comprising vertices `d`, `e`, and `f`.\n\nPseudocode\n\nBelow is the pseudocode for the Bron-Kerbosch algorithm with pivoting, closely following the Rust implementation provided earlier.\n\n```\nFUNCTION BronKerbosch(R, P, X, G, Cliques)\n    // R: Current clique (Set)\n    // P: Potential candidates to expand the clique (Set)\n    // X: Vertices already processed (Set)\n    // G: Graph represented as an adjacency list (Dictionary)\n    // Cliques: List to store all maximal cliques (List of Lists)\n\n    IF P is empty AND X is empty THEN\n        IF size of R > 2 THEN\n            SORT R lexicographically\n            ADD R to Cliques\n        END IF\n        RETURN\n    END IF\n\n    // Select a pivot vertex from P ∪ X with the maximum degree\n    Pivot := vertex in (P ∪ X) with the highest number of neighbors in G\n\n    // Candidates are vertices in P that are not neighbors of the pivot\n    Candidates := P - Neighbors(Pivot)\n\n    FOR EACH vertex v IN Candidates DO\n        // New clique including vertex v\n        NewR := R ∪ {v}\n\n        // New potential candidates are neighbors of v in P\n        Neighbors_v := G[v]\n        NewP := P ∩ Neighbors_v\n\n        // New excluded vertices are neighbors of v in X\n        NewX := X ∩ Neighbors_v\n\n        // Recursive call with updated sets\n        BronKerbosch(NewR, NewP, NewX, G, Cliques)\n\n        // Move vertex v from P to X\n        P := P - {v}\n        X := X ∪ {v}\n    END FOR\nEND FUNCTION\n\nFUNCTION Main()\n    // Define input edges as a list of tuples\n    Input := [\n        ('a', 'b'), ('b', 'a'), ('a', 'c'), ('c', 'a'),\n        ('b', 'c'), ('c', 'b'), ('d', 'e'), ('e', 'd'),\n        ('d', 'f'), ('f', 'd'), ('e', 'f'), ('f', 'e')\n    ]\n\n    // Build the graph as an adjacency list\n    Graph := empty Dictionary\n    FOR EACH (src, dest) IN Input DO\n        IF src NOT IN Graph THEN\n            Graph[src] := empty Set\n        END IF\n        ADD dest TO Graph[src]\n    END FOR\n\n    // Initialize R, P, X\n    R := empty Set\n    P := set of all vertices in Graph\n    X := empty Set\n\n    // Initialize list to store cliques\n    Cliques := empty List\n\n    // Execute the Bron-Kerbosch algorithm\n    BronKerbosch(R, P, X, Graph, Cliques)\n\n    // Sort the cliques for consistent output\n    SORT Cliques lexicographically\n\n    // Print each clique\n    FOR EACH Clique IN Cliques DO\n        PRINT elements of Clique separated by commas\n    END FOR\nEND FUNCTION\n\n```"}, {"role": "assistant", "content": "```\n# Returns all maximal Cliques as sorted List of Lists.\nsub BronKerbosch ( @undirected_edges ) {\n\n    #| Adjacency list of the whole Graph, as immutable hash (Map) of immutable Sets.\n    my Map $G = @undirected_edges\n                .map({ |( .[0,1], .[1,0] ) })\n                .classify( {.[0]}, :as{.[1]} )\n                .duckmap( *.Set )\n                .Map;\n\n    #| Number of neighbors in G\n    my Map $degree = $G.map({ .key => .value.elems }).Map;\n\n    return gather BK();\n\n    sub BK (\n        Set     :$R         = Set.new,              #= Current clique\n        SetHash :$P is copy = SetHash.new($G.keys), #= Potential candidates to expand the clique\n        SetHash :$X is copy = SetHash.new,          #= Vertices already processed\n    ) {\n        if !$P and !$X {\n            take $R.keys.sort.cache if $R.elems > 2;\n            return;\n        }\n\n        my $Pivot = ($P ∪ $X).max({ $degree{$_} }).key;\n\n        my @Candidates = ( $P (-) $G{$Pivot} ).keys;\n\n        for $G{@Candidates}:kv -> $v, $Neighbors_of_v {\n\n            &?ROUTINE.(     # Recursive call with updated sets\n                R => ($R ∪ $v),\n                P => ($P ∩ $Neighbors_of_v),\n                X => ($X ∩ $Neighbors_of_v),\n            );\n\n            # Move vertex v from P to X\n            $P{$v} = False;\n            $X{$v} = True;\n        }\n    }\n}\n\nsay .join(\",\") for sort BronKerbosch <a-b a-c b-c d-e d-f e-f>».split(\"-\");\n\n```\n\nOutput:\n\n```\na,b,c\nd,e,f\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Brownian\\_tree. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nGenerate and draw a   Brownian Tree.\n\nA Brownian Tree is generated as a result of an initial seed, followed by the interaction of two processes.\n\n1. The initial \"seed\" is placed somewhere within the field. Where is not particularly important; it could be randomized, or it could be a fixed point.\n2. Particles are injected into the field, and are individually given a (typically random) motion pattern.\n3. When a particle collides with the seed or tree, its position is fixed, and it's considered to be part of the tree.\n\nBecause of the lax rules governing the random nature of the particle's placement and motion, no two resulting trees are really expected to be the same, or even necessarily have the same general shape."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis solution spawns new Particles at a growing square border and displays the Tree every 50 particles and at the end using unicode UPPER/LOWER HALF BLOCK and FULL BLOCK.\n\n**Works with**: Rakudo version 2015.12\n\n```\nconstant size = 100;\nconstant particlenum = 1_000;\n\n\nconstant mid = size div 2;\n\nmy $spawnradius = 5;\nmy @map;\n\nsub set($x, $y) {\n    @map[$x][$y] = True;\n}\n\nsub get($x, $y) {\n    return @map[$x][$y] || False;\n}\n\nset(mid, mid);\nmy @blocks = \" \",\"\\c[UPPER HALF BLOCK]\", \"\\c[LOWER HALF BLOCK]\",\"\\c[FULL BLOCK]\";\n\nsub infix:<█>($a, $b) {\n    @blocks[$a + 2 * $b]\n}\n\nsub display {\n    my $start = 0;\n    my $end = size;\n    say (for $start, $start + 2 ... $end -> $y {\n        (for $start..$end -> $x {\n            if abs(($x&$y) - mid) < $spawnradius {\n                get($x, $y) █ get($x, $y+1);\n            } else {\n                \" \"\n            }\n        }).join\n    }).join(\"\\n\")\n}\n\nfor ^particlenum -> $progress {\n    my Int $x;\n    my Int $y;\n    my &reset = {\n        repeat {\n            ($x, $y) = (mid - $spawnradius..mid + $spawnradius).pick, (mid - $spawnradius, mid + $spawnradius).pick;\n            ($x, $y) = ($y, $x) if (True, False).pick();\n        } while get($x,$y);\n    }\n    reset;\n\n    while not get($x-1|$x|$x+1, $y-1|$y|$y+1) {\n        $x = ($x-1, $x, $x+1).pick;\n        $y = ($y-1, $y, $y+1).pick;\n        if (False xx 3, True).pick {\n            $x = $x >= mid ?? $x - 1 !! $x + 1;\n            $y = $y >= mid ?? $y - 1 !! $y + 1;\n        }\n        if abs(($x | $y) - mid) > $spawnradius {\n            reset;\n        }\n    }\n    set($x,$y);\n    if $spawnradius < mid && abs(($x|$y) - mid) > $spawnradius - 5 {\n        $spawnradius = $spawnradius + 1;\n    }\n}\n\ndisplay;\n\n```"}]}
{"messages": [{"role": "user", "content": "Description\n\nThe Brzozowski Algebraic Method is a technique used in automata theory, specifically for constructing the minimal deterministic finite automaton (DFA) from a given nondeterministic finite automaton (NFA). It was introduced by Janusz Brzozowski in 1962 and involves the use of algebraic transformations to simplify and optimize automata.\n\nAs the workings of the algorithm are clearly described in the linked article they will not be repeated here.\n\nTask\n\nImplement the Brzozowski Algebraic Method to convert an NFA representation into a regular expression. The implementation should:\n\n1. Take as input:\n\n```\n  - A 2D array 'a' representing the transition matrix of the NFA\n  - An array 'b' representing the final states\n\n```\n\n2. Include functionality to:\n\n```\n  - Handle basic regular expression operations (Empty, Epsilon, Character, Union, Concatenation, Star)\n  - Print regular expressions in a readable format\n  - Simplify regular expressions using algebraic rules\n\n```\n\n3. Apply the Brzozowski algorithm to:\n\n```\n  - Process the transition matrix in reverse order\n  - Update transitions using Star and Concatenation operations\n  - Combine paths using Union operations\n  - Generate a final regular expression representing the language accepted by the NFA\n\n```\n\n4. Include simplification rules for:\n\n```\n  - Eliminating redundant unions (e + e → e)\n  - Handling identity elements (e·1 → e, 1·e → e)\n  - Handling zero elements (e·0 → 0, 0·e → 0)\n  - Simplifying star operations (0* → 1, 1* → 1)\n\n```\n\nThe implementation should be able to process the given example input and produce both the raw and simplified regular expressions as output."}, {"role": "assistant", "content": "**Translation of**: Python\n\n```\n# 20241120 Raku programming solution\n\nrole RE1 { has $.c }\nrole RE2 { has ( $.e, $.f ) }\n\nclass Empty           { method Str { '0' } }\nclass Epsilon         { method Str { '1' } }\nclass Car    does RE1 { method Str { $.c } } # Caractère ?\nclass Star   does RE1 { method Str { \"($.c)*\" } }\nclass Union  does RE2 { method Str { \"$.e+$.f\" } }\nclass Concat does RE2 { method Str { \"($.e)($.f)\" } }\n\nmy ($empty, $epsilon) = (Empty, Epsilon)>>.new;\n\nsub simple-re($e is rw) {\n   sub do-simple($e) {\n      given $e {\n         when Union {\n            my ($ee,$ef) = ($e.e, $e.f).map: { do-simple $_ };\n            if    $ee ~~ $ef   { return $ee }\n            elsif $ee ~~ Union { do-simple(Union.new(e => $ee.e, f => Union.new(e => $ee.f, f => $ef))) }\n            elsif $ee ~~ Empty { return $ef }\n            elsif $ef ~~ Empty { return $ee }\n            else  { Union.new: e => $ee, f => $ef }\n         }\n         when Concat {\n            my ($ee,$ef) = ($e.e, $e.f).map: { do-simple $_ };\n            if    $ee ~~ Epsilon { return $ef }\n            elsif $ef ~~ Epsilon {  return $ee }\n            elsif $ee ~~ Empty || $ef ~~ Empty { return Empty }\n            elsif $ee ~~ Concat { do-simple(Concat.new(e => $ee.e, f => Concat.new(e => $ee.f, f => $ef))) }\n            else { Concat.new: e => $ee, f => $ef }\n         }\n         when Star {\n            given do-simple($e.c) {\n               $_ ~~ Empty | Epsilon ?? return Epsilon !! Star.new: c => $_\n            }      \n         }\n         default { $e }\n      }\n   }\n   my $prev = '';\n   until $e === $prev or $e.Str eq $prev { ($prev, $e) = $e, do-simple($e) }\n   return $e;\n}\n\nsub brzozowski(@a, @b) {\n   for @a.elems - 1 ... 0 -> \\n {\n      @b[n] = Concat.new(e => Star.new(c => @a[n;n]), f => @b[n]);\n      for ^n -> \\j {\n         @a[n;j] = Concat.new(e => Star.new(c => @a[n;n]), f => @a[n;j]);\n      }\n      for ^n -> \\i {\n         @b[i] = Union.new(e => @b[i], f => Concat.new(e => @a[i;n], f => @b[n]));\n         for ^n -> \\j {\n            @a[i;j] = Union.new(e => @a[i;j], f => Concat.new(e => @a[i;n], f => @a[n;j]));\n         }\n      }\n      for ^n -> \\i { @a[i;n] = $empty }\n   }\n   return @b[0]\n}\n\nmy @a = [\n    [$empty, Car.new(c => 'a'), Car.new(c => 'b')],\n    [Car.new(c => 'b'), $empty, Car.new(c => 'a')],\n    [Car.new(c => 'a'), Car.new(c => 'b'), $empty],\n];\nmy @b = [$epsilon, $empty, $empty];\n\nsay ( my $re = brzozowski(@a, @b) ).Str;\nsay simple-re($re).Str;\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Bulls and Cows   is an old game played with pencil and paper that was later implemented using computers.\n\nTask\n\nCreate a four digit random number from the digits   **1**   to   **9**,   without duplication.\n\nThe program should:\n\n:   :   :   :   :   :   * ask for guesses to this number\n                        * reject guesses that are malformed\n                        * print the score for the guess\n\nThe score is computed as:\n\n1. The player wins if the guess is the same as the randomly chosen number, and the program ends.\n2. A score of one **bull** is accumulated for each digit in the guess that equals the corresponding digit in the randomly chosen initial number.\n3. A score of one **cow** is accumulated for each digit in the guess that also appears in the randomly chosen number, but in the wrong position.\n\nRelated tasks\n\n* Bulls and cows/Player\n* Guess the number\n* Guess the number/With Feedback\n* Mastermind"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n**Works with**: Rakudo version 2015.12\n\n```\nmy $size = 4;\nmy @secret = pick $size, '1' .. '9';\n\nfor 1..* -> $guesses {\n    my @guess;\n    loop {\n        @guess = (prompt(\"Guess $guesses: \") // exit).comb;\n        last if @guess == $size and\n            all(@guess) eq one(@guess) & any('1' .. '9');\n        say 'Malformed guess; try again.';\n    }\n    my ($bulls, $cows) = 0, 0;\n    for ^$size {\n        when @guess[$_] eq @secret[$_] { ++$bulls; }\n        when @guess[$_] eq any @secret { ++$cows; }\n    }\n    last if $bulls == $size;\n    say \"$bulls bulls, $cows cows.\";\n}\n\nsay 'A winner is you!';\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a *player* of the Bulls and Cows game, rather than a scorer. The player should give intermediate answers that respect the scores to previous attempts.\n\nOne method is to generate a list of all possible numbers that could be the answer, then to prune the list by keeping only those numbers that would give an equivalent score to how your last guess was scored. Your next guess can be any number from the pruned list.  \nEither you guess correctly or run out of numbers to guess, which indicates a problem with the scoring.\n\nRelated tasks\n\n* Bulls and cows\n* Guess the number\n* Guess the number/With Feedback (Player)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\n**Translation of**: Perl\n\n```\n# we use the [] reduction meta operator along with the Cartesian Product\n# operator X to create the Cartesian Product of four times [1..9] and then get\n# all the elements where the number of unique digits is four.\nmy @candidates = ([X] [1..9] xx 4).grep: *.unique == 4;\n\nrepeat {\n\tmy $guess = @candidates.pick;\n\tmy ($bulls, $cows) = read-score;\n\t@candidates .= grep: &score-correct;\n\n\t# note how we declare our two subroutines within the repeat block. This\n\t# limits the scope in which the routines are known to the scope in which\n\t# they are needed and saves us a lot of arguments to our two routines.\n\tsub score-correct($a) {\n\t\tmy $exact = [+] $a >>==<< $guess;\n\n\t\t# number of elements of $a that match any element of $b\n\t\tmy $loose = +$a.grep: any @$guess;\n\n\t\treturn $bulls == $exact && $cows == $loose - $exact;\n\t}\n\n\tsub read-score() {\n\t\tloop {\n\t\t\tmy $score = prompt \"My guess: {$guess.join}.\\n\";\n\n\t\t\tif $score ~~ m:s/^ $<bulls>=(\\d) $<cows>=(\\d) $/\n\t\t\t\tand $<bulls> + $<cows> <= 4 {\n\t\t\t\treturn +$<bulls>, +$<cows>;\n\t\t\t}\n\n\t\t\tsay \"Please specify the number of bulls and cows\";\n\t\t}\n\t}\n} while @candidates > 1;\n\nsay @candidates\n\t?? \"Your secret number is {@candidates[0].join}!\"\n\t!! \"I think you made a mistake with your scoring.\";\n\n```\n\nOutput:\n\n```\nMy guess: 4235.\n2 1\nMy guess: 1435.\n2 1\nMy guess: 1245.\n2 1\nYour secret number is 1234!\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Burrows–Wheeler\\_transform. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThe Burrows–Wheeler transform (BWT, also called block-sorting compression) rearranges a character string into runs of similar characters.\n\nThis is useful for compression, since it tends to be easy to compress a string that has runs of repeated characters by techniques such as move-to-front transform and run-length encoding.\n\nMore importantly, the transformation is reversible, without needing to store any additional data.\n\nThe BWT is thus a \"free\" method of improving the efficiency of text compression algorithms, costing only some extra computation.\n\nSource: Burrows–Wheeler transform"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.06\n\n```\n# STX can be any character that doesn't appear in the text.\n# Using a visible character here for ease of viewing. \n \nconstant \\STX = '👍';\n\n# Burrows-Wheeler transform\nsub transform (Str $s is copy) {\n    note \"String can't contain STX character.\" and exit if $s.contains: STX;\n    $s = STX ~ $s;\n    (^$s.chars).map({ $s.comb.list.rotate: $_ }).sort[*;*-1].join\n}\n \n# Burrows-Wheeler inverse transform\nsub ɯɹoɟsuɐɹʇ (Str $s) {\n    my @t = $s.comb.sort;\n    @t = ($s.comb Z~ @t).sort for 1..^$s.chars;\n    @t.first( *.ends-with: STX ).chop\n}\n \n# TESTING\nfor |<BANANA dogwood SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES>,\n    'TO BE OR NOT TO BE OR WANT TO BE OR NOT?', \"Oops{STX}\"\n    -> $phrase {\n    say 'Original:            ', $phrase;\n    say 'Transformed:         ', transform $phrase;\n    say 'Inverse transformed: ', ɯɹoɟsuɐɹʇ transform $phrase;\n    say '';\n}\n\n```\n\nOutput:\n\n```\nOriginal:            BANANA\nTransformed:         BNN👍AAA\nInverse transformed: BANANA\n\nOriginal:            dogwood\nTransformed:         👍ooodwgd\nInverse transformed: dogwood\n\nOriginal:            SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES\nTransformed:         TEXYDST.E.IXIXIXXSSMPPS.B..E.👍.UESFXDIIOIIITS\nInverse transformed: SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES\n\nOriginal:            TO BE OR NOT TO BE OR WANT TO BE OR NOT?\nTransformed:         OOORREEETTRTW   BBB  ATTT   NNOOONOO👍   ?\nInverse transformed: TO BE OR NOT TO BE OR WANT TO BE OR NOT?\n\nOriginal:            Oops👍\nString can't contain STX character.\n```"}]}
{"messages": [{"role": "user", "content": "You are given two planar quadratic Bézier curves, having control points \n\n(\n−\n1\n,\n0\n)\n,\n(\n0\n,\n10\n)\n,\n(\n1\n,\n0\n)\n{\\displaystyle {\\displaystyle (-1,0),(0,10),(1,0)}}\n and \n\n(\n2\n,\n1\n)\n,\n(\n−\n8\n,\n2\n)\n,\n(\n2\n,\n3\n)\n{\\displaystyle {\\displaystyle (2,1),(-8,2),(2,3)}}\n, respectively. They are parabolas intersecting at four points, as shown in the following diagram:\n\nThe task is to write a program that finds all four intersection points and prints their \n\n(\nx\n,\ny\n)\n{\\displaystyle {\\displaystyle (x,y)}}\n coordinates. You may use any algorithm you know of or can think of, including any of those that others have used.\n\n### See also\n\n* Bitmap/Bézier curves/Quadratic\n* Steffensen's method"}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20231025 Raku programming solution\n\nclass Point { has ($.x, $.y) is rw is default(0) }\n\nclass QuadSpline { has ($.c0, $.c1, $.c2) is rw is default(0) }\n\nclass QuadCurve { has QuadSpline ($.x, $.y) is rw }\n\nclass Workset { has QuadCurve ($.p, $.q) }\n\nsub subdivideQuadSpline($q, $t) {\n   my $s = 1.0 - $t;\n   my ($c0,$c1,$c2) = do given $q { .c0, .c1, .c2 }; \n   my $u_c1 = $s*$c0 + $t*$c1;\n   my $v_c1 = $s*$c1 + $t*$c2;\n   my $u_c2 = $s*$u_c1 + $t*$v_c1;\n   return ($c0, $u_c1, $u_c2), ($u_c2, $v_c1, $c2)\n}\n\nsub subdivideQuadCurve($q, $t, $u is rw, $v is rw) {\n   with (subdivideQuadSpline($q.x,$t),subdivideQuadSpline($q.y,$t))».List.flat {\n      $u=QuadCurve.new(x => QuadSpline.new(c0 => .[0],c1 => .[1],c2 => .[2]),\n                       y => QuadSpline.new(c0 => .[6],c1 => .[7],c2 => .[8]));\n      $v=QuadCurve.new(x => QuadSpline.new(c0 => .[3],c1 => .[4],c2 => .[5]),\n                       y => QuadSpline.new(c0 => .[9],c1 => .[10],c2 => .[11]))\n   }\n}\n\nsub seemsToBeDuplicate(@intersects, $xy, $spacing) {\n   my $seemsToBeDup = False;\n   for @intersects {\n      $seemsToBeDup = abs(.x - $xy.x) < $spacing && abs(.y - $xy.y) < $spacing;\n      last if $seemsToBeDup;\n   }\n   return $seemsToBeDup;\n}\n\nsub rectsOverlap($xa0, $ya0, $xa1, $ya1, $xb0, $yb0, $xb1, $yb1) {\n   return $xb0 <= $xa1 && $xa0 <= $xb1 && $yb0 <= $ya1 && $ya0 <= $yb1\n}\n\nsub testIntersect($p,$q,$tol,$exclude is rw,$accept is rw,$intersect is rw) {\n   my $pxmin = min($p.x.c0, $p.x.c1, $p.x.c2);\n   my $pymin = min($p.y.c0, $p.y.c1, $p.y.c2);\n   my $pxmax = max($p.x.c0, $p.x.c1, $p.x.c2);\n   my $pymax = max($p.y.c0, $p.y.c1, $p.y.c2);\n   my $qxmin = min($q.x.c0, $q.x.c1, $q.x.c2);\n   my $qymin = min($q.y.c0, $q.y.c1, $q.y.c2);\n   my $qxmax = max($q.x.c0, $q.x.c1, $q.x.c2);\n   my $qymax = max($q.y.c0, $q.y.c1, $q.y.c2);\n   ($exclude, $accept) = True, False;\n\n   if rectsOverlap($pxmin,$pymin,$pxmax,$pymax,$qxmin,$qymin,$qxmax,$qymax) {\n      $exclude = False;\n      my ($xmin,$xmax) = max($pxmin, $qxmin), min($pxmax, $pxmax);\n      if ($xmax < $xmin) { die \"Assertion failure: $xmax < $xmin\\n\" }\n      my ($ymin,$ymax) = max($pymin, $qymin), min($pymax, $qymax);\n      if ($ymax < $ymin) { die \"Assertion failure: $ymax < $ymin\\n\" }\n      if $xmax - $xmin <= $tol and $ymax - $ymin <= $tol {\n         $accept = True;\n         given $intersect { (.x, .y) = 0.5 X* $xmin+$xmax, $ymin+$ymax }\n      }\n   }\n}\n\nsub find-intersects($p, $q, $tol, $spacing) {\n   my Point @intersects;\n   my @workload = Workset.new(p => $p, q => $q);\n\n   while my $work = @workload.pop {\n      my ($intersect,$exclude,$accept) = Point.new, False, False;\n      testIntersect($work.p, $work.q, $tol, $exclude, $accept, $intersect); \n      if $accept {\n         unless seemsToBeDuplicate(@intersects, $intersect, $spacing) {\n            @intersects.push: $intersect;\n         }\n      } elsif not $exclude {\n         my QuadCurve ($p0, $p1, $q0, $q1);\n         subdivideQuadCurve($work.p, 0.5, $p0, $p1);\n         subdivideQuadCurve($work.q, 0.5, $q0, $q1);\n         for $p0, $p1 X $q0, $q1 { \n            @workload.push: Workset.new(p => .[0], q => .[1]) \n         }\n      }\n   }\n   return @intersects;\n}\n\nmy $p = QuadCurve.new( x => QuadSpline.new(c0 => -1.0,c1 =>  0.0,c2 => 1.0),\n                       y => QuadSpline.new(c0 =>  0.0,c1 => 10.0,c2 => 0.0));\nmy $q = QuadCurve.new( x => QuadSpline.new(c0 =>  2.0,c1 => -8.0,c2 => 2.0),\n                       y => QuadSpline.new(c0 =>  1.0,c1 =>  2.0,c2 => 3.0));\nmy $spacing = ( my $tol = 0.0000001 ) * 10;\n.say for find-intersects($p, $q, $tol, $spacing);\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a Caesar cipher, both encoding and decoding.   \nThe key is an integer from 1 to 25.\n\nThis cipher rotates (either towards left or right) the letters of the alphabet (A to Z).\n\nThe encoding replaces each letter with the 1st to 25th next letter in the alphabet (wrapping Z to A).\n  \nSo key 2 encrypts \"HI\" to \"JK\", but key 20 encrypts \"HI\" to \"BC\".\n\nThis simple \"mono-alphabetic substitution cipher\" provides almost no security, because an attacker who has the encoded message can either use frequency analysis to guess the key, or just try all 25 keys.\n\nCaesar cipher is identical to Vigenère cipher with a key of length 1.   \nAlso, Rot-13 is identical to Caesar cipher with key 13.\n\nRelated tasks\n\n* Rot-13\n* Substitution Cipher\n* Vigenère Cipher/Cryptanalysis"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nmy @alpha = 'A' .. 'Z';\nsub encrypt ( $key where 1..25, $plaintext ) {\n    $plaintext.trans( @alpha Z=> @alpha.rotate($key) );\n}\nsub decrypt ( $key where 1..25, $cyphertext ) {\n    $cyphertext.trans( @alpha.rotate($key) Z=> @alpha );\n}\n\nmy $original = 'THE FIVE BOXING WIZARDS JUMP QUICKLY';\nmy $en = encrypt( 13, $original );\nmy $de = decrypt( 13, $en );\n\n.say for $original, $en, $de;\n\nsay 'OK' if $original eq all( map { .&decrypt(.&encrypt($original)) }, 1..25 );\n```\n\nOutput:\n\n```\nTHE FIVE BOXING WIZARDS JUMP QUICKLY\nGUR SVIR OBKVAT JVMNEQF WHZC DHVPXYL\nTHE FIVE BOXING WIZARDS JUMP QUICKLY\nOK\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCalculate the value of   *e*.\n\n(*e*   is also known as   *Euler's number*   and   *Napier's constant*.)\n\nSee details: Calculating the value of e"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2023.09\n\n```\n# If you need high precision: Sum of a Taylor series method.\n# Adjust the terms parameter to suit. Theoretically the\n# terms could be ∞. Practically, calculating an infinite\n# series takes an awfully long time so limit to 500.\n\nconstant 𝑒 = [\\+] flat 1, [\\/] 1.FatRat..*;\n\n.say for 𝑒[500].comb(80);\n\nsay '';\n\n# Or, if you don't need high precision, it's a built-in.\nsay e;\n\n```\n\nOutput:\n\n```\n2.718281828459045235360287471352662497757247093699959574966967627724076630353547\n59457138217852516642742746639193200305992181741359662904357290033429526059563073\n81323286279434907632338298807531952510190115738341879307021540891499348841675092\n44761460668082264800168477411853742345442437107539077744992069551702761838606261\n33138458300075204493382656029760673711320070932870912744374704723069697720931014\n16928368190255151086574637721112523897844250569536967707854499699679468644549059\n87931636889230098793127736178215424999229576351482208269895193668033182528869398\n49646510582093923982948879332036250944311730123819706841614039701983767932068328\n23764648042953118023287825098194558153017567173613320698112509961818815930416903\n51598888519345807273866738589422879228499892086805825749279610484198444363463244\n96848756023362482704197862320900216099023530436994184914631409343173814364054625\n31520961836908887070167683964243781405927145635490613031072085103837505101157477\n04171898610687396965521267154688957035035402123407849819334321068170121005627880\n23519303322474501585390473041995777709350366041699732972508868769664035557071622\n68447162560798827\n\n2.718281828459045\n```"}]}
{"messages": [{"role": "user", "content": "Create a routine that will generate a text calendar for any year.\nTest the calendar by generating a calendar for the year 1969, on a device of the time.\nChoose one of the following devices:\n\n* A line printer with a width of 132 characters.\n* An IBM 3278 model 4 terminal (80×43 display with accented characters). Target formatting the months of the year to fit nicely across the 80 character width screen. Restrict number of lines in test output to 43.\n\n(Ideally, the program will generate well-formatted calendars for any page width from 20 characters up.)\n\nKudos (κῦδος) for routines that also transition from Julian to Gregorian calendar.\n\nThis task is inspired by Real Programmers Don't Use PASCAL by Ed Post, Datamation, volume 29 number 7, July 1983.\n\n```\nTHE REAL PROGRAMMER'S NATURAL HABITAT\n\"Taped to the wall is a line-printer Snoopy calender for the year 1969.\"\n\n```\n\nFor further Kudos see task CALENDAR, where all code is to be in UPPERCASE.\n\nFor economy of size, do not actually include Snoopy generation in either the code or the output, instead just output a place-holder.\n\nSee Also\n:   * Snoopy calendar 1969-2025 Marcel van der Veer - The deck is credited as being one of the first FOSS programs.\n\nRelated task\n:   * Five weekends"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $months-per-row = 3;\nmy @weekday-names  = <Mo Tu We Th Fr Sa Su>;\nmy @month-names    = <Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec>;\n\nmy Int() $year = @*ARGS.shift || 1969;\nsay fmt-year($year);\n\nsub fmt-year ($year) {\n    my @month-strs;\n    @month-strs[$_] = [fmt-month($year, $_).lines] for 1 .. 12;\n    my @C = ' ' x 30 ~ $year, '';\n    for 1, 1+$months-per-row ... 12 -> $month {\n        while @month-strs[$month] {\n            for ^$months-per-row -> $column {\n                @C[*-1] ~= @month-strs[$month+$column].shift ~ ' ' x 3 if @month-strs[$month+$column];\n            }\n            @C.push: '';\n        }\n        @C.push: '';\n    }\n    @C.join: \"\\n\";\n}\n\nsub fmt-month ($year, $month) {\n    my $date = Date.new($year,$month,1);\n    @month-names[$month-1].fmt(\"%-20s\\n\") ~ @weekday-names ~ \"\\n\" ~\n    (('  ' xx $date.day-of-week - 1), (1..$date.days-in-month)».fmt('%2d')).flat.rotor(7, :partial).join(\"\\n\") ~\n    (' ' if $_ < 7) ~ ('  ' xx 7-$_).join(' ') given Date.new($year, $month, $date.days-in-month).day-of-week;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nProvide an algorithm as per the Calendar task, except the entire code for the algorithm must be presented   *entirely without lowercase*.\n\nAlso - as per many 1969 era line printers - format the calendar to nicely fill a page that is 132 characters wide.\n\n(Hint: manually convert the code from the Calendar task to all UPPERCASE)\n\nThis task also is inspired by Real Programmers Don't Use PASCAL by Ed Post, Datamation, volume 29 number 7, July 1983.\n\n```\nTHE REAL PROGRAMMER'S NATURAL HABITAT\n\"Taped to the wall is a line-printer Snoopy calender for the year 1969.\"\n\n```\n\nMoreover this task is further inspired by the *long lost* corollary article titled:\n\n```\n\"Real programmers think in UPPERCASE\"!\n\n```\n\nNote: Whereas today we *only* need to worry about ASCII, UTF-8, UTF-16, UTF-32, UTF-7 and UTF-EBCDIC encodings, in the 1960s having code in UPPERCASE was often mandatory as characters were often stuffed into 36-bit words as 6 lots of 6-bit characters. More extreme words sizes include 60-bit words of the CDC 6000 series computers. The Soviets even had a national character set that was inclusive of all\n4-bit,\n5-bit,\n6-bit &\n7-bit depending on how the file was opened... **And** one rogue Soviet university went further and built a 1.5-bit based computer.\n\nOf course... as us Boomers have turned into Geezers we have become HARD OF HEARING,\nand suffer from chronic Presbyopia, hence programming in UPPERCASE\nis less to do with computer architecture and more to do with practically. :-)\n\nFor economy of size, do not actually include Snoopy generation\nin either the code or the output, instead just output a place-holder.\n\nFYI: a nice ASCII art file of Snoopy can be found at textfiles.com. Save with a .txt extension.\n\n**Trivia:** The terms uppercase and lowercase date back to the early days of the mechanical printing press. Individual metal alloy casts of each needed letter, or punctuation symbol, were meticulously added to a press block, by hand, before rolling out copies of a page. These metal casts were stored and organized in wooden cases. The more often needed *minuscule* letters were placed closer to hand, in the lower cases of the work bench. The less often needed, capitalized, *majuscule* letters, ended up in the harder to reach upper cases."}, {"role": "assistant", "content": "(formerly Perl 6)\nUppercase is no challenge, who needs letters at all?\n[Requires the year to be supplied as a command-line argument, and Unixish *cal* command.]\n\n```\n$_=\"\\0\"..\"~\";<\n115 97 121 32 34 91 73 78 83 69 82 84 32 83 78 79 79 80 89 32 72 69 82 69 93 34\n59 114 117 110 32 60 99 97 108 62 44 64 42 65 82 71 83 91 48 93 47 47 49 57 54 57\n>.\"$_[99]$_[104]$_[114]$_[115]\"().\"$_[69]$_[86]$_[65]$_[76]\"()\n\n```"}]}
{"messages": [{"role": "user", "content": "The **Calkin-Wilf sequence** contains every nonnegative rational number exactly once.\n\nIt can be calculated recursively as follows:\n\n```\n       a1   =  1 \n       an+1  =  1/(2⌊an⌋+1-an) for n > 1 \n\n```\n\nTask part 1\n\n* Show on this page terms 1 through 20 of the Calkin-Wilf sequence.\n\nTo avoid floating point error, you may want to use a rational number data type.\n\nIt is also possible, given a non-negative rational number, to determine where it appears in the sequence without calculating the sequence. The procedure is to get the continued fraction representation of the rational and use it as the run-length encoding of the binary representation of the term number, beginning from the end of the continued fraction.\nIt only works if the number of terms in the continued fraction is odd- use either of the two equivalent representations to achieve this:\n\n```\n       [a0; a1, a2, ..., an]  =  [a0; a1, a2 ,..., an-1, 1] \n\n```\n\nExample\n\nThe fraction   **9/4**   has odd continued fraction representation      2; 3, 1,     giving a binary representation of   **100011**,\n  \nwhich means   **9/4**   appears as the   **35th**   term of the sequence.\n\nTask part 2\n\n* Find the position of the number   **83116****/****51639**   in the Calkin-Wilf sequence.\n\nRelated tasks\n:   * Fusc sequence.\n\nSee also\n\n* Wikipedia entry: Calkin-Wilf tree\n* Continued fraction\n* Continued fraction/Arithmetic/Construct from rational number"}, {"role": "assistant", "content": "In Raku, arrays are indexed from 0. The Calkin-Wilf sequence does not have a term defined at 0.\n\nThis implementation includes a bogus undefined value at position 0, having the bogus first term shifts the indices up by one, making the ordinal position and index match. Useful due to how reversibility function works.\n\n```\nmy @calkin-wilf = Any, 1, {1 / (.Int × 2 + 1 - $_)} … *;\n\n# Rational to Calkin-Wilf index\nsub r2cw (Rat $rat) { :2( join '', flat (flat (1,0) xx *) Zxx reverse r2cf $rat ) }\n\n# The task\n\nsay \"First twenty terms of the Calkin-Wilf sequence: \",\n    @calkin-wilf[1..20]».&prat.join: ', ';\n\nsay \"\\n99991st through 100000th: \",\n    (my @tests = @calkin-wilf[99_991 .. 100_000])».&prat.join: ', ';\n\nsay \"\\nCheck reversibility: \", @tests».Rat».&r2cw.join: ', ';\n\nsay \"\\n83116/51639 is at index: \", r2cw 83116/51639;\n\n\n# Helper subs\nsub r2cf (Rat $rat is copy) { # Rational to continued fraction\n    gather loop {\n\t    $rat -= take $rat.floor;\n\t    last if !$rat;\n\t    $rat = 1 / $rat;\n    }\n}\n\nsub prat ($num) { # pretty Rat\n    return $num unless $num ~~ Rat|FatRat;\n    return $num.numerator if $num.denominator == 1;\n    $num.nude.join: '/';\n}\n\n```\n\nOutput:\n\n```\nFirst twenty terms of the Calkin-Wilf sequence: 1, 1/2, 2, 1/3, 3/2, 2/3, 3, 1/4, 4/3, 3/5, 5/2, 2/5, 5/3, 3/4, 4, 1/5, 5/4, 4/7, 7/3, 3/8\n\n99991st through 100000th: 1085/303, 303/1036, 1036/733, 733/1163, 1163/430, 430/987, 987/557, 557/684, 684/127, 127/713\n\nCheck reversibility: 99991, 99992, 99993, 99994, 99995, 99996, 99997, 99998, 99999, 100000\n\n83116/51639 is at index: 123456789\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow how a foreign language function can be called from the language.\n\nAs an example, consider calling functions defined in the C language. Create a string containing \"Hello World!\" of the string type typical to the language. Pass the string content to C's `strdup`. The content can be copied if necessary. Get the result from `strdup` and print it using language means. Do not forget to free the result of `strdup` (allocated in the heap).\n\nNotes\n\n* It is not mandated if the C run-time library is to be loaded statically or dynamically. You are free to use either way.\n* C++ and C solutions can take some other language to communicate with.\n* It is *not* mandatory to use `strdup`, especially if the foreign function interface being demonstrated makes that uninformative.\n\nSee also\n\n* Use another language to call a function"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.07\n\n```\nuse NativeCall;\n\nsub strdup(Str $s --> Pointer) is native {*}\nsub puts(Pointer $p --> int32) is native {*}\nsub free(Pointer $p --> int32) is native {*}\n\nmy $p = strdup(\"Success!\");\nsay 'puts returns ', puts($p);\nsay 'free returns ', free($p);\n\n```\n\nOutput:\n\n```\nSuccess!\nputs returns 9\nfree returns 0\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate the different syntax and semantics provided for calling a function.\n\nThis may include:\n\n:   * Calling a function that requires no arguments\n    * Calling a function with a fixed number of arguments\n    * Calling a function with optional arguments\n    * Calling a function with a variable number of arguments\n    * Calling a function with named arguments\n    * Using a function in statement context\n    * Using a function in first-class context within an expression\n    * Obtaining the return value of a function\n    * Distinguishing built-in functions and user-defined functions\n    * Distinguishing subroutines and functions\n    * Stating whether arguments are passed by value or by reference\n    * Is partial application possible and how\n\nThis task is *not* about defining functions."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Theory\n\nFundamentally, nearly everything you do in Raku is a function call if you look hard enough.\nAt the lowest level, a function call merely requires a reference to any\nkind of invokable object, and a call to its postcircumfix:<( )> method.\nHowever, there are various forms of sugar and indirection that you\ncan use to express these function calls differently. In particular,\noperators are all just sugar for function calls.\n\nCalling a function that requires no arguments:\n\n```\nfoo               # as list operator\nfoo()             # as function\nfoo.()            # as function, explicit postfix form\n$ref()            # as object invocation\n$ref.()           # as object invocation, explicit postfix\n&foo()            # as object invocation\n&foo.()           # as object invocation, explicit postfix\n::($name)()       # as symbolic ref\n```\n\nCalling a function with exactly one argument:\n\n```\nfoo 1             # as list operator\nfoo(1)            # as named function\nfoo.(1)           # as named function, explicit postfix\n$ref(1)           # as object invocation (must be hard ref)   \n$ref.(1)          # as object invocation, explicit postfix\n1.$foo            # as pseudo-method meaning $foo(1) (hard ref only)\n1.$foo()          # as pseudo-method meaning $foo(1) (hard ref only)\n1.&foo            # as pseudo-method meaning &foo(1) (is hard foo)\n1.&foo()          # as pseudo-method meaning &foo(1) (is hard foo)\n1.foo             # as method via dispatcher\n1.foo()           # as method via dispatcher\n1.\"$name\"()       # as method via dispatcher, symbolic\n+1                # as operator to prefix:<+> function\n```\n\nMethod calls are included here because they do eventually dispatch to a true\nfunction via a dispatcher. However, the dispatcher in question is not going\nto dispatch to the same set of functions that a function call of that name\nwould invoke. That's why there's a dispatcher, after all. Methods are declared\nwith a different keyword, method, in Raku, but all that does is\ninstall the actual function into a metaclass. Once it's there, it's merely\na function that expects its first argument to be the invocant object. Hence we\nfeel justified in including method call syntax as a form of indirect function call.\n\nOperators like + also go through a dispatcher, but in this case it is\nmultiply dispatched to all lexically scoped candidates for the function. Hence\nthe candidate list is bound early, and the function itself can be bound early\nif the type is known. Raku maintains a clear distinction between early-bound\nlinguistic constructs that force Perlish semantics, and late-bound OO dispatch\nthat puts the objects and/or classes in charge of semantics. (In any case, &foo,\nthough being a hard ref to the function named \"foo\", may actually be a ref to\na dispatcher to a list of candidates that, when called, makes all the candidates behave as a single unit.)\n\nCalling a function with exactly two arguments:\n\n```\nfoo 1,2           # as list operator\nfoo(1,2)          # as named function\nfoo.(1,2)         # as named function, explicit postfix\n$ref(1,2)         # as object invocation (must be hard ref)\n$ref.(1,2)        # as object invocation, explicit postfix\n1.$foo: 2         # as pseudo-method meaning $foo(1,2) (hard ref only)\n1.$foo(2)         # as pseudo-method meaning $foo(1,2) (hard ref only)\n1.&foo: 2         # as pseudo-method meaning &foo(1,2) (is hard foo)\n1.&foo(2)         # as pseudo-method meaning &foo(1,2) (is hard foo)\n1.foo: 2          # as method via dispatcher\n1.foo(2)          # as method via dispatcher\n1.\"$name\"(2)      # as method via dispatcher, symbolic\n1 + 2             # as operator to infix:<+> function\n```\n\nOptional arguments don't look any different from normal arguments.\nThe optionality is all on the binding end.\n\nCalling a function with a variable number of arguments (varargs):\n\n```\nfoo @args         # as list operator\nfoo(@args)        # as named function\nfoo.(@args)       # as named function, explicit postfix\n$ref(@args)       # as object invocation (must be hard ref)\n$ref.(@args)      # as object invocation, explicit postfix\n1.$foo: @args     # as pseudo-method meaning $foo(1,@args) (hard ref)\n1.$foo(@args)     # as pseudo-method meaning $foo(1,@args) (hard ref)\n1.&foo: @args     # as pseudo-method meaning &foo(1,@args)\n1.&foo(@args)     # as pseudo-method meaning &foo(1,@args)\n1.foo: @args      # as method via dispatcher\n1.foo(@args)      # as method via dispatcher\n1.\"$name\"(@args)  # as method via dispatcher, symbolic\n@args X @blargs   # as list infix operator to infix:<X>\n```\n\nNote: whether a function may actually be called with a variable number of arguments depends entirely\non whether a signature accepts a list at that position in the argument list, but\ndescribing that is not the purpose of this task. Suffice to say that we assume here that the\nfoo function is declared with a signature of the form (\\*@params). The calls above might be interpreted as having a single array argument if the signature indicates a normal parameter instead of a variadic one. What you cannot do in Raku (unlike Perl 5) is pass an array as several fixed arguments. By default it must either represent a single argument, or be part of a variadic list. You can force the extra level of argument list interpolation using a prefix | however:\n\n```\nmy @args = 1,2,3;\nfoo(|@args);  # equivalent to foo(1,2,3)\n```\n\nCalling a function with named arguments:\n\n```\nfoo :a, :b(4), :!c, d => \"stuff\"\nfoo(:a, :b(4), :!c, d => \"stuff\")\n```\n\n...and so on. Operators may also be called with named arguments, but only\ncolon adverbials are allowed:\n\n```\n1 + 1 :a :b(4) :!c :d(\"stuff\")   # calls infix:<+>(1,1,:a, :b(4), :!c, d => \"stuff\")\n```\n\nUsing a function in statement context:\n\n```\nfoo(); bar(); baz();    # evaluate for side effects\n```\n\nUsing a function in first class context within an expression:\n\n```\n1 / find-a-func(1,2,3)(4,5,6) ** 2;\n```\n\nObtaining the return value of a function:\n\n```\nmy $result = somefunc(1,2,3) + 2;\n```\n\nThere is no difference between calling builtins and user-defined functions and operators (or\neven control stuctures). This was a major design goal of Raku, and apart from a very few\nlow-level primitives, all of Raku can be written in Raku.\n\nThere is no difference between calling subroutines and functions in Raku, other than that\ncalling a function in void context that has no side effects is likely to get you a \"Useless use of...\" warning.\nAnd, of course, the fact that pure functions can participate in more optimizations such as constant folding.\n\nBy default, arguments are passed readonly, which allows the implementation to decide whether pass-by-reference or pass-by-value is more efficient on a case-by-case basis. Explicit lvalue, reference, or copy semantics may be requested on a parameter-by-parameter basis, and the entire argument list may be processed raw if that level of control is needed.\n\n### Practice\n\nDemonstrating each of the above-mentioned function calls with actual running code, along with the various extra definitions required to make them work (in certain cases). Arguments are checked, and function name / run-sequence number are displayed upon success.\n\n```\n{\nstate $n;\n\nmulti f ()          {                                    print ' f' ~ ++$n }\nmulti f ($a)        { die if 1  != $a;                   print ' f' ~ ++$n }\nmulti f ($a,$b)     { die if 3  != $a+$b;                print ' f' ~ ++$n }\nmulti f (@a)        { die if @a != [2,3,4];              print ' f' ~ ++$n }\nmulti f ($a,$b,$c)  { die if 2  != $a || 4 != $c;        print ' f' ~ ++$n }\nsub   g ($a,*@b)    { die if @b != [2,3,4] || 1 != $a;   print ' g' ~ ++$n }\n\nmy \\i = ->          {                                    print ' i' ~ ++$n }\nmy \\l = -> $a       { die if 1 != $a;                    print ' l' ~ ++$n }\nmy \\m = -> $a,$b    { die if 1 != $a || 2 != $b;         print ' m' ~ ++$n }\nmy \\n = -> @a       { die if @a != [2,3,4];              print ' n' ~ ++$n }\n\nInt.^add_method( 'j', method ()\n                    { die if 1 != self;                  print ' j' ~ ++$n } );\nInt.^add_method( 'k', method ($a)\n                    { die if 1 != self || 2 != $a;       print ' k' ~ ++$n } );\nInt.^add_method( 'h', method (@a)\n                    { die if @a != [2,3,4] || 1 != self; print ' h' ~ ++$n } );\n\nmy $ref   =  &f;  # soft ref\nmy $f    :=  &f;  # hard ref\nmy $g    :=  &g;  # hard ref\nmy $f-sym = '&f'; # symbolic ref\nmy $g-sym = '&g'; # symbolic ref\nmy $j-sym =  'j'; # symbolic ref\nmy $k-sym =  'k'; # symbolic ref\nmy $h-sym =  'h'; # symbolic ref\n\n# Calling a function with no arguments:\n\nf;            #  1  as list operator\nf();          #  2  as function\ni.();         #  3  as function, explicit postfix form  # defined via pointy-block\n$ref();       #  4  as object invocation\n$ref.();      #  5  as object invocation, explicit postfix\n&f();         #  6  as object invocation\n&f.();        #  7  as object invocation, explicit postfix\n::($f-sym)(); #  8  as symbolic ref\n\n# Calling a function with exactly one argument:\n\nf 1;          #   9  as list operator\nf(1);         #  10  as named function\nl.(1);        #  11  as named function, explicit postfix  # defined via pointy-block\n$f(1);        #  12  as object invocation (must be hard ref)\n$ref.(1);     #  13  as object invocation, explicit postfix\n1.$f;         #  14  as pseudo-method meaning $f(1) (hard ref only)\n1.$f();       #  15  as pseudo-method meaning $f(1) (hard ref only)\n1.&f;         #  16  as pseudo-method meaning &f(1) (is hard f)\n1.&f();       #  17  as pseudo-method meaning &f(1) (is hard f)\n1.j;          #  18  as method via dispatcher             # requires custom method, via 'Int.^add_method'\n1.j();        #  19  as method via dispatcher\n1.\"$j-sym\"(); #  20  as method via dispatcher, symbolic\n\n# Calling a function with exactly two arguments:\n\nf 1,2;         #  21  as list operator\nf(1,2);        #  22  as named function\nm.(1,2);       #  23  as named function, explicit postfix  # defined via pointy-block\n$ref(1,2);     #  24  as object invocation (must be hard ref)\n$ref.(1,2);    #  25  as object invocation, explicit postfix\n1.$f: 2;       #  26  as pseudo-method meaning $f(1,2) (hard ref only)\n1.$f(2);       #  27  as pseudo-method meaning $f(1,2) (hard ref only)\n1.&f: 2;       #  28  as pseudo-method meaning &f(1,2) (is hard f)\n1.&f(2);       #  29  as pseudo-method meaning &f(1,2) (is hard f)\n1.k: 2;        #  30  as method via dispatcher             # requires custom method, via 'Int.^add_method'\n1.k(2);        #  31  as method via dispatcher\n1.\"$k-sym\"(2); #  32  as method via dispatcher, symbolic\n\n# Calling a function with a variable number of arguments (varargs):\n\nmy @args = 2,3,4;\n\nf @args;           #  33  as list operator\nf(@args);          #  34  as named function\nn.(@args);         #  35  as named function, explicit postfix   # defined via pointy-block\n$ref(@args);       #  36  as object invocation (must be hard ref)\n$ref.(@args);      #  37  as object invocation, explicit postfix\n1.$g: @args;       #  38  as pseudo-method meaning $f(1,@args) (hard ref)\n1.$g(@args);       #  39  as pseudo-method meaning $f(1,@args) (hard ref)\n1.&g: @args;       #  40  as pseudo-method meaning &f(1,@args)\n1.&g(@args);       #  41  as pseudo-method meaning &f(1,@args)\n1.h: @args;        #  42  as method via dispatcher              # requires custom method, via 'Int.^add_method'\n1.h(@args);        #  43  as method via dispatcher\n1.\"$h-sym\"(@args); #  44  as method via dispatcher, symbolic\nf(|@args);         #  45  equivalent to f(1,2,3)\n\n}\n```\n\nOutput:\n\n```\nf1 f2 i3 f4 f5 f6 f7 f8 f9 f10 l11 f12 f13 f14 f15 f16 f17 j18 j19 j20 f21 f22 m23 f24 f25 f26 f27 f28 f29 k30 k31 k32 f33 f34 n35 f36 f37 g38 g39 g40 g41 h42 h43 h44 f45\n```"}]}
{"messages": [{"role": "user", "content": "Show how to call a function in a shared library (without dynamically linking to it at compile-time). In particular, show how to call the shared library function if the library is available, otherwise use an internal equivalent function.\n\nThis is a special case of calling a foreign language function where the focus is close to the ABI level and not at the normal API level.\n\nRelated task\n\n* OpenGL -- OpenGL is usually maintained as a shared library."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.11\n\n```\nuse NativeCall;\n\nsub XOpenDisplay(Str $s --> int64) is native('X11') {*}\nsub XCloseDisplay(int64 $i --> int32) is native('X11') {*}\n\nif try my $d = XOpenDisplay \":0.0\" {\n    say \"ID = $d\";\n    XCloseDisplay($d);\n}\nelse {\n    say \"No X11 library!\";\n    say \"Use this window instead --> ⬜\";\n}\n\n```\n\nOutput:\n\n```\nID = 94722089782960\n```"}]}
{"messages": [{"role": "user", "content": "In object-oriented programming a method is a function associated with a particular class or object. In most forms of object oriented implementations methods can be static, associated with the class itself; or instance, associated with an instance of a class.\n\nShow how to call a static or class method, and an instance method of a class."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n### Basic method calls\n\n```\nclass Thing { \n  method regular-example() { say 'I haz a method' }\n\n  multi method multi-example() { say 'No arguments given' }\n  multi method multi-example(Str $foo) { say 'String given' }\n  multi method multi-example(Int $foo) { say 'Integer given' }\n};\n\n# 'new' is actually a method, not a special keyword:\nmy $thing = Thing.new;\n\n# No arguments: parentheses are optional\n$thing.regular-example;\n$thing.regular-example();\n$thing.multi-example;\n$thing.multi-example();\n\n# Arguments: parentheses or colon required\n$thing.multi-example(\"This is a string\");\n$thing.multi-example: \"This is a string\";\n$thing.multi-example(42);\n$thing.multi-example: 42;\n\n# Indirect (reverse order) method call syntax: colon required\nmy $foo = new Thing: ;\nmulti-example $thing: 42;\n\n```\n\n### Meta-operators\n\nThe `.` operator can be decorated with meta-operators.\n\n```\nmy @array = <a z c d y>;\n@array .= sort;  # short for @array = @array.sort;\n\nsay @array».uc;  # uppercase all the strings: A C D Y Z\n\n```\n\n### Classless methods\n\nA method that is not in a class can be called by using the `&` sigil explicitly.\n\n```\nmy $object = \"a string\";  # Everything is an object.\nmy method example-method {\n    return \"This is { self }.\";\n}\n\nsay $object.&example-method;  # Outputs \"This is a string.\"\n\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nLet **n** be a positive integer having **k** divisors (other than **1** and **n** itself) where **k** is exactly divisible by 3.\n\nAdd the first three eligible divisors, then the next three, and so on until the eligible divisors are exhausted. If the resulting partial sums are prime numbers, then **n** is called a Calmo number.\n\nExample\n\nConsider n = 165.\n\nIt has 6 eligible divisors, namely [3 5 11 15 33 55].\n\nThe sum of the first three is: 3 + 5 + 11 = 19 which is a prime number.\n\nThe sum of the next three is: 15 + 33 + 55 = 103 which is also a prime number.\n\nHence n is a Calmo number.\n\nTask\n\nFind and show here all Calmo numbers under 1000."}, {"role": "assistant", "content": "```\nuse Prime::Factor;\nuse List::Divvy;\n\nmy $upto = 1e3;\n\nmy @found = (2..Inf).hyper.grep({\n    (so my @d = .&proper-divisors(:s)) &&\n    (@d.elems %% 3) &&\n    (all @d.batch(3)».sum».is-prime)\n}).&upto($upto);\n\nput \"{+@found} found before $upto using sums of proper-divisors:\\n\" ~\n@found.batch(10)».fmt(\"%4d\").join: \"\\n\";\n\n@found = (2..Inf).hyper.grep({\n    (so my @d = .&proper-divisors(:s).&after: 1) &&\n    (@d.elems %% 3) &&\n    (all @d.batch(3)».sum».is-prime)\n}).&upto($upto);\n\nput \"\\n{+@found} found before $upto using sums of some bizarre\\nbespoke definition for divisors:\\n\" ~\n@found.batch(10)».fmt(\"%4d\").join: \"\\n\";\n\n```\n\nOutput:\n\n```\n85 found before 1000 using sums of proper-divisors:\n   8   21   27   35   39   55   57   65   77   85\n 111  115  125  129  155  161  185  187  201  203\n 205  209  221  235  237  265  291  299  305  309\n 319  323  327  335  341  365  371  377  381  391\n 413  415  437  451  485  489  493  497  505  515\n 517  535  579  611  623  649  655  667  669  671\n 687  689  697  707  731  737  755  767  779  781\n 785  831  835  851  865  893  899  901  917  921\n 939  955  965  979  989\n\n9 found before 1000 using sums of some bizarre\nbespoke definition for divisors:\n 165  273  385  399  561  595  665  715  957\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nLet p(1), p(2), p(3), ... , p(n) be consecutive prime numbers. If the sum of any consecutive sub-sequence of these numbers is a prime number, then the numbers in such a sub-sequence are called **CalmoSoft primes**.\n\nTask\n\nFind and show here the longest sequence of CalmoSoft primes for p(n) < 100.\n\nStretch\n\nShow a shortened version (first and last 6 primes) of the same for p(n) < fifty million.  \nTip: if it takes longer than twenty seconds, you're doing it wrong."}, {"role": "assistant", "content": "Longest sliding window prime sums\n\n```\nuse Lingua::EN::Numbers;\n\nsub sliding-window(@list, $window) { (^(+@list - $window)).map: { @list[$_ .. $_+$window] } }\n\nfor flat (1e2, 1e3, 1e4, 1e5).map: { (1, 2.5, 5) »×» $_ } -> $upto {\n\n    my @primes = (^$upto).grep: &is-prime;\n\n    for +@primes ... 1 {\n        my @sums = @primes.&sliding-window($_).grep: { .sum.is-prime }\n        next unless @sums;\n        say \"\\nFor primes up to {$upto.Int.&cardinal}:\\nLongest sequence of consecutive primes yielding a prime sum: elements: {comma 1+$_}\";\n        for @sums {  say \" {join '...', .[0..5, *-5..*]».&comma».join(' + ')}, sum: {.sum.&comma}\" }\n        last\n    }\n}\n\n```\n\nOutput:\n\n```\nFor primes up to one hundred:\nLongest sequence of consecutive primes yielding a prime sum: elements: 21\n 7 + 11 + 13 + 17 + 19 + 23...71 + 73 + 79 + 83 + 89, sum: 953\n\nFor primes up to two hundred fifty:\nLongest sequence of consecutive primes yielding a prime sum: elements: 49\n 11 + 13 + 17 + 19 + 23 + 29...227 + 229 + 233 + 239 + 241, sum: 5,813\n\nFor primes up to five hundred:\nLongest sequence of consecutive primes yielding a prime sum: elements: 85\n 31 + 37 + 41 + 43 + 47 + 53...467 + 479 + 487 + 491 + 499, sum: 21,407\n\nFor primes up to one thousand:\nLongest sequence of consecutive primes yielding a prime sum: elements: 163\n 13 + 17 + 19 + 23 + 29 + 31...971 + 977 + 983 + 991 + 997, sum: 76,099\n\nFor primes up to two thousand, five hundred:\nLongest sequence of consecutive primes yielding a prime sum: elements: 359\n 7 + 11 + 13 + 17 + 19 + 23...2,411 + 2,417 + 2,423 + 2,437 + 2,441, sum: 408,479\n\nFor primes up to five thousand:\nLongest sequence of consecutive primes yielding a prime sum: elements: 665\n 7 + 11 + 13 + 17 + 19 + 23...4,967 + 4,969 + 4,973 + 4,987 + 4,993, sum: 1,543,127\n\nFor primes up to ten thousand:\nLongest sequence of consecutive primes yielding a prime sum: elements: 1,223\n 3 + 5 + 7 + 11 + 13 + 17...9,887 + 9,901 + 9,907 + 9,923 + 9,929, sum: 5,686,633\n 7 + 11 + 13 + 17 + 19 + 23...9,907 + 9,923 + 9,929 + 9,931 + 9,941, sum: 5,706,497\n\nFor primes up to twenty-five thousand:\nLongest sequence of consecutive primes yielding a prime sum: elements: 2,759\n 7 + 11 + 13 + 17 + 19 + 23...24,967 + 24,971 + 24,977 + 24,979 + 24,989, sum: 32,405,707\n\nFor primes up to fifty thousand:\nLongest sequence of consecutive primes yielding a prime sum: elements: 5,131\n 5 + 7 + 11 + 13 + 17 + 19...49,943 + 49,957 + 49,991 + 49,993 + 49,999, sum: 121,013,303\n\nFor primes up to one hundred thousand:\nLongest sequence of consecutive primes yielding a prime sum: elements: 9,590\n 2 + 3 + 5 + 7 + 11 + 13...99,907 + 99,923 + 99,929 + 99,961 + 99,971, sum: 454,196,557\n\nFor primes up to two hundred fifty thousand:\nLongest sequence of consecutive primes yielding a prime sum: elements: 22,041\n 7 + 11 + 13 + 17 + 19 + 23...249,947 + 249,967 + 249,971 + 249,973 + 249,989, sum: 2,623,031,141\n\nFor primes up to five hundred thousand:\nLongest sequence of consecutive primes yielding a prime sum: elements: 41,530\n 2 + 3 + 5 + 7 + 11 + 13...499,801 + 499,819 + 499,853 + 499,879 + 499,883, sum: 9,910,236,647\n```"}]}
{"messages": [{"role": "user", "content": "Two common conventions for naming of computer program variables are **Snake Case** and\n**Camel Case**.\n\n**Snake case** variables are generally all lower case, with an underscore between words in the variable, as in **snake\\_case\\_variable'**. **Camel case** variables are generally lower case first (except in some Pascal conventions or with class names in many other languages), with captalization of the initial letter of the words within the variable, as in '**camelCaseVariable'**.\n\nLeading underscores are not used in such variables except as part of a different naming convention, usually for special internal or system variables. White space is not permitted as part of camel case or snake case variable names.\n\nTask\n\n:   * Write two functions, one to change snake case to camel case and one to change camel case to snake case. If possible, generalize the function enough to apply to strings containing spaces between words or a `-` dash between words, assuming that in those cases a space or hyphen is a also a separator character, like `\\_`, for the purpose of creating a new variable name. Leading or trailing whitespace may be ignored.\n\n:   * Show the results on changing to both snake case and camel case for each of the following strings:\n\n```\n\"snakeCase\", \"snake_case\", \"variable_10_case\", \"variable10Case\", \"ɛrgo rE tHis\",\n\"hurry-up-joe!\", \"c://my-docs/happy_Flag-Day/12.doc\", \"  spaces  \"\n\n```\n\nRelated tasks\n\n* Naming\\_conventions"}, {"role": "assistant", "content": "The specs are a little vague, but taking a wild stab at it... *(May be completely wrong but without any examples of expected output it is hard to judge. This is what **I** would expect at least...)*\n\n```\nmy @tests = qww<\n  snakeCase  snake_case  variable_10_case  variable10Case  \"ɛrgo rE tHis\"\n  hurry-up-joe!  c://my-docs/happy_Flag-Day/12.doc  \"  spaces  \"\n>;\n\n\nsub to_snake_case (Str $snake_case_string is copy) {\n    $snake_case_string.=trim;\n    return $snake_case_string if $snake_case_string.contains: / \\s | '/' /;\n    $snake_case_string.=subst: / <after <:Ll>> (<:Lu>|<:digit>+) /, {'_' ~ $0.lc}, :g;\n    $snake_case_string.=subst: / <after <:digit>> (<:Lu>) /, {'_' ~ $0.lc}, :g;\n}\n\nsub toCamelCase (Str $CamelCaseString is copy) {\n    $CamelCaseString.=trim;\n    return $CamelCaseString if $CamelCaseString.contains: / \\s | '/' /;\n    $CamelCaseString.=subst: / ('_') (\\w) /, {$1.uc}, :g;\n}\n\nsub to-kebab-case (Str $kebab-case-string is copy) {\n    $kebab-case-string.=trim;\n    return $kebab-case-string if $kebab-case-string.contains: / \\s | '/' /;\n    $kebab-case-string.=subst: / ('_') (\\w) /, {'-' ~ $1.lc}, :g;\n    $kebab-case-string.=subst: / <after <:Ll>> (<:Lu>|<:digit>+) /, {'-' ~ $0.lc}, :g;\n    $kebab-case-string.=subst: / <after <:digit>> (<:Lu>) /, {'-' ~ $0.lc}, :g;\n}\n\nsay   \"{' ' x 30}to_snake_case\";\nprintf \"%33s ==> %s\\n\", $_, .&to_snake_case for @tests;\nsay \"\\n{' ' x 30}toCamelCase\";\nprintf \"%33s ==> %s\\n\", $_,   .&toCamelCase for @tests;\nsay \"\\n{' ' x 30}to-kabab-case\";\nprintf \"%33s ==> %s\\n\", $_, .&to-kebab-case for @tests;\n\n```\n\nOutput:\n\n```\n                              to_snake_case\n                        snakeCase ==> snake_case\n                       snake_case ==> snake_case\n                 variable_10_case ==> variable_10_case\n                   variable10Case ==> variable_10_case\n                     ɛrgo rE tHis ==> ɛrgo rE tHis\n                    hurry-up-joe! ==> hurry-up-joe!\nc://my-docs/happy_Flag-Day/12.doc ==> c://my-docs/happy_Flag-Day/12.doc\n                         spaces   ==> spaces\n\n                              toCamelCase\n                        snakeCase ==> snakeCase\n                       snake_case ==> snakeCase\n                 variable_10_case ==> variable10Case\n                   variable10Case ==> variable10Case\n                     ɛrgo rE tHis ==> ɛrgo rE tHis\n                    hurry-up-joe! ==> hurry-up-joe!\nc://my-docs/happy_Flag-Day/12.doc ==> c://my-docs/happy_Flag-Day/12.doc\n                         spaces   ==> spaces\n\n                              to-kabab-case\n                        snakeCase ==> snake-case\n                       snake_case ==> snake-case\n                 variable_10_case ==> variable-10-case\n                   variable10Case ==> variable-10-case\n                     ɛrgo rE tHis ==> ɛrgo rE tHis\n                    hurry-up-joe! ==> hurry-up-joe!\nc://my-docs/happy_Flag-Day/12.doc ==> c://my-docs/happy_Flag-Day/12.doc\n                         spaces   ==> spaces\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program that performs so-called canny edge detection on an image.\n\nA possible algorithm consists of the following steps:\n\n1. **Noise reduction.**   May be performed by Gaussian filter.\n2. Compute **intensity gradient**   (matrices \n\n   G\n\n   x\n   {\\displaystyle {\\displaystyle G\\_{x}}}\n    and \n\n   G\n\n   y\n   {\\displaystyle {\\displaystyle G\\_{y}}}\n   )   and its **magnitude**   \n\n   G\n   {\\displaystyle {\\displaystyle G}}\n   :  \n              \n\n   G\n   =\n\n   G\n\n   x\n\n   2\n   +\n\n   G\n\n   y\n\n   2\n   {\\displaystyle {\\displaystyle G={\\sqrt {G\\_{x}^{2}+G\\_{y}^{2}}}}}\n     \n   May be performed by convolution of an image with Sobel operators.\n3. **Non-maximum suppression.**     \n   For each pixel compute the orientation of intensity gradient vector:   \n\n   θ\n   =\n\n\n   a\n   t\n   a\n   n\n   2\n\n   (\n\n\n   G\n\n   y\n   ,\n\n\n   G\n\n   x\n   )\n   {\\displaystyle {\\displaystyle \\theta ={\\rm {atan2}}\\left(G\\_{y},\\,G\\_{x}\\right)}}\n   .       \n   Transform   angle \n\n   θ\n   {\\displaystyle {\\displaystyle \\theta }}\n      to one of four directions:   0, 45, 90, 135 degrees.       \n   Compute new array   \n\n   N\n   {\\displaystyle {\\displaystyle N}}\n   :     if         \n\n   G\n\n   (\n\n   p\n\n   a\n   )\n   <\n   G\n\n   (\n   p\n   )\n   <\n   G\n\n   (\n\n   p\n\n   b\n   )\n   {\\displaystyle {\\displaystyle G\\left(p\\_{a}\\right)<G\\left(p\\right)<G\\left(p\\_{b}\\right)}}\n     \n   where   \n\n   p\n   {\\displaystyle {\\displaystyle p}}\n      is the current pixel,   \n\n   p\n\n   a\n   {\\displaystyle {\\displaystyle p\\_{a}}}\n      and   \n\n   p\n\n   b\n   {\\displaystyle {\\displaystyle p\\_{b}}}\n      are the two neighbour pixels in the direction of gradient,     \n   then     \n\n   N\n   (\n   p\n   )\n   =\n   G\n   (\n   p\n   )\n   {\\displaystyle {\\displaystyle N(p)=G(p)}}\n   ,       otherwise   \n\n   N\n   (\n   p\n   )\n   =\n   0\n   {\\displaystyle {\\displaystyle N(p)=0}}\n   .     \n   Nonzero pixels in resulting array correspond to local maxima of   \n\n   G\n   {\\displaystyle {\\displaystyle G}}\n      in direction   \n\n   θ\n   (\n   p\n   )\n   {\\displaystyle {\\displaystyle \\theta (p)}}\n   .\n4. **Tracing edges with hysteresis.**     \n   At this stage two thresholds for the values of   \n\n   G\n   {\\displaystyle {\\displaystyle G}}\n      are introduced:   \n\n   T\n\n   m\n   i\n   n\n   {\\displaystyle {\\displaystyle T\\_{min}}}\n      and   \n\n   T\n\n   m\n   a\n   x\n   {\\displaystyle {\\displaystyle T\\_{max}}}\n   .     \n   Starting from pixels with   \n\n   N\n   (\n   p\n   )\n   ⩾\n\n   T\n\n   m\n   a\n   x\n   {\\displaystyle {\\displaystyle N(p)\\geqslant T\\_{max}}}\n   ,     \n   find all paths of pixels with   \n\n   N\n   (\n   p\n   )\n   ⩾\n\n   T\n\n   m\n   i\n   n\n   {\\displaystyle {\\displaystyle N(p)\\geqslant T\\_{min}}}\n      and put them to the resulting image."}, {"role": "assistant", "content": "Admittedly laziness always prevails so an off-the-shelf function from ImageMagick is used instead.\n\ncannyedge.c\n\n```\n#include <stdio.h>\n#include <string.h>\n#include <magick/MagickCore.h>\n\nint CannyEdgeDetector(\n   const char *infile, const char *outfile,\n   double radius, double sigma, double lower, double upper ) {\n\n   ExceptionInfo   *exception;\n   Image           *image, *processed_image, *output;\n   ImageInfo       *input_info;\n\n   exception   = AcquireExceptionInfo();\n   input_info  = CloneImageInfo((ImageInfo *) NULL);\n   (void) strcpy(input_info->filename, infile);\n   image       = ReadImage(input_info, exception);\n   output      = NewImageList();\n   processed_image = CannyEdgeImage(image,radius,sigma,lower,upper,exception);\n   (void) AppendImageToList(&output, processed_image);\n   (void) strcpy(output->filename, outfile);\n   WriteImage(input_info, output);\n                                    // after-party clean up \n   DestroyImage(image);\n   output=DestroyImageList(output);\n   input_info=DestroyImageInfo(input_info);\n   exception=DestroyExceptionInfo(exception);\n   MagickCoreTerminus();\n\n   return 0;\n}\n\n```\n\ncannyedge.raku\n\n```\n# 20220103 Raku programming solution\n \nuse NativeCall;\n \nsub CannyEdgeDetector(CArray[uint8], CArray[uint8], num64, num64, num64, num64 \n) returns int32 is native( '/home/hkdtam/LibCannyEdgeDetector.so' ) {*};\n\nCannyEdgeDetector( # imagemagick.org/script/command-line-options.php#canny \n   CArray[uint8].new(  'input.jpg'.encode.list, 0), # pbs.org/wgbh/nova/next/wp-content/uploads/2013/09/fingerprint-1024x575.jpg\n   CArray[uint8].new( 'output.jpg'.encode.list, 0),\n   0e0, 2e0, 0.05e0, 0.05e0\n)\n\n```\n\nOutput:\n\n```\nexport PKG_CONFIG_PATH=/usr/lib/pkgconfig\ngcc -Wall -fPIC -shared -o LibCannyEdgeDetector.so  cannyedge.c `pkg-config --cflags --libs MagickCore`\nraku -c cannyedge.raku && ./cannyedge.raku\n```\n\nOutput: (Offsite image file)"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a function or program that, given a range of IPv4 addresses in CIDR notation (dotted-decimal/network-bits), will return/output the same range in canonical form.\n\nThat is, the IP address portion of the output CIDR block must not contain any set (1) bits in the host part of the address.\n\nExample\n\nGiven   **87.70.141.1/22**,   your code should output   **87.70.140.0/22**\n\nExplanation\n\nAn Internet Protocol version 4 address is a 32-bit value, conventionally represented as a number in base 256 using dotted-decimal notation, where each base-256 digit is given in decimal and the digits are separated by periods. Logically, this 32-bit value represents two components: the leftmost (most-significant) bits determine the network portion of the address, while the rightmost (least-significant) bits determine the host portion. Classless Internet Domain Routing block notation indicates where the boundary between these two components is for a given address by adding a slash followed by the number of bits in the network portion.\n\nIn general, CIDR blocks stand in for the entire set of IP addresses sharing the same network component, so it's common to see access control lists that specify individual IP addresses using /32 to indicate that only the one address is included. Software accepting this notation as input often expects it to be entered in canonical form, in which the host bits are all zeroes. But network admins sometimes skip this step and just enter the address of a specific host on the subnet with the network size, resulting in a non-canonical entry.\n\nThe example address, 87.70.141.1/22, represents binary 0101011101000110100011 / 0100000001, with the / indicating the network/host division. To canonicalize, clear all the bits to the right of the / and convert back to dotted decimal: 0101011101000110100011 / 0000000000 → 87.70.140.0.\n\nMore examples for testing\n\n```\n        36.18.154.103/12    →  36.16.0.0/12\n        62.62.197.11/29     →  62.62.197.8/29\n        67.137.119.181/4    →  64.0.0.0/4\n        161.214.74.21/24    →  161.214.74.0/24\n        184.232.176.184/18  →  184.232.128.0/18\n\n```"}, {"role": "assistant", "content": "### Using library\n\n**Library:** raku-IP-Addr\n\n```\nuse IP::Addr;\nfor «87.70.141.1/22 36.18.154.103/12 62.62.197.11/29 67.137.119.181/4 161.214.74.21/24 184.232.176.184/18» -> $cidr {\n   say \"$cidr -> $(IP::Addr.new($cidr).network)\";\n}\n\n```\n\n### String manipulation\n\n**Translation of**: Perl\n\n```\n#!/usr/bin/env raku\nunit sub MAIN(*@cidrs);\n\nif !@cidrs {\n  # test data\n  @cidrs = «87.70.141.1/22 36.18.154.103/12 62.62.197.11/29 67.137.119.181/4 161.214.74.21/24 184.232.176.184/18»;\n}\n\nfor @cidrs -> $cidr {\n  say \"$cidr -> $(canonicalize $cidr)\";\n}\n\n# canonicalize a CIDR block: make sure none of the host bits are set\nsub canonicalize($cidr) {\n  # dotted-decimal / bits in network part\n  my ($dotted, $size) = $cidr.split: '/';\n\n  # get network part of the IP as binary string\n  my $binary = $dotted.split('.')».fmt('%08b').join.substr(0, $size);\n\n  # Add host part with all zeroes\n  $binary ~= 0 x (32 - $size);\n\n  # Convert back to dotted-decimal\n  my $canon = $binary.comb(8)».parse-base(2).join: '.';\n\n  # And output\n  say \"$canon/$size\";\n}\n\n```\n\nOutput:\n\n```\n87.70.141.1/22 -> 87.70.140.0/22\n36.18.154.103/12 -> 36.16.0.0/12\n62.62.197.11/29 -> 62.62.197.8/29\n67.137.119.181/4 -> 64.0.0.0/4\n161.214.74.21/24 -> 161.214.74.0/24\n184.232.176.184/18 -> 184.232.128.0/18\n```\n\n### Bit mask and shift\n\n```\n# canonicalize a IP4 CIDR block\nsub CIDR-IP4-canonicalize ($address) {\n  constant @mask = 24, 16, 8, 0;\n \n  # dotted-decimal / subnet size\n  my ($dotted, $size) = |$address.split('/'), 32;\n \n  # get IP as binary address\n  my $binary = sum $dotted.comb(/\\d+/) Z+< @mask;\n \n  # mask off subnet\n  $binary +&= (2 ** $size - 1) +< (32 - $size);\n \n  # Return dotted-decimal notation\n  (@mask.map($binary +> * +& 0xFF).join('.'), $size)\n}\n \nmy @tests = <\n  87.70.141.1/22\n  36.18.154.103/12\n  62.62.197.11/29\n  67.137.119.181/4\n  161.214.74.21/24\n  184.232.176.184/18\n  100.68.0.18/18\n  10.4.30.77/30\n  10.207.219.251/32\n  10.207.219.251\n  110.200.21/4\n  10.11.12.13/8\n  10.../8\n>;\n \nprintf \"CIDR: %18s  Routing prefix: %s/%s\\n\", $_, |.&CIDR-IP4-canonicalize\n  for @*ARGS || @tests;\n\n```\n\nOutput:\n\n```\nCIDR:     87.70.141.1/22  Routing prefix: 87.70.140.0/22\nCIDR:   36.18.154.103/12  Routing prefix: 36.16.0.0/12\nCIDR:    62.62.197.11/29  Routing prefix: 62.62.197.8/29\nCIDR:   67.137.119.181/4  Routing prefix: 64.0.0.0/4\nCIDR:   161.214.74.21/24  Routing prefix: 161.214.74.0/24\nCIDR: 184.232.176.184/18  Routing prefix: 184.232.128.0/18\nCIDR:     100.68.0.18/18  Routing prefix: 100.68.0.0/18\nCIDR:      10.4.30.77/30  Routing prefix: 10.4.30.76/30\nCIDR:  10.207.219.251/32  Routing prefix: 10.207.219.251/32\nCIDR:     10.207.219.251  Routing prefix: 10.207.219.251/32\nCIDR:       110.200.21/4  Routing prefix: 96.0.0.0/4\nCIDR:      10.11.12.13/8  Routing prefix: 10.0.0.0/8\nCIDR:            10.../8  Routing prefix: 10.0.0.0/8\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDraw a Cantor set.\n\nSee details at this Wikipedia webpage:   Cantor set"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Kotlin\n\n```\nsub cantor ( Int $height ) {\n    my $width = 3 ** ($height - 1);\n\n    my @lines = ( \"\\c[FULL BLOCK]\" x $width ) xx $height;\n\n    my sub _trim_middle_third ( $len, $start, $index ) {\n        my $seg = $len div 3\n            or return;\n\n        for ( $index ..^ $height ) X ( 0 ..^ $seg ) -> ( $i, $j ) {\n            @lines[$i].substr-rw( $start + $seg + $j, 1 ) = ' ';\n        }\n\n        _trim_middle_third( $seg, $start + $_, $index + 1 ) for 0, $seg * 2;\n    }\n\n    _trim_middle_third( $width, 0, 1 );\n    return @lines;\n}\n\n.say for cantor(5);\n\n```\n\nOutput:\n\n```\n█████████████████████████████████████████████████████████████████████████████████\n███████████████████████████                           ███████████████████████████\n█████████         █████████                           █████████         █████████\n███   ███         ███   ███                           ███   ███         ███   ███\n█ █   █ █         █ █   █ █                           █ █   █ █         █ █   █ █\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nThere are many techniques that people use to shuffle cards for card games. Some are more effective than others.\n\nTask\n\nImplement the (seemingly) more common techniques of the riffle shuffle and overhand shuffle for   *n*   iterations.\n\nImplementing playing cards is not necessary if it would be easier to implement these shuffling methods for generic collections.\n\nWhere possible, compare this to a standard/built-in shuffling procedure.\n\nOne iteration of the riffle shuffle is defined as:\n\n1. Split the deck into two piles\n2. Merge the two piles by taking one card from the top of either pile in proportion to the number of cards remaining in the pile. To start with the probability for both piles will be 26/52 (50-50), then 25/51-26/51 etc etc as the riffle progresses.\n3. The merged deck is now the new \"shuffled\" deck\n\nOne iteration of the overhand shuffle is defined as:\n\n1. Take a group of consecutive cards from the top of the deck. For our purposes up to 20% of the deck seems like a good amount.\n2. Place that group on top of a second pile\n3. Repeat these steps until there are no cards remaining in the original deck\n4. The second pile is now the new \"shuffled\" deck\n\nBonus\n\nImplement other methods described in the Wikipedia\narticle:   card shuffling.\n\nAllow for \"human errors\" of imperfect cutting and interleaving.\n\nRelated tasks:\n\n* Playing cards\n* Deal cards\\_for\\_FreeCell\n* War Card\\_Game\n* Poker hand\\_analyser\n* Go Fish"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub overhand ( @cards ) {\n    my @splits = roll 10, ^( @cards.elems div 5 )+1;\n    @cards.rotor( @splits  ,:partial ).reverse.flat\n}\n\nsub riffle ( @pile is copy ) {\n    my @pile2 = @pile.splice: @pile.elems div 2 ;\n \n    roundrobin(\n        @pile.rotor(  (1 .. 3).roll(7), :partial ),\n        @pile2.rotor( (1 .. 3).roll(9), :partial ),\n    ).flat\n}\n\nmy @cards = ^20;\n@cards.=&overhand for ^10;\nsay @cards;\n \nmy @cards2 = ^20;\n@cards2.=&riffle for ^10;\nsay @cards2;\n\nsay (^20).pick(*);\n\n```"}]}
{"messages": [{"role": "user", "content": "A lot of composite numbers can be separated from primes by Fermat's Little Theorem, but there are some that completely confound it.\n\nThe   Miller Rabin Test   uses a combination of Fermat's Little Theorem and Chinese Division Theorem to overcome this.\n\nThe purpose of this task is to investigate such numbers using a method based on   Carmichael numbers,   as suggested in   Notes by G.J.O Jameson March 2010.\n\nTask\n\nFind Carmichael numbers of the form:\n\n:   :   :   :   *Prime*1 × *Prime*2 × *Prime*3\n\nwhere    (*Prime*1 < *Prime*2 < *Prime*3)    for all    *Prime*1    up to   **61**.\n  \n(See page 7 of   Notes by G.J.O Jameson March 2010   for solutions.)\n\nPseudocode\n\nFor a given   **Prime1**\n\n```\nfor 1 < h3 < Prime1\n    for 0 < d < h3+Prime1\n         if (h3+Prime1)*(Prime1-1) mod d == 0 and -Prime1 squared mod h3 == d mod h3\n         then\n               Prime2 = 1 + ((Prime1-1) * (h3+Prime1)/d)\n               next d if Prime2 is not prime\n               Prime3 = 1 + (Prime1*Prime2/h3)\n               next d if Prime3 is not prime\n               next d if (Prime2*Prime3) mod (Prime1-1) not equal 1\n               Prime1 * Prime2 * Prime3 is a Carmichael Number\n\n```\n\nrelated task\n\nChernick's Carmichael numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\nAn almost direct translation of the pseudocode. We take the liberty of going up to 67 to show we aren't limited to 32-bit integers. (Raku uses arbitrary precision in any case.)\n\n```\nfor (2..67).grep: *.is-prime -> \\Prime1 {\n    for 1 ^..^ Prime1 -> \\h3 {\n        my \\g = h3 + Prime1;\n        for 0 ^..^ h3 + Prime1 -> \\d {\n            if (h3 + Prime1) * (Prime1 - 1) %% d and -Prime1**2 % h3 == d % h3  {\n                my \\Prime2 = floor 1 + (Prime1 - 1) * g / d;\n                next unless Prime2.is-prime;\n                my \\Prime3 = floor 1 + Prime1 * Prime2 / h3;\n                next unless Prime3.is-prime;\n                next unless (Prime2 * Prime3) % (Prime1 - 1) == 1;\n                say \"{Prime1} × {Prime2} × {Prime3} == {Prime1 * Prime2 * Prime3}\";\n            }\n        }\n    }\n}\n\n```\n\nOutput:\n\n```\n3 × 11 × 17 == 561\n5 × 29 × 73 == 10585\n5 × 17 × 29 == 2465\n5 × 13 × 17 == 1105\n7 × 19 × 67 == 8911\n7 × 31 × 73 == 15841\n7 × 13 × 31 == 2821\n7 × 23 × 41 == 6601\n7 × 73 × 103 == 52633\n7 × 13 × 19 == 1729\n13 × 61 × 397 == 314821\n13 × 37 × 241 == 115921\n13 × 97 × 421 == 530881\n13 × 37 × 97 == 46657\n13 × 37 × 61 == 29341\n17 × 41 × 233 == 162401\n17 × 353 × 1201 == 7207201\n19 × 43 × 409 == 334153\n19 × 199 × 271 == 1024651\n23 × 199 × 353 == 1615681\n29 × 113 × 1093 == 3581761\n29 × 197 × 953 == 5444489\n31 × 991 × 15361 == 471905281\n31 × 61 × 631 == 1193221\n31 × 151 × 1171 == 5481451\n31 × 61 × 271 == 512461\n31 × 61 × 211 == 399001\n31 × 271 × 601 == 5049001\n31 × 181 × 331 == 1857241\n37 × 109 × 2017 == 8134561\n37 × 73 × 541 == 1461241\n37 × 613 × 1621 == 36765901\n37 × 73 × 181 == 488881\n37 × 73 × 109 == 294409\n41 × 1721 × 35281 == 2489462641\n41 × 881 × 12041 == 434932961\n41 × 101 × 461 == 1909001\n41 × 241 × 761 == 7519441\n41 × 241 × 521 == 5148001\n41 × 73 × 137 == 410041\n41 × 61 × 101 == 252601\n43 × 631 × 13567 == 368113411\n43 × 271 × 5827 == 67902031\n43 × 127 × 2731 == 14913991\n43 × 127 × 1093 == 5968873\n43 × 211 × 757 == 6868261\n43 × 631 × 1597 == 43331401\n43 × 127 × 211 == 1152271\n43 × 211 × 337 == 3057601\n43 × 433 × 643 == 11972017\n43 × 547 × 673 == 15829633\n43 × 3361 × 3907 == 564651361\n47 × 3359 × 6073 == 958762729\n47 × 1151 × 1933 == 104569501\n47 × 3727 × 5153 == 902645857\n53 × 157 × 2081 == 17316001\n53 × 79 × 599 == 2508013\n53 × 157 × 521 == 4335241\n59 × 1451 × 2089 == 178837201\n61 × 421 × 12841 == 329769721\n61 × 181 × 5521 == 60957361\n61 × 1301 × 19841 == 1574601601\n61 × 277 × 2113 == 35703361\n61 × 181 × 1381 == 15247621\n61 × 541 × 3001 == 99036001\n61 × 661 × 2521 == 101649241\n61 × 271 × 571 == 9439201\n61 × 241 × 421 == 6189121\n61 × 3361 × 4021 == 824389441\n67 × 2311 × 51613 == 7991602081\n67 × 331 × 7393 == 163954561\n67 × 331 × 463 == 10267951\n```"}]}
{"messages": [{"role": "user", "content": "Background\n\nThe **Carmichael function**, or **Carmichael lambda function**, is a function in number theory. The Carmichael lambda  *λ*(*n*) of a positive integer **n** is the smallest positive integer **m** such that\n\n:   a\n\n    m\n    ≡\n    1\n\n\n    (\n    mod\n\n    n\n    )\n    {\\displaystyle {\\displaystyle a^{m}\\equiv 1{\\pmod {n}}}}\n\nholds for every integer coprime to **n**.\n\nThe Carmichael lambda function can be iterated, that is, called repeatedly on its result. If this iteration is\nperformed **k** times, this is considered the **k**-iterated Carmichael lambda function. Thus,  *λ*(*λ*(*n*))\nwould be the 2-iterated lambda function. With repeated, sufficiently large but finite **k**-iterations, the iterated Carmichael function will eventually compute as 1 for all positive integers **n**.\n\nTask\n\n* Write a function to obtain the Carmichael lambda of a positive integer. If the function is supplied by a core library of the language, this also may be used.\n\n* Write a function to count the number of iterations **k** of the **k**-iterated lambda function needed to get to a value of 1. Show the value of  *λ*(*n*) and the number of **k**-iterations for integers from 1 to 25.\n\n* Find the lowest integer for which the value of iterated k is i, for i from 1 to 15.\n\nStretch task (an extension of the third task above)\n\n* Find, additionally, for **i** from 16 to 25, the lowest integer **n** for which the number of iterations **k** of the Carmichael lambda function from **n** to get to 1 is **i**.\n\nSee also\n\n:   * Wikipedia entry for Carmichael function\n    * OEIS lambda(lambda(n)) function sequence"}, {"role": "assistant", "content": "**Translation of**: Wren\n\n```\n# 20240228 Raku programming solution\n\nuse Prime::Factor;\n\nsub phi(Int $p, Int $r) { return $p**($r - 1) * ($p - 1) }\n\nsub CarmichaelLambda(Int $n) {\n\n   state %cache = 1 => 1, 2 => 1, 4 => 2;\n\n   sub CarmichaelHelper(Int $p, Int $r) {\n      my Int $n = $p ** $r;\n      return %cache{$n} if %cache{$n}:exists;\n      return %cache{$n} = $p > 2 ?? phi($p, $r) !! phi($p, $r - 1)\n   }\n\n   if $n < 1 { die \"'n' must be a positive integer.\" }\n   return %cache{$n} if %cache{$n}:exists;\n   if ( my %pps = prime-factors($n).Bag ).elems == 1 { \n      my ($p, $r) = %pps.kv>>.Int;\n      return %cache{$n} = $p > 2 ?? phi($p, $r) !! phi($p, $r - 1)\n   }\n   return [lcm] %pps.kv.map: -> $k, $v { CarmichaelHelper($k.Int, $v) } \n}\n\nsub iteratedToOne($i is copy) {\n   my $k = 0;\n   while $i > 1 { $i = CarmichaelLambda($i) andthen $k++ } \n   return $k\n}\n\nsay \" n   λ   k\";\nsay \"----------\";\nfor 1..25 -> $n {\n   printf \"%2d  %2d  %2d\\n\", $n, CarmichaelLambda($n), iteratedToOne($n)\n}\n\nsay \"\\nIterations to 1       i     lambda(i)\";\nsay \"=====================================\";\nsay \"   0                  1            1\";\n\nmy ($maxI, $maxN) = 5e6, 10; # for N=15, takes around 47 minutes with an i5-10500T\nmy @found = True, |( False xx $maxN );\nfor 1 .. $maxI -> $i {\n   unless @found[ my $n = iteratedToOne($i) ] {\n      printf \"%4d %18d %12d\\n\", $n, $i, CarmichaelLambda($i);\n      @found[$n] = True andthen ( last if $n == $maxN )\n   }\n}\n\n```\n\nOutput:\n\nSame as Wren example .. and it is probably 30X times slower 😅"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow one or more idiomatic ways of generating the Cartesian product of two arbitrary lists in your language.\n\nDemonstrate that your function/method correctly returns:\n\n:   :   {1, 2} × {3, 4} = {(1, 3), (1, 4), (2, 3), (2, 4)}\n\nand, in contrast:\n\n:   :   {3, 4} × {1, 2} = {(3, 1), (3, 2), (4, 1), (4, 2)}\n\nAlso demonstrate, using your function/method, that the product of an empty list with any other list is empty.\n\n:   :   {1, 2} × {} = {}\n    :   {} × {1, 2} = {}\n\nFor extra credit, show or write a function returning the n-ary product of an arbitrary number of lists, each of arbitrary length. Your function might, for example, accept a single argument which is itself a list of lists, and return the n-ary product of those lists.\n\nUse your n-ary Cartesian product function to show the following products:\n\n:   :   {1776, 1789} × {7, 12} × {4, 14, 23} × {0, 1}\n    :   {1, 2, 3} × {30} × {500, 100}\n    :   {1, 2, 3} × {} × {500, 100}"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.06\n\nThe cross meta operator X will return the cartesian product of two lists. To apply the cross meta-operator to a variable number of lists, use the reduce cross meta operator [X].\n\n```\n# cartesian product of two lists using the X cross meta-operator\nsay (1, 2) X (3, 4);\nsay (3, 4) X (1, 2);\nsay (1, 2) X ( );\nsay ( )    X ( 1, 2 );\n\n# cartesian product of variable number of lists using\n# the [X] reduce cross meta-operator\nsay [X] (1776, 1789), (7, 12), (4, 14, 23), (0, 1);\nsay [X] (1, 2, 3), (30), (500, 100);\nsay [X] (1, 2, 3), (),   (500, 100);\n\n```\n\nOutput:\n\n```\n((1 3) (1 4) (2 3) (2 4))\n((3 1) (3 2) (4 1) (4 2))\n()\n()\n((1776 7 4 0) (1776 7 4 1) (1776 7 14 0) (1776 7 14 1) (1776 7 23 0) (1776 7 23 1) (1776 12 4 0) (1776 12 4 1) (1776 12 14 0) (1776 12 14 1) (1776 12 23 0) (1776 12 23 1) (1789 7 4 0) (1789 7 4 1) (1789 7 14 0) (1789 7 14 1) (1789 7 23 0) (1789 7 23 1) (1789 12 4 0) (1789 12 4 1) (1789 12 14 0) (1789 12 14 1) (1789 12 23 0) (1789 12 23 1))\n((1 30 500) (1 30 100) (2 30 500) (2 30 100) (3 30 500) (3 30 100))\n()\n```"}]}
{"messages": [{"role": "user", "content": "Three dogs (Are there three dogs or one dog?) is a code snippet used to illustrate the lettercase sensitivity of the programming language. For a case-sensitive language, the identifiers dog, Dog and DOG are all different and we should get the output:\n\n```\nThe three dogs are named Benjamin, Samba and Bernie.\n\n```\n\nFor a language that is lettercase insensitive, we get the following output:\n\n```\nThere is just one dog named Bernie.\n\n```\n\nRelated task\n\n* Unicode variable names"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $dog = 'Benjamin';\nmy $Dog = 'Samba';\nmy $DOG = 'Bernie';\nsay \"The three dogs are named $dog, $Dog, and $DOG.\"\n\n```\n\nThe only place that Raku pays any attention to the case of identifiers is that, for certain error messages, it will guess that an identifier starting lowercase is probably a function name, while one starting uppercase is probably a type or constant name. But this case distinction is merely a convention in Raku, not mandatory:\n\n```\nconstant dog = 'Benjamin';\nsub Dog() { 'Samba' }\nmy &DOG = { 'Bernie' }\nsay \"The three dogs are named {dog}, {Dog}, and {DOG}.\"\n\n```"}]}
{"messages": [{"role": "user", "content": "Task   (in three parts)\n\nPart 1\n\nWrite a procedure (say \n\nc\no\n9\n(\nx\n)\n{\\displaystyle {\\displaystyle {\\mathit {co9}}(x)}}\n) which implements Casting Out Nines as described by returning the checksum for \n\nx\n{\\displaystyle {\\displaystyle x}}\n. Demonstrate the procedure using the examples given there, or others you may consider lucky.\n\nNote that this function does nothing more than calculate the least positive residue, modulo 9. Many of the solutions omit Part 1 for this reason. Many languages have a modulo operator, of which this is a trivial application.\n\nWith that understanding, solutions to Part 1, if given, are encouraged to follow the naive pencil-and-paper or mental arithmetic of repeated digit addition understood to be \"casting out nines\", or some approach other than just reducing modulo 9 using a built-in operator. Solutions for part 2 and 3 are not required to make use of the function presented in part 1.\n\nPart 2\n\nNotwithstanding past Intel microcode errors, checking computer calculations like this would not be sensible. To find a computer use for your procedure:\n\n:   Consider the statement \"318682 is 101558 + 217124 and squared is 101558217124\" (see: Kaprekar numbers#Casting Out Nines (fast)).\n:   note that \n\n    318682\n    {\\displaystyle {\\displaystyle 318682}}\n     has the same checksum as (\n\n    101558\n    +\n    217124\n    {\\displaystyle {\\displaystyle 101558+217124}}\n    );\n:   note that \n\n    101558217124\n    {\\displaystyle {\\displaystyle 101558217124}}\n     has the same checksum as (\n\n    101558\n    +\n    217124\n    {\\displaystyle {\\displaystyle 101558+217124}}\n    ) because for a Kaprekar they are made up of the same digits (sometimes with extra zeroes);\n:   note that this implies that for Kaprekar numbers the checksum of \n\n    k\n    {\\displaystyle {\\displaystyle k}}\n     equals the checksum of \n\n    k\n\n    2\n    {\\displaystyle {\\displaystyle k^{2}}}\n    .\n\nDemonstrate that your procedure can be used to generate or filter a range of numbers with the property \n\nc\no\n9\n(\nk\n)\n=\n\n\nc\no\n9\n(\n\nk\n\n2\n)\n{\\displaystyle {\\displaystyle {\\mathit {co9}}(k)={\\mathit {co9}}(k^{2})}}\n and show that this subset is a small proportion of the range and contains all the Kaprekar in the range.\n\nPart 3\n\nConsidering this MathWorld page, produce a efficient algorithm based on the more mathematical treatment of Casting Out Nines, and realizing:\n\n:   c\n    o\n    9\n    (\n    x\n    )\n    {\\displaystyle {\\displaystyle {\\mathit {co9}}(x)}}\n     is the residual of \n\n    x\n    {\\displaystyle {\\displaystyle x}}\n     mod \n\n    9\n    {\\displaystyle {\\displaystyle 9}}\n    ;\n:   the procedure can be extended to bases other than 9.\n\nDemonstrate your algorithm by generating or filtering a range of numbers with the property \n\nk\n%\n(\n\n\nB\na\ns\ne\n−\n1\n)\n==\n(\n\nk\n\n2\n)\n%\n(\n\n\nB\na\ns\ne\n−\n1\n)\n{\\displaystyle {\\displaystyle k\\%({\\mathit {Base}}-1)==(k^{2})\\%({\\mathit {Base}}-1)}}\n and show that this subset is a small proportion of the range and contains all the Kaprekar in the range.\n\nrelated tasks\n\n* First perfect square in base N with N unique digits\n* Kaprekar numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub cast-out(\\BASE = 10, \\MIN = 1, \\MAX = BASE**2 - 1) {\n  my \\B9 = BASE - 1;\n  my @ran = ($_ if $_ % B9 == $_**2 % B9 for ^B9);\n  my $x = MIN div B9;\n  gather loop {\n    for @ran -> \\n {\n      my \\k = B9 * $x + n;\n      take k if k >= MIN;\n    }\n    $x++;\n  } ...^ * > MAX;\n}\n\nsay cast-out;\nsay cast-out 16;\nsay cast-out 17;\n\n```\n\nOutput:\n\n```\n(1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99)\n(1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 105 106 111 115 120 121 126 130 135 136 141 145 150 151 156 160 165 166 171 175 180 181 186 190 195 196 201 205 210 211 216 220 225 226 231 235 240 241 246 250 255)\n(1 16 17 32 33 48 49 64 65 80 81 96 97 112 113 128 129 144 145 160 161 176 177 192 193 208 209 224 225 240 241 256 257 272 273 288)\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Catalan numbers. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nCatalan numbers are a sequence of numbers which can be defined directly:\n\n:   C\n\n    n\n    =\n\n\n    1\n\n    n\n    +\n    1\n\n    (\n\n\n    2\n    n\n    n\n\n    )\n    =\n\n    (\n    2\n    n\n    )\n    !\n\n    (\n    n\n    +\n    1\n    )\n    !\n\n    n\n    !\n\n     for \n    n\n    ≥\n    0.\n    {\\displaystyle {\\displaystyle C\\_{n}={\\frac {1}{n+1}}{2n \\choose n}={\\frac {(2n)!}{(n+1)!\\,n!}}\\qquad {\\mbox{ for }}n\\geq 0.}}\n\nOr recursively:\n\n:   C\n\n    0\n    =\n    1\n\n    and\n\n\n    C\n\n    n\n    +\n    1\n    =\n\n    ∑\n\n    i\n    =\n    0\n\n    n\n\n    C\n\n    i\n\n\n    C\n\n    n\n    −\n    i\n\n\n    for \n    n\n    ≥\n    0\n    ;\n    {\\displaystyle {\\displaystyle C\\_{0}=1\\quad {\\mbox{and}}\\quad C\\_{n+1}=\\sum \\_{i=0}^{n}C\\_{i}\\,C\\_{n-i}\\quad {\\text{for }}n\\geq 0;}}\n\nOr alternatively (also recursive):\n\n:   C\n\n    0\n    =\n    1\n\n    and\n\n\n    C\n\n    n\n    =\n\n    2\n    (\n    2\n    n\n    −\n    1\n    )\n\n    n\n    +\n    1\n\n    C\n\n    n\n    −\n    1\n    ,\n    {\\displaystyle {\\displaystyle C\\_{0}=1\\quad {\\mbox{and}}\\quad C\\_{n}={\\frac {2(2n-1)}{n+1}}C\\_{n-1},}}\n\nTask\n\nImplement at least one of these algorithms and print out the first 15 Catalan numbers with each.\n\nMemoization   is not required, but may be worth the effort when using the second method above.\n\nRelated tasks\n\n* Catalan numbers/Pascal's triangle\n* Evaluate binomial coefficients"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\nThe recursive formulas are easily written into a constant array, either:\n\n```\nconstant Catalan = 1, { [+] @_ Z* @_.reverse } ... *;\n```\n\nor\n\n```\nconstant Catalan = 1, |[\\*] (2, 6 ... *) Z/ 2 .. *;\n\n\n# In both cases, the sixteen first values can be seen with:\n.say for Catalan[^16];\n```\n\nOutput:\n\n```\n1\n1\n2\n5\n14\n42\n132\n429\n1430\n4862\n16796\n58786\n208012\n742900\n2674440\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nPrint out the first   **15**   Catalan numbers by extracting them from Pascal's triangle.\n\nSee\n\n* Catalan Numbers and the Pascal Triangle.     This method enables calculation of Catalan Numbers using only addition and subtraction.\n* Catalan's Triangle for a Number Triangle that generates Catalan Numbers using only addition.\n* Sequence A000108 on OEIS has a lot of information on Catalan Numbers.\n\nRelated Tasks\n\nPascal's triangle"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nconstant @pascal = [1], -> @p { [0, |@p Z+ |@p, 0] } ... *;\n\nconstant @catalan = gather for 2, 4 ... * -> $ix {\n    my @row := @pascal[$ix];\n    my $mid = +@row div 2;\n    take [-] @row[$mid, $mid+1]\n}\n\n.say for @catalan[^20];\n\n```\n\nOutput:\n\n```\n1\n2\n5\n14\n42\n132\n429\n1430\n4862\n16796\n58786\n208012\n742900\n2674440\n9694845\n35357670\n129644790\n477638700\n1767263190\n6564120420\n```"}]}
{"messages": [{"role": "user", "content": "*Reduce* is a function or method that is used to take the values in an array or a list and apply a function to successive members of the list to produce (or reduce them to), a single value.\n\nTask\n\nShow how *reduce* (or *foldl* or *foldr* etc), work (or would be implemented) in your language.\n\nSee also\n\n* Wikipedia article:   Fold\n* Wikipedia article:   Catamorphism"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nAny associative infix operator, either built-in or user-defined, may be turned into a reduce operator by putting it into square brackets (known as \"the reduce metaoperator\") and using it as a list operator. The operations will work left-to-right or right-to-left automatically depending on the natural associativity of the base operator.\n\n```\nmy @list = 1..10;\nsay [+] @list;\nsay [*] @list;\nsay [~] @list;\nsay min @list;\nsay max @list;\nsay [lcm] @list;\n\n```\n\nOutput:\n\n```\n55\n3628800\n12345678910\n1\n10\n2520\n```\n\nIn addition to the reduce metaoperator, a general higher-order function, reduce, can apply any appropriate function. Reproducing the above in this form, using the function names of those operators, we have:\n\n```\nmy @list = 1..10;\nsay reduce &infix:<+>, @list;\nsay reduce &infix:<*>, @list;\nsay reduce &infix:<~>, @list;\nsay reduce &infix:<min>, @list;\nsay reduce &infix:<max>, @list;\nsay reduce &infix:<lcm>, @list;\n\n```"}]}
{"messages": [{"role": "user", "content": "Write a function which returns the centre and radius of a circle passing through three point in a plane. Demonstrate the function using the points (22.83,2.07) (14.39,30.24) and (33.65,17.31)"}, {"role": "assistant", "content": "Don't bother defining all the intermediate variables.\n\n```\nsub circle( (\\𝒳ᵢ, \\𝒴ᵢ), (\\𝒳ⱼ, \\𝒴ⱼ), (\\𝒳ₖ, \\𝒴ₖ) ) {\n   my \\𝒞ₓ = ((𝒳ᵢ² + 𝒴ᵢ²) × (𝒴ₖ - 𝒴ⱼ) + (𝒳ⱼ² + 𝒴ⱼ²) × (𝒴ᵢ - 𝒴ₖ) + (𝒳ₖ² + 𝒴ₖ²) × (𝒴ⱼ - 𝒴ᵢ)) /\n             (𝒳ᵢ × (𝒴ₖ - 𝒴ⱼ) + 𝒳ⱼ × (𝒴ᵢ - 𝒴ₖ) + 𝒳ₖ × (𝒴ⱼ - 𝒴ᵢ)) / 2 ;\n   my \\𝒞ᵧ = ((𝒳ᵢ² + 𝒴ᵢ²) × (𝒳ₖ - 𝒳ⱼ) + (𝒳ⱼ² + 𝒴ⱼ²) × (𝒳ᵢ - 𝒳ₖ) + (𝒳ₖ² + 𝒴ₖ²) × (𝒳ⱼ - 𝒳ᵢ)) /\n             (𝒴ᵢ × (𝒳ₖ - 𝒳ⱼ) + 𝒴ⱼ × (𝒳ᵢ - 𝒳ₖ) + 𝒴ₖ × (𝒳ⱼ - 𝒳ᵢ)) / 2 ;\n   center => (𝒞ₓ,𝒞ᵧ), radius => ((𝒞ₓ - 𝒳ᵢ)² + (𝒞ᵧ - 𝒴ᵢ)²).sqrt \n}\n\nsay circle (22.83,2.07), (14.39,30.24), (33.65,17.31);\n\n```\n\nOutput:\n\n```\n(center => (18.97851566 16.2654108) radius => 14.70862397833418)\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "In analytic geometry, the *centroid* of a set of points is a point in the same domain as the set. The centroid point is chosen to show a property which can be calculated for that set.\n\nConsider the centroid defined as the arithmetic mean of a set of points of arbitrary dimension.\n\nTask\n\nCreate a function in your chosen programming language to calculate such a centroid using an arbitrary number of points of arbitrary dimension.\n\nTest your function with the following groups of points\n\n```\none-dimensional: (1), (2), (3)\n\n```\n\n```\ntwo-dimensional: (8, 2), (0, 0)\n\n```\n\n```\nthree-dimensional: the set (5, 5, 0), (10, 10, 0) and the set (1, 3.1, 6.5), (-2, -5, 3.4), (-7, -4, 9), (2, 0, 3)\n\n```\n\n```\nfive-dimensional: (0, 0, 0, 0, 1), (0, 0, 0, 1, 0), (0, 0, 1, 0, 0), (0, 1, 0, 0, 0)\n\n```\n\nStretch task\n\n```\n   Show a 3D plot image of the second 3-dimensional set and its centroid.\n\n```\n\nSee Also\n\n[Wikipedia page]\n\n[Wolfram Mathworld on Centroid]"}, {"role": "assistant", "content": "```\nsub centroid { ( [»+«] @^LoL ) »/» +@^LoL }\n\nsay .&centroid for\n    ( (1,), (2,), (3,) ),\n    ( (8, 2), (0, 0) ),\n    ( (5, 5, 0), (10, 10, 0) ),\n    ( (1, 3.1, 6.5), (-2, -5, 3.4), (-7, -4, 9), (2, 0, 3) ),\n    ( (0, 0, 0, 0, 1), (0, 0, 0, 1, 0), (0, 0, 1, 0, 0), (0, 1, 0, 0, 0) ),\n;\n\n```\n\nOutput:\n\n```\n(2)\n(4 1)\n(7.5 7.5 0)\n(-1.5 -1.475 5.475)\n(0 0.25 0.25 0.25 0.25)\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nUse the dictionary   unixdict.txt\n\nChange letters   **e**   to   **i**   in words.\n\nIf the changed word is in the dictionary,   show it here on this page.\n\nThe length of any word shown should have a length   **>  5****.**\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nmy %ei = 'unixdict.txt'.IO.words.grep({ .chars > 5 and /<[ie]>/ }).map: { $_ => .subst('e', 'i', :g) };\nput %ei.grep( *.key.contains: 'e' ).grep({ %ei{.value}:exists }).sort.batch(4)».gist».fmt('%-22s').join: \"\\n\";\n\n```\n\nOutput:\n\n```\nanalyses => analysis   atlantes => atlantis   bellow => billow       breton => briton      \nclench => clinch       convect => convict     crises => crisis       diagnoses => diagnosis\nenfant => infant       enquiry => inquiry     frances => francis     galatea => galatia    \nharden => hardin       heckman => hickman     inequity => iniquity   inflect => inflict    \njacobean => jacobian   marten => martin       module => moduli       pegging => pigging    \npsychoses => psychosis rabbet => rabbit       sterling => stirling   synopses => synopsis  \nvector => victor       welles => willis\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nUsing the dictionary   unixdict.txt,   change one letter in a word,   and if the changed word occurs in the dictionary,\n  \nthen display the original word   and   the changed word here (on this page).\n\nThe length of any word shown should have a length   **>  11****.**\n\nNote\n\n* A copy of the specific unixdict.txt linked to should be used for consistency of results.\n* Words **>  11** are required, ie of 12 characters or more.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet\n\nReference\n\n* Levenshtein distance"}, {"role": "assistant", "content": "Sorensen-Dice is very fast to calculate similarities but isn't great for detecting small changes. Levenshtein is great for detecting small changes but isn't very fast.\n\nGet the best of both worlds by doing an initial filter with Sorensen, then get exact results with Levenshtein.\n\n```\nuse Text::Levenshtein;\nuse Text::Sorensen :sorensen;\n\nmy @words = grep {.chars > 11}, 'unixdict.txt'.IO.words;\n\nmy %bi-grams = @words.map: { $_ => .&bi-gram };\n\nmy %skip = @words.map: { $_ => 0 };\n\nsay (++$).fmt('%2d'), |$_ for @words.hyper.map: -> $this {\n    next if %skip{$this};\n    my ($word, @sorensens) = sorensen($this, %bi-grams);\n    next unless @sorensens.=grep: { 1 > .[0] > .8 };\n    @sorensens = @sorensens»[1].grep: {$this.chars == .chars};\n    my @levenshtein = distance($this, @sorensens).grep: * == 1, :k;\n    next unless +@levenshtein;\n    %skip{$_}++ for @sorensens[@levenshtein];\n    \": {$this.fmt('%14s')}  <->  \", @sorensens[@levenshtein].join: ', ';\n}\n\n```\n\nOutput:\n\n```\n 1:   aristotelean  <->  aristotelian\n 2: claustrophobia  <->  claustrophobic\n 3:   committeeman  <->  committeemen\n 4: committeewoman  <->  committeewomen\n 5:  complimentary  <->  complementary\n 6:   confirmation  <->  conformation\n 7:  congresswoman  <->  congresswomen\n 8:   councilwoman  <->  councilwomen\n 9:   draftsperson  <->  craftsperson\n10:   eavesdropped  <->  eavesdropper\n11:   frontiersman  <->  frontiersmen\n12: handicraftsman  <->  handicraftsmen\n13:   incommutable  <->  incomputable\n14:   installation  <->  instillation\n15:   kaleidescope  <->  kaleidoscope\n16:   neuroanatomy  <->  neuroanotomy\n17:   newspaperman  <->  newspapermen\n18:   nonagenarian  <->  nonogenarian\n19:   onomatopoeia  <->  onomatopoeic\n20:   philanthrope  <->  philanthropy\n21:   proscription  <->  prescription\n22:  schizophrenia  <->  schizophrenic\n23:  shakespearean  <->  shakespearian\n24:   spectroscope  <->  spectroscopy\n25:  underclassman  <->  underclassmen\n26:  upperclassman  <->  upperclassmen\n```"}]}
{"messages": [{"role": "user", "content": "Description\n\nThe Chaocipher was invented by J.F.Byrne in 1918 and, although simple by modern cryptographic standards, does not appear to have been broken until the algorithm was finally disclosed by his family in 2010.\n\nThe algorithm is described in this paper by M.Rubin in 2010 and there is a C# implementation here.\n\nTask\n\nCode the algorithm in your language and test that it works with the plaintext 'WELLDONEISBETTERTHANWELLSAID' used in the paper itself."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nmy @left;\nmy @right;\n\nsub reset {\n    @left  = <HXUCZVAMDSLKPEFJRIGTWOBNYQ>.comb;\n    @right = <PTLNBQDEOYSFAVZKGJRIHWXUMC>.comb;\n}\n\nsub encode ($letter) {\n    my $index = @right.first: $letter.uc, :k;\n    my $enc   = @left[$index];\n    $index.&permute;\n    $enc\n}\n\nsub decode ($letter) {\n    my $index = @left.first: $letter.uc, :k;\n    my $dec   = @right[$index];\n    $index.&permute;\n    $dec\n}\n\nsub permute ($index) {\n    @left.=rotate: $index;\n    @left[1..13].=rotate;\n    @right.=rotate: $index + 1;\n    @right[2..13].=rotate;\n}\n\nreset;\nsay 'WELLDONEISBETTERTHANWELLSAID'.comb».&encode.join;\nreset;\nsay 'OAHQHCNYNXTSZJRRHJBYHQKSOUJY'.comb».&decode.join;\n\n```\n\nOutput:\n\n```\nOAHQHCNYNXTSZJRRHJBYHQKSOUJY\nWELLDONEISBETTERTHANWELLSAID\n```"}]}
{"messages": [{"role": "user", "content": "The Chaos Game is a method of generating the attractor of an iterated function system (IFS).\n\nOne of the best-known and simplest examples creates a fractal, using a polygon and an initial point selected at random.\n\nTask\n\nPlay the Chaos Game using the corners of an equilateral triangle as the reference points.   Add a starting point at random (preferably inside the triangle).   Then add the next point halfway between the starting point and one of the reference points.   This reference point is chosen at random.\n\nAfter a sufficient number of iterations, the image of a Sierpinski Triangle should emerge.\n\nSee also\n\n* The Game of Chaos"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.10\n\n```\nuse Image::PNG::Portable;\n\nmy ($w, $h) = (640, 640);\n\nmy $png = Image::PNG::Portable.new: :width($w), :height($h);\n\nmy @vertex = [0, 0], [$w, 0], [$w/2, $h];\n\nmy @xy = [0,0], [0,0], [0,0], [0,0];\n\n# :degree must be equal to or less than @xy elements.\n(^1e5).race(:4degree).map: {\n    my $p = ++$ % +@xy;\n    @xy[$p] = do given @vertex.pick -> @v { ((@xy[$p] »+« @v) »/» 2)».Int };\n    $png.set: |@xy[$p], 0, 255, 0;\n}\n\n$png.write: 'Chaos-game-perl6.png';\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a character value in your language, print its code   (could be ASCII code, Unicode code, or whatever your language uses).\n\nExample\n\nThe character   'a'   (lowercase letter A)   has a code of 97 in ASCII   (as well as Unicode, as ASCII forms the beginning of Unicode).\n\nConversely, given a code, print out the corresponding character."}, {"role": "assistant", "content": "(formerly Perl 6)\nBoth Perl 5 and Raku have good Unicode support, though Raku attempts to make working with Unicode effortless. Note that even multi-byte emoji and characters outside the BMP are considered single characters. Also note: all of these routines are built into the base compiler. No need to load external libraries. See Wikipedia: Unicode character properties for explanation of Unicode property.\n\n```\nfor 'AΑА𪚥🇺🇸👨‍👩‍👧‍👦'.comb {\n    .put for\n    [ 'Character',\n      'Character name',\n      'Unicode property',\n      'Unicode script',\n      'Unicode block',\n      'Added in Unicode version',\n      'Ordinal(s)',\n      'Hex ordinal(s)',\n      'UTF-8',\n      'UTF-16LE',\n      'UTF-16BE',\n      'Round trip by name',\n      'Round trip by ordinal'\n    ]».fmt('%25s:')\n    Z\n    [ $_,\n      .uninames.join(', '),\n      .uniprops.join(', '),\n      .uniprops('Script').join(', '),\n      .uniprops('Block').join(', '),\n      .uniprops('Age').join(', '),\n      .ords,\n      .ords.fmt('0x%X'),\n      .encode('utf8'   )».fmt('%02X'),\n      .encode('utf16le')».fmt('%02X').join.comb(4),\n      .encode('utf16be')».fmt('%02X').join.comb(4),\n      .uninames».uniparse.join,\n      .ords.chrs\n    ];\n    say '';\n}\n```\n\nOutput:\n\n```\n                Character: A\n           Character name: LATIN CAPITAL LETTER A\n         Unicode property: Lu\n           Unicode script: Latin\n            Unicode block: Basic Latin\n Added in Unicode version: 1.1\n               Ordinal(s): 65\n           Hex ordinal(s): 0x41\n                    UTF-8: 41\n                 UTF-16LE: 4100\n                 UTF-16BE: 0041\n       Round trip by name: A\n    Round trip by ordinal: A\n\n                Character: Α\n           Character name: GREEK CAPITAL LETTER ALPHA\n         Unicode property: Lu\n           Unicode script: Greek\n            Unicode block: Greek and Coptic\n Added in Unicode version: 1.1\n               Ordinal(s): 913\n           Hex ordinal(s): 0x391\n                    UTF-8: CE 91\n                 UTF-16LE: 9103\n                 UTF-16BE: 0391\n       Round trip by name: Α\n    Round trip by ordinal: Α\n\n                Character: А\n           Character name: CYRILLIC CAPITAL LETTER A\n         Unicode property: Lu\n           Unicode script: Cyrillic\n            Unicode block: Cyrillic\n Added in Unicode version: 1.1\n               Ordinal(s): 1040\n           Hex ordinal(s): 0x410\n                    UTF-8: D0 90\n                 UTF-16LE: 1004\n                 UTF-16BE: 0410\n       Round trip by name: А\n    Round trip by ordinal: А\n\n                Character: 𪚥\n           Character name: CJK UNIFIED IDEOGRAPH-2A6A5\n         Unicode property: Lo\n           Unicode script: Han\n            Unicode block: CJK Unified Ideographs Extension B\n Added in Unicode version: 3.1\n               Ordinal(s): 173733\n           Hex ordinal(s): 0x2A6A5\n                    UTF-8: F0 AA 9A A5\n                 UTF-16LE: 69D8 A5DE\n                 UTF-16BE: D869 DEA5\n       Round trip by name: 𪚥\n    Round trip by ordinal: 𪚥\n\n                Character: 🇺🇸\n           Character name: REGIONAL INDICATOR SYMBOL LETTER U, REGIONAL INDICATOR SYMBOL LETTER S\n         Unicode property: So, So\n           Unicode script: Common, Common\n            Unicode block: Enclosed Alphanumeric Supplement, Enclosed Alphanumeric Supplement\n Added in Unicode version: 6.0, 6.0\n               Ordinal(s): 127482 127480\n           Hex ordinal(s): 0x1F1FA 0x1F1F8\n                    UTF-8: F0 9F 87 BA F0 9F 87 B8\n                 UTF-16LE: 3CD8 FADD 3CD8 F8DD\n                 UTF-16BE: D83C DDFA D83C DDF8\n       Round trip by name: 🇺🇸\n    Round trip by ordinal: 🇺🇸\n\n                Character: 👨‍👩‍👧‍👦\n           Character name: MAN, ZERO WIDTH JOINER, WOMAN, ZERO WIDTH JOINER, GIRL, ZERO WIDTH JOINER, BOY\n         Unicode property: So, Cf, So, Cf, So, Cf, So\n           Unicode script: Common, Inherited, Common, Inherited, Common, Inherited, Common\n            Unicode block: Miscellaneous Symbols and Pictographs, General Punctuation, Miscellaneous Symbols and Pictographs, General Punctuation, Miscellaneous Symbols and Pictographs, General Punctuation, Miscellaneous Symbols and Pictographs\n Added in Unicode version: 6.0, 1.1, 6.0, 1.1, 6.0, 1.1, 6.0\n               Ordinal(s): 128104 8205 128105 8205 128103 8205 128102\n           Hex ordinal(s): 0x1F468 0x200D 0x1F469 0x200D 0x1F467 0x200D 0x1F466\n                    UTF-8: F0 9F 91 A8 E2 80 8D F0 9F 91 A9 E2 80 8D F0 9F 91 A7 E2 80 8D F0 9F 91 A6\n                 UTF-16LE: 3DD8 68DC 0D20 3DD8 69DC 0D20 3DD8 67DC 0D20 3DD8 66DC\n                 UTF-16BE: D83D DC68 200D D83D DC69 200D D83D DC67 200D D83D DC66\n       Round trip by name: 👨‍👩‍👧‍👦\n    Round trip by ordinal: 👨‍👩‍👧‍👦\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a server for a minimal text based chat.\n\nPeople should be able to connect via ‘telnet’, sign on with a nickname, and type messages which will then be seen by all other connected users. Arrivals and departures of chat members should generate appropriate notification messages."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n(or at least started out that way)\n\n**Works with**: Rakudo version 2016.07\n\n```\nreact {\n    my %connections;\n    \n    whenever IO::Socket::Async.listen('localhost', 4004) -> $conn {\n        my $name;\n        \n        $conn.print: \"Please enter your name: \";\n        \n        whenever $conn.Supply.lines -> $message {\n            if !$name {\n                if %connections{$message} {\n                    $conn.print: \"Name already taken, choose another one: \";\n                }\n                else {\n                    $name = $message;\n                    %connections{$name} = $conn;\n                    broadcast \"+++ %s arrived +++\", $name;\n                }\n            }\n            else {\n                broadcast \"%s> %s\", $name, $message;\n            }\n            LAST {\n                broadcast \"--- %s left ---\", $name;\n                %connections{$name}:delete;\n                $conn.close ;\n            }\n            QUIT {\n                 default {\n                     say \"oh no, $_\";\n                }\n            }\n        }\n    }\n    \n    sub broadcast ($format, $from, *@message) {\n        my $text = sprintf $format, $from, |@message;\n        say $text;\n        for %connections.kv -> $name, $conn {\n            $conn.print: \"$text\\n\" if $name ne $from;\n        }\n    }\n}\n\n```\n\nNotes:\n\n* It operates asynchronously (using IO::Socket::Async), so a slow connection to one client won't affect other clients.\n* It accepts messages encoded in UTF-8.\n* It tokenizes the message streams at newline boundaries (using the Supply.lines method), which I think makes the most sense for a chat application."}]}
{"messages": [{"role": "user", "content": "Chebyshev coefficients are the basis of polynomial approximations of functions.\n\nTask\n\nWrite a program to generate Chebyshev coefficients.\n\nCalculate coefficients:   cosine function,   **10**   coefficients,   interval   **0   1**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: C\n\n```\nsub chebft ( Code $func, Real \\a, Real \\b, Int \\n ) {\n\n    my \\bma = ½ × (b - a);\n    my \\bpa = ½ × (b + a);\n\n    my @pi-n = ( ^n »+» ½ ) »×» (π/n);\n    my @f    = ( @pi-n».cos »×» bma »+» bpa )».&$func;\n    my @sums = (^n).map: { [+] @f »×« ( @pi-n »×» $_ )».cos };\n\n    @sums »×» (2/n)\n}\n\nsay chebft(&cos, 0, 1, 10)».fmt: '%+13.7e';\n\n```\n\nOutput:\n\n```\n+1.6471695e+00\n-2.3229937e-01\n-5.3715115e-02\n+2.4582353e-03\n+2.8211906e-04\n-7.7222292e-06\n-5.8985565e-07\n+1.1521427e-08\n+6.5962992e-10\n-1.0021994e-11\n```"}]}
{"messages": [{"role": "user", "content": "Self-explanatory: given a polygon (as an array/vector/list of its vertices) and a rectangle (in x, y, width, height format), check if they intersect.\n\nRelated tasks\n\n* Determine if two triangles overlap\n* Check if two polygons overlap"}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20230810 Raku programming solution\n\nclass Vector2 { has ( $.x, $.y );\n   method dot ( \\other ) { self.x * other.x + self.y * other.y }\n}; \n\nclass Rectangle { has ( $.x, $.y, $.w, $.h ) }\n\nclass Projection { has ( $.min, $.max ) };\n\nsub getAxes(\\poly) {\n   return poly.append(poly[0]).rotor(2=>-1).map: -> (\\vertex1,\\vertex2) {\n      my \\vector1 = Vector2.new: x => vertex1[0], y => vertex1[1];\n      my \\vector2 = Vector2.new: x => vertex2[0], y => vertex2[1];\n      my \\edge    = Vector2.new: x => vector1.x - vector2.x, \n                                 y => vector1.y - vector2.y;\n      $_ = Vector2.new: x => -edge.y, y => edge.x\n   }\n}\n\nsub projectOntoAxis(\\poly, \\axis) {\n   my \\vertex0 = poly[0];\n   my \\vector0 = Vector2.new: x => vertex0[0], y => vertex0[1];\n   my $max     = my $min = axis.dot: vector0;\n   for poly -> \\vertex {\n      my \\vector = Vector2.new: x => vertex[0], y => vertex[1];\n      given axis.dot: vector { when $_ < $min { $min = $_ } \n                               when $_ > $max { $max = $_ } }\n   }\n   return Projection.new: min => $min, max => $max\n}\n\nsub projectionsOverlap(\\proj1, \\proj2) {\n   return ! ( proj1.max < proj2.min or proj2.max < proj1.min )\n}\n\nsub rectToPolygon( \\r ) {\n    return [(r.x, r.y), (r.x, r.y+r.h), (r.x+r.w, r.y+r.h), (r.x+r.w, r.y)]\n}\n\nsub polygonOverlapsRect(\\poly1, \\rect) {\n   my \\poly2 = rectToPolygon rect;\n   my (\\axes1,\\axes2) := (poly1,poly2).map: { getAxes $_ };\n   for (axes1, axes2) -> \\axes {\n     for axes -> \\axis {\n         my (\\proj1,\\proj2) := (poly1,poly2).map: { projectOntoAxis $_, axis }\n         return False unless projectionsOverlap(proj1, proj2) \n      }\n   }\n   return True\n}\n\nmy \\poly = [ <0 0>, <0 2>, <1 4>, <2 2>, <2 0> ]; \nmy \\rect1 = Rectangle.new: :4x, :0y, :2h, :2w;\nmy \\rect2 = Rectangle.new: :1x, :0y, :8h, :2w;\nsay \"poly  = \", poly;\nsay \"rect1 = \", rectToPolygon(rect1);\nsay \"rect2 = \", rectToPolygon(rect2);\nsay();\nsay \"poly and rect1 overlap? \", polygonOverlapsRect(poly, rect1);\nsay \"poly and rect2 overlap? \", polygonOverlapsRect(poly, rect2);\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Self-explanatory: given two polygons (as a list of their vertices), check whether they overlap.\n\nRelated tasks\n\n* Determine if two triangles overlap\n* Check if a polygon overlaps with a rectangle"}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20230810 Raku programming solution\n\nclass Vector2 { has ( $.x, $.y );\n   method dot ( \\other ) { self.x * other.x + self.y * other.y }\n}; \n\nclass Projection { has ( $.min, $.max ) };\n\nsub getAxes ( \\poly ) {\n   return poly.append(poly[0]).rotor(2=>-1).map: -> (\\vertex1,\\vertex2) {\n      my \\vector1 = Vector2.new: x => vertex1[0], y => vertex1[1];\n      my \\vector2 = Vector2.new: x => vertex2[0], y => vertex2[1];\n      my \\edge    = Vector2.new: x => vector1.x - vector2.x, \n                                 y => vector1.y - vector2.y;\n      $_ = Vector2.new: x => -edge.y, y => edge.x\n   }\n}\n\nsub projectOntoAxis ( \\poly, \\axis ) {\n   my \\vertex0 = poly[0];\n   my \\vector0 = Vector2.new: x => vertex0[0], y => vertex0[1];\n   my $max     = my $min = axis.dot: vector0;\n   for poly -> \\vertex {\n      my \\vector = Vector2.new: x => vertex[0], y => vertex[1];\n      given axis.dot: vector { when $_ < $min { $min = $_ } \n                               when $_ > $max { $max = $_ } }\n   }\n   return Projection.new: min => $min, max => $max\n}\n\nsub projectionsOverlap ( \\proj1, \\proj2 ) {\n   return ! ( proj1.max < proj2.min or proj2.max < proj1.min )\n}\n\nsub polygonsOverlap( \\poly1, \\poly2 ) {\n   my (\\axes1,\\axes2) := (poly1,poly2).map: { getAxes $_ };\n   for (axes1, axes2) -> \\axes {\n     for axes -> \\axis {\n         my (\\proj1,\\proj2) := (poly1,poly2).map: { projectOntoAxis $_, axis }\n         return False unless projectionsOverlap(proj1, proj2) \n      }\n   }\n   return True\n}\n\nmy \\poly1 = [ <0 0>, <0 2>, <1 4>, <2 2>, <2 0> ];\nmy \\poly2 = [ <4 0>, <4 2>, <5 4>, <6 2>, <6 0> ];\nmy \\poly3 = [ <1 0>, <1 2>, <5 4>, <9 2>, <9 0> ];\n\nsay \"poly1 = \", poly1;\nsay \"poly2 = \", poly2;\nsay \"poly3 = \", poly3;\nsay();\nsay \"poly1 and poly2 overlap? \", polygonsOverlap(poly1, poly2);\nsay \"poly1 and poly3 overlap? \", polygonsOverlap(poly1, poly3);\nsay \"poly2 and poly3 overlap? \", polygonsOverlap(poly2, poly3);\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate how to check whether the input device is a terminal or not.\n\nRelated task\n\n* Check output device is a terminal"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nsay $*IN.t ?? \"Input comes from tty.\" !! \"Input doesn't come from tty.\";\n\n```\n\n```\n$ raku istty.raku\nInput comes from tty.\n$ true | raku istty.raku\nInput doesn't come from tty.\n\n```"}]}
{"messages": [{"role": "user", "content": "Machin-like formulas   are useful for efficiently computing numerical approximations for \n\nπ\n{\\displaystyle {\\displaystyle \\pi }}\n\nTask\n\nVerify the following Machin-like formulas are correct by calculating the value of **tan**   (*right hand side)* for each equation using exact arithmetic and showing they equal **1**:\n\n:   π\n    4\n    =\n    arctan\n    ⁡\n\n\n    1\n    2\n    +\n    arctan\n    ⁡\n\n\n    1\n    3\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=\\arctan {1 \\over 2}+\\arctan {1 \\over 3}}}\n:   π\n    4\n    =\n    2\n    arctan\n    ⁡\n\n\n    1\n    3\n    +\n    arctan\n    ⁡\n\n\n    1\n    7\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=2\\arctan {1 \\over 3}+\\arctan {1 \\over 7}}}\n:   π\n    4\n    =\n    4\n    arctan\n    ⁡\n\n\n    1\n    5\n    −\n    arctan\n    ⁡\n\n\n    1\n    239\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=4\\arctan {1 \\over 5}-\\arctan {1 \\over 239}}}\n:   π\n    4\n    =\n    5\n    arctan\n    ⁡\n\n\n    1\n    7\n    +\n    2\n    arctan\n    ⁡\n\n\n    3\n    79\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=5\\arctan {1 \\over 7}+2\\arctan {3 \\over 79}}}\n:   π\n    4\n    =\n    5\n    arctan\n    ⁡\n\n\n    29\n    278\n    +\n    7\n    arctan\n    ⁡\n\n\n    3\n    79\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=5\\arctan {29 \\over 278}+7\\arctan {3 \\over 79}}}\n:   π\n    4\n    =\n    arctan\n    ⁡\n\n\n    1\n    2\n    +\n    arctan\n    ⁡\n\n\n    1\n    5\n    +\n    arctan\n    ⁡\n\n\n    1\n    8\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=\\arctan {1 \\over 2}+\\arctan {1 \\over 5}+\\arctan {1 \\over 8}}}\n:   π\n    4\n    =\n    4\n    arctan\n    ⁡\n\n\n    1\n    5\n    −\n    arctan\n    ⁡\n\n\n    1\n    70\n    +\n    arctan\n    ⁡\n\n\n    1\n    99\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=4\\arctan {1 \\over 5}-\\arctan {1 \\over 70}+\\arctan {1 \\over 99}}}\n:   π\n    4\n    =\n    5\n    arctan\n    ⁡\n\n\n    1\n    7\n    +\n    4\n    arctan\n    ⁡\n\n\n    1\n    53\n    +\n    2\n    arctan\n    ⁡\n\n\n    1\n    4443\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=5\\arctan {1 \\over 7}+4\\arctan {1 \\over 53}+2\\arctan {1 \\over 4443}}}\n:   π\n    4\n    =\n    6\n    arctan\n    ⁡\n\n\n    1\n    8\n    +\n    2\n    arctan\n    ⁡\n\n\n    1\n    57\n    +\n    arctan\n    ⁡\n\n\n    1\n    239\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=6\\arctan {1 \\over 8}+2\\arctan {1 \\over 57}+\\arctan {1 \\over 239}}}\n:   π\n    4\n    =\n    8\n    arctan\n    ⁡\n\n\n    1\n    10\n    −\n    arctan\n    ⁡\n\n\n    1\n    239\n    −\n    4\n    arctan\n    ⁡\n\n\n    1\n    515\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=8\\arctan {1 \\over 10}-\\arctan {1 \\over 239}-4\\arctan {1 \\over 515}}}\n:   π\n    4\n    =\n    12\n    arctan\n    ⁡\n\n\n    1\n    18\n    +\n    8\n    arctan\n    ⁡\n\n\n    1\n    57\n    −\n    5\n    arctan\n    ⁡\n\n\n    1\n    239\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=12\\arctan {1 \\over 18}+8\\arctan {1 \\over 57}-5\\arctan {1 \\over 239}}}\n:   π\n    4\n    =\n    16\n    arctan\n    ⁡\n\n\n    1\n    21\n    +\n    3\n    arctan\n    ⁡\n\n\n    1\n    239\n    +\n    4\n    arctan\n    ⁡\n\n\n    3\n    1042\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=16\\arctan {1 \\over 21}+3\\arctan {1 \\over 239}+4\\arctan {3 \\over 1042}}}\n:   π\n    4\n    =\n    22\n    arctan\n    ⁡\n\n\n    1\n    28\n    +\n    2\n    arctan\n    ⁡\n\n\n    1\n    443\n    −\n    5\n    arctan\n    ⁡\n\n\n    1\n    1393\n    −\n    10\n    arctan\n    ⁡\n\n\n    1\n    11018\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=22\\arctan {1 \\over 28}+2\\arctan {1 \\over 443}-5\\arctan {1 \\over 1393}-10\\arctan {1 \\over 11018}}}\n:   π\n    4\n    =\n    22\n    arctan\n    ⁡\n\n\n    1\n    38\n    +\n    17\n    arctan\n    ⁡\n\n\n    7\n    601\n    +\n    10\n    arctan\n    ⁡\n\n\n    7\n    8149\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=22\\arctan {1 \\over 38}+17\\arctan {7 \\over 601}+10\\arctan {7 \\over 8149}}}\n:   π\n    4\n    =\n    44\n    arctan\n    ⁡\n\n\n    1\n    57\n    +\n    7\n    arctan\n    ⁡\n\n\n    1\n    239\n    −\n    12\n    arctan\n    ⁡\n\n\n    1\n    682\n    +\n    24\n    arctan\n    ⁡\n\n\n    1\n    12943\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=44\\arctan {1 \\over 57}+7\\arctan {1 \\over 239}-12\\arctan {1 \\over 682}+24\\arctan {1 \\over 12943}}}\n:   π\n    4\n    =\n    88\n    arctan\n    ⁡\n\n\n    1\n    172\n    +\n    51\n    arctan\n    ⁡\n\n\n    1\n    239\n    +\n    32\n    arctan\n    ⁡\n\n\n    1\n    682\n    +\n    44\n    arctan\n    ⁡\n\n\n    1\n    5357\n    +\n    68\n    arctan\n    ⁡\n\n\n    1\n    12943\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=88\\arctan {1 \\over 172}+51\\arctan {1 \\over 239}+32\\arctan {1 \\over 682}+44\\arctan {1 \\over 5357}+68\\arctan {1 \\over 12943}}}\n\nand confirm that the following formula is *incorrect* by showing   **tan**   (*right hand side)*   is *not*   **1**:\n\n:   π\n    4\n    =\n    88\n    arctan\n    ⁡\n\n\n    1\n    172\n    +\n    51\n    arctan\n    ⁡\n\n\n    1\n    239\n    +\n    32\n    arctan\n    ⁡\n\n\n    1\n    682\n    +\n    44\n    arctan\n    ⁡\n\n\n    1\n    5357\n    +\n    68\n    arctan\n    ⁡\n\n\n    1\n    12944\n    {\\displaystyle {\\displaystyle {\\pi \\over 4}=88\\arctan {1 \\over 172}+51\\arctan {1 \\over 239}+32\\arctan {1 \\over 682}+44\\arctan {1 \\over 5357}+68\\arctan {1 \\over 12944}}}\n\nThese identities are useful in calculating the values:\n\n:   tan\n    ⁡\n    (\n    a\n    +\n    b\n    )\n    =\n\n    tan\n    ⁡\n    (\n    a\n    )\n    +\n    tan\n    ⁡\n    (\n    b\n    )\n\n    1\n    −\n    tan\n    ⁡\n    (\n    a\n    )\n    tan\n    ⁡\n    (\n    b\n    )\n    {\\displaystyle {\\displaystyle \\tan(a+b)={\\tan(a)+\\tan(b) \\over 1-\\tan(a)\\tan(b)}}}\n\n:   tan\n    ⁡\n\n    (\n\n    arctan\n    ⁡\n\n\n    a\n    b\n    )\n    =\n\n\n    a\n    b\n    {\\displaystyle {\\displaystyle \\tan \\left(\\arctan {a \\over b}\\right)={a \\over b}}}\n\n:   tan\n    ⁡\n    (\n    −\n    a\n    )\n    =\n    −\n    tan\n    ⁡\n    (\n    a\n    )\n    {\\displaystyle {\\displaystyle \\tan(-a)=-\\tan(a)}}\n\nYou can store the equations in any convenient data structure, but for extra credit parse them from human-readable text input.\n\nNote: to formally prove the formula correct, it would have to be shown that *−\n3\nπ\n4\n{\\displaystyle {\\displaystyle {-3\\pi \\over 4}}}\n < right hand side < \n\n5\nπ\n4\n{\\displaystyle {\\displaystyle {5\\pi \\over 4}}}* due to *tan\n⁡\n(\n)\n{\\displaystyle {\\displaystyle \\tan()}}* periodicity."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\nThe coercion to FatRat provides for exact computation for all input.\n\n**Translation of**: Perl\n\n```\nsub taneval ($coef, $f) {\n  return 0 if $coef == 0;\n  return $f if $coef == 1;\n  return -taneval(-$coef, $f) if $coef < 0;\n\n  my $a = taneval($coef+>1, $f);\n  my $b = taneval($coef - $coef+>1, $f);\n  ($a+$b)/(1-$a*$b);\n}\n\nsub tans (@xs) {\n  return taneval(@xs[0;0], @xs[0;1].FatRat) if @xs == 1;\n\n  my $a = tans(@xs[0 .. (-1+@xs+>1)]);\n  my $b = tans(@xs[(-1+@xs+>1)+1 .. -1+@xs]);\n  ($a+$b)/(1-$a*$b);\n}\n\nsub verify (@eqn) {\n  printf \"%5s (%s)\\n\", (tans(@eqn) == 1) ?? \"OK\" !! \"Error\",\n    (map { \"[{.[0]} {.[1].nude.join('/')}]\" }, @eqn).join(' ');\n}\n\nverify($_) for\n   ([[1,1/2], [1,1/3]],\n    [[2,1/3], [1,1/7]],\n    [[4,1/5], [-1,1/239]],\n    [[5,1/7], [2,3/79]],\n    [[5,29/278], [7,3/79]],\n    [[1,1/2], [1,1/5], [1,1/8]],\n    [[4,1/5], [-1,1/70], [1,1/99]],\n    [[5,1/7], [4,1/53], [2,1/4443]],\n    [[6,1/8], [2,1/57], [1,1/239]],\n    [[8,1/10], [-1,1/239], [-4,1/515]],\n    [[12,1/18], [8,1/57], [-5,1/239]],\n    [[16,1/21], [3,1/239], [4,3/1042]],\n    [[22,1/28], [2,1/443], [-5,1/1393], [-10,1/11018]],\n    [[22,1/38], [17,7/601], [10,7/8149]],\n    [[44,1/57], [7,1/239], [-12,1/682], [24,1/12943]],\n    [[88,1/172], [51,1/239], [32,1/682], [44,1/5357], [68,1/12943]],\n    [[88,1/172], [51,1/239], [32,1/682], [44,1/5357], [68,1/21944]]\n    );\n\n```\n\nOutput:\n\n```\n   OK ([1 1/2] [1 1/3])\n   OK ([2 1/3] [1 1/7])\n   OK ([4 1/5] [-1 1/239])\n   OK ([5 1/7] [2 3/79])\n   OK ([5 29/278] [7 3/79])\n   OK ([1 1/2] [1 1/5] [1 1/8])\n   OK ([4 1/5] [-1 1/70] [1 1/99])\n   OK ([5 1/7] [4 1/53] [2 1/4443])\n   OK ([6 1/8] [2 1/57] [1 1/239])\n   OK ([8 1/10] [-1 1/239] [-4 1/515])\n   OK ([12 1/18] [8 1/57] [-5 1/239])\n   OK ([16 1/21] [3 1/239] [4 3/1042])\n   OK ([22 1/28] [2 1/443] [-5 1/1393] [-10 1/11018])\n   OK ([22 1/38] [17 7/601] [10 7/8149])\n   OK ([44 1/57] [7 1/239] [-12 1/682] [24 1/12943])\n   OK ([88 1/172] [51 1/239] [32 1/682] [44 1/5357] [68 1/12943])\nError ([88 1/172] [51 1/239] [32 1/682] [44 1/5357] [68 1/21944])\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate how to check whether the output device is a terminal or not.\n\nRelated task\n\n* Check input device is a terminal"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\nThe .t method on a filehandle tells you whether it's going to the terminal. Here we use the note function to emit our result to standard error rather than standard out.\n\n```\n$ raku -e 'note $*OUT.t'\nTrue\n$ raku -e 'note $*OUT.t' >/dev/null\nFalse\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nVerify that a file called     **input.txt**     and   a directory called     **docs**     exist.\n\nThis should be done twice:\n\n:   :   :   * once for the current working directory,   and\n            * once for a file and a directory in the filesystem root.\n\nOptional criteria (May 2015):   verify it works with:\n\n:   :   :   * zero-length files\n            * an unusual filename:     **`Abdu'l-Bahá.txt**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $path = \"/etc/passwd\";\nsay $path.IO.e ?? \"Exists\" !! \"Does not exist\";\n\ngiven $path.IO {\n    when :d { say \"$path is a directory\"; }\n    when :f { say \"$path is a regular file\"; }\n    when :e { say \"$path is neither a directory nor a file, but it does exist\"; }\n    default { say \"$path does not exist\" }\n}\n\n```\n\n`when` internally uses the smart match operator `~~`, so `when :e` really does `$given ~~ :e` instead of the method call `$given.e`; both test whether the file exists.\n\n```\nrun ('touch', \"♥ Unicode.txt\");\n\nsay \"♥ Unicode.txt\".IO.e;      # \"True\"\nsay \"♥ Unicode.txt\".IO ~~ :e;  # same\n\n```"}]}
{"messages": [{"role": "user", "content": "The checkpoint synchronization is a problem of synchronizing multiple tasks. Consider a workshop where several workers (tasks) assembly details of some mechanism. When each of them completes his work they put the details together. There is no store, so a worker who finished its part first must wait for others before starting another one. Putting details together is the *checkpoint* at which tasks synchronize themselves before going their paths apart.\n\n**The task**\n\nImplement checkpoint synchronization in your language.\n\nMake sure that the solution is race condition-free. Note that a straightforward solution based on events is exposed to race condition. Let two tasks A and B need to be synchronized at a checkpoint. Each signals its event (*EA* and *EB* correspondingly), then waits for the AND-combination of the events (*EA*&*EB*) and resets its event. Consider the following scenario: A signals *EA* first and gets blocked waiting for *EA*&*EB*. Then B signals *EB* and loses the processor. Then A is released (both events are signaled) and resets *EA*. Now if B returns and enters waiting for *EA*&*EB*, it gets lost.\n\nWhen a worker is ready it shall not continue before others finish. A typical implementation bug is when a worker is counted twice within one working cycle causing its premature completion. This happens when the quickest worker serves its cycle two times while the laziest one is lagging behind.\n\nIf you can, implement workers joining and leaving."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $TotalWorkers = 3;\nmy $BatchToRun = 3;\nmy @TimeTaken = (5..15); # in seconds\n\nmy $batch_progress = 0;\nmy @batch_lock = map { Semaphore.new(1) } , ^$TotalWorkers;\nmy $lock = Lock.new;\n\nsub assembly_line ($ID) {\n   my $wait;\n   for ^$BatchToRun -> $j {\n      $wait = @TimeTaken.roll;\n      say \"Worker \",$ID,\" at batch $j will work for \",$wait,\" seconds ..\";\n      sleep($wait);\n      $lock.protect: {\n         my $k = ++$batch_progress;\n         print \"Worker \",$ID,\" is done and update batch $j complete counter \";\n         say \"to $k of $TotalWorkers\";\n         if ($batch_progress == $TotalWorkers) {\n            say \">>>>> batch $j completed.\";\n            $batch_progress = 0; # reset for next batch\n            for @batch_lock { .release }; # and ready for next batch\n         };\n       };\n\n       @batch_lock[$ID].acquire; # for next batch\n   }\n}\n\nfor ^$TotalWorkers -> $i {\n   Thread.start(\n      sub {\n         @batch_lock[$i].acquire;\n         assembly_line($i);\n      }\n   );\n}\n\n```\n\nOutput:\n\n```\nWorker 1 at batch 0 will work for 6 seconds ..\nWorker 2 at batch 0 will work for 32 seconds ..\nWorker 0 at batch 0 will work for 13 seconds ..\nWorker 1 is done and update batch 0 complete counter to 1 of 3\nWorker 0 is done and update batch 0 complete counter to 2 of 3\nWorker 2 is done and update batch 0 complete counter to 3 of 3\n>>>>> batch 0 completed.\nWorker 2 at batch 1 will work for 27 seconds ..\nWorker 0 at batch 1 will work for 18 seconds ..\nWorker 1 at batch 1 will work for 13 seconds ..\nWorker 1 is done and update batch 1 complete counter to 1 of 3\nWorker 0 is done and update batch 1 complete counter to 2 of 3\nWorker 2 is done and update batch 1 complete counter to 3 of 3\n>>>>> batch 1 completed.\nWorker 2 at batch 2 will work for 5 seconds ..\nWorker 0 at batch 2 will work for 28 seconds ..\nWorker 1 at batch 2 will work for 33 seconds ..\nWorker 2 is done and update batch 2 complete counter to 1 of 3\nWorker 0 is done and update batch 2 complete counter to 2 of 3\nWorker 1 is done and update batch 2 complete counter to 3 of 3\n>>>>> batch 2 completed.\n\n```"}]}
{"messages": [{"role": "user", "content": "**Context:** In December 2013 a patch was proposed to the coreutils list to add a --color option to the commands md5sum and shaXsum to display the checksums in color to make it easier to visually identify similarities in a list of printed checksums. The patch was not accepted for inclusion and instead it was suggested to create a command line utility which can be used to pipe the output of the md5sum and shaXsum commands similar to the utility colordiff.\n\n**Task:** The task is to create this command line utility that we can use to pipe the output of the md5sum and shaXsum commands and that colors the checksum part of the output. Take each group of 3 or 6 hexadecimal characters and interpret it as if it was a color code and print it with the closest console color. Print with colors if the output is the terminal or print the input unchanged if the output of the utility is a pipe.\n\n**Example:**\n\n```\n$ md5sum coreutils-* | checksumcolor\nab20d840e13adfebf2b6936a2dab071b  coreutils-8.29.tar.gz\nb259b2936bb46009be3f5cc06a12c32d  coreutils-8.30.tar.gz\n03cf26420de566c306d340df52f6ccd7  coreutils-8.31.tar.gz\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\nTo determine the colors, rather than breaking the md5sum into groups of 3 characters, (which leaves two lonely characters at the end), I elected to replicate the first 5 characters onto the end, then for each character, used it and the 5 characters following as a true-color index. I also added an option to output as HTML code for ease of pasting in here.\n\n```\nunit sub MAIN ($mode = 'ANSI');\n\nif $*OUT.t or $mode eq 'HTML' { # if OUT is a terminal or if in HTML $module\n\n    say '<div style=\"background-color:black; font-size:125%; font-family: Monaco, monospace;\">'\n      if $mode eq 'HTML';\n\n    while my $line = get() {\n        my $cs  = $line.words[0];\n        my $css = $cs ~ $cs.substr(0,5);\n        given $mode {\n            when 'ANSI' {\n                print \"\\e[48;5;232m\";\n                .print for $css.comb.rotor(6 => -5)».map({ ($^a, $^b).join })\\\n                .map( { sprintf \"\\e[38;2;%d;%d;%dm\", |$_».parse-base(16) } ) Z~ $cs.comb;\n                say \"\\e[0m  {$line.words[1..*]}\";\n            }\n            when 'HTML' {\n                print \"$_\\</span>\" for $css.comb.rotor(6 => -5)\\\n                .map( { \"<span style=\\\"color:#{.join};\\\">\" } ) Z~ $cs.comb;\n                say \" <span style=\\\"color:#ffffff\\\"> {$line.words[1..*]}</span>\";\n                say '<br>';\n            }\n            default { say $line; }\n        }\n    }\n\n    say '</div>' if $mode eq 'HTML';\n} else { # just pass the unaltered line through\n    .say while $_ = get();\n}\n\n```\n\nCan't really show the ANSI output directly so show the HTML output. Essentially identical.\n\nOutput:\n\n```\nmd5sum *.p6 | raku checksum-color.p6 HTML > checksum-color.html\n```\n\nyields:\n\nf09a3fc8551d8a703d64d8e918ece236  checksum-color (another copy).p6\n  \nf09a3fc8551d8a703d64d8e918ece236  checksum-color (copy).p6\n  \nf09a3fc8551d8a703d64d8e918ece236  checksum-color.p6\n  \nbbd8a92c326c8a35e80d2d71ab8902cd  something-completely-different.p6"}]}
{"messages": [{"role": "user", "content": "Given a molecule's chemical formula, calculate the   molar mass.\n\nIntroduction\n\n* A molecule consists of atoms.   E.g. water, H2O, has two hydrogen atoms and one oxygen atom\n* The mass of   H2O   is   1.008 \\* 2 + 15.999 = 18.015\n* An atom name consists of one upper-case letter followed by zero, one or two lower-case letters.\n  + H       (hydrogen)\n  + He     (helium)\n  + Uue   (ununennium)\n* The number of atoms is stated behind the atom or atom group\n* An atom group is specified using parenthesis.   E.g. butyric acid, (CH3)2CHCOOH, has two CH3 groups\n* A group may contain other groups, e.g.   COOH(C(CH3)2)3CH3\n\nBackground\n\n* The mass is dimensionless,   it is relative to   1/12   of Carbon-12\n* Carbon-12   has exactly   6 protons,   6 electrons,   and   6 neutrons\n* One mole of   H2O   has the mass 18.015 grams\n* One mole is defined as exactly   6.02214076×1023   particles\n\nThe above number is known as the   Avogadro constant,   which is\nnamed by the International Bureau of Weights and Measures (IBPM);\n  \nthe initials are taken from   *Bureau International des Poids et Mesures*,   the official name of the bureau.\n\nAn older name for   *Avogadro constant*   is   *Avogadro number*.\n\nAtom masses\n\nA mapping between some recognized element names and atomic mass is:\n\n```\n  H,     1.008\n  He,    4.002602\n  Li,    6.94\n  Be,    9.0121831\n  B,    10.81\n  C,    12.011\n  N,    14.007\n  O,    15.999\n  F,    18.998403163\n  Ne,   20.1797\n  Na,   22.98976928\n  Mg,   24.305\n  Al,   26.9815385\n  Si,   28.085\n  P,    30.973761998\n  S,    32.06\n  Cl,   35.45\n  K,    39.0983\n  Ar,   39.948\n  Ca,   40.078\n  Sc,   44.955908\n  Ti,   47.867\n  V,    50.9415\n  Cr,   51.9961\n  Mn,   54.938044\n  Fe,   55.845\n  Ni,   58.6934\n  Co,   58.933194\n  Cu,   63.546\n  Zn,   65.38\n  Ga,   69.723\n  Ge,   72.63\n  As,   74.921595\n  Se,   78.971\n  Br,   79.904\n  Kr,   83.798\n  Rb,   85.4678\n  Sr,   87.62\n  Y,    88.90584\n  Zr,   91.224\n  Nb,   92.90637\n  Mo,   95.95\n  Ru,   101.07\n  Rh,   102.9055\n  Pd,   106.42\n  Ag,   107.8682\n  Cd,   112.414\n  In,   114.818\n  Sn,   118.71\n  Sb,   121.76\n  I,    126.90447\n  Te,   127.6\n  Xe,   131.293\n  Cs,   132.90545196\n  Ba,   137.327\n  La,   138.90547\n  Ce,   140.116\n  Pr,   140.90766\n  Nd,   144.242\n  Pm,   145\n  Sm,   150.36\n  Eu,   151.964\n  Gd,   157.25\n  Tb,   158.92535\n  Dy,   162.5\n  Ho,   164.93033\n  Er,   167.259\n  Tm,   168.93422\n  Yb,   173.054\n  Lu,   174.9668\n  Hf,   178.49\n  Ta,   180.94788\n  W,    183.84\n  Re,   186.207\n  Os,   190.23\n  Ir,   192.217\n  Pt,   195.084\n  Au,   196.966569\n  Hg,   200.592\n  Tl,   204.38\n  Pb,   207.2\n  Bi,   208.9804\n  Po,   209\n  At,   210\n  Rn,   222\n  Fr,   223\n  Ra,   226\n  Ac,   227\n  Pa,   231.03588\n  Th,   232.0377\n  Np,   237\n  U,    238.02891\n  Am,   243\n  Pu,   244\n  Cm,   247\n  Bk,   247\n  Cf,   251\n  Es,   252\n  Fm,   257\n  Ubn,  299\n  Uue,  315\n```\n\nExamples\n\n```\nassert   1.008 == molar_mass('H')                  # hydrogen\nassert   2.016 == molar_mass('H2')                 # hydrogen gas\nassert  18.015 == molar_mass('H2O')                # water\nassert  34.014 == molar_mass('H2O2')               # hydrogen peroxide\nassert  34.014 == molar_mass('(HO)2')              # hydrogen peroxide\nassert 142.036 == molar_mass('Na2SO4')             # sodium sulfate\nassert  84.162 == molar_mass('C6H12')              # cyclohexane\nassert 186.295 == molar_mass('COOH(C(CH3)2)3CH3')  # butyric or butanoic acid \nassert 176.124 == molar_mass('C6H4O2(OH)4')        # vitamin C\nassert 386.664 == molar_mass('C27H46O')            # cholesterol\nassert 315     == molar_mass('Uue')                # ununennium\n\n```\n\nReference\n:   * Wikipedia article:   Molecular mass"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy %ATOMIC_MASS =\n    H  =>   1.008       , Fe =>  55.845    , Te => 127.60       , Ir => 192.217    ,\n    He =>   4.002602    , Co =>  58.933194 , I  => 126.90447    , Pt => 195.084    ,\n    Li =>   6.94        , Ni =>  58.6934   , Xe => 131.293      , Au => 196.966569 ,\n    Be =>   9.0121831   , Cu =>  63.546    , Cs => 132.90545196 , Hg => 200.592    ,\n    B  =>  10.81        , Zn =>  65.38     , Ba => 137.327      , Tl => 204.38     ,\n    C  =>  12.011       , Ga =>  69.723    , La => 138.90547    , Pb => 207.2      ,\n    N  =>  14.007       , Ge =>  72.630    , Ce => 140.116      , Bi => 208.98040  ,\n    O  =>  15.999       , As =>  74.921595 , Pr => 140.90766    , Po => 209        ,\n    F  =>  18.998403163 , Se =>  78.971    , Nd => 144.242      , At => 210        ,\n    Ne =>  20.1797      , Br =>  79.904    , Pm => 145          , Rn => 222        ,\n    Na =>  22.98976928  , Kr =>  83.798    , Sm => 150.36       , Fr => 223        ,\n    Mg =>  24.305       , Rb =>  85.4678   , Eu => 151.964      , Ra => 226        ,\n    Al =>  26.9815385   , Sr =>  87.62     , Gd => 157.25       , Ac => 227        ,\n    Si =>  28.085       , Y  =>  88.90584  , Tb => 158.92535    , Th => 232.0377   ,\n    P  =>  30.973761998 , Zr =>  91.224    , Dy => 162.500      , Pa => 231.03588  ,\n    S  =>  32.06        , Nb =>  92.90637  , Ho => 164.93033    , U  => 238.02891  ,\n    Cl =>  35.45        , Mo =>  95.95     , Er => 167.259      , Np => 237        ,\n    Ar =>  39.948       , Ru => 101.07     , Tm => 168.93422    , Pu => 244        ,\n    K  =>  39.0983      , Rh => 102.90550  , Yb => 173.054      , Am => 243        ,\n    Ca =>  40.078       , Pd => 106.42     , Lu => 174.9668     , Cm => 247        ,\n    Sc =>  44.955908    , Ag => 107.8682   , Hf => 178.49       , Bk => 247        ,\n    Ti =>  47.867       , Cd => 112.414    , Ta => 180.94788    , Cf => 251        ,\n    V  =>  50.9415      , In => 114.818    , W  => 183.84       , Es => 252        ,\n    Cr =>  51.9961      , Sn => 118.710    , Re => 186.207      , Fm => 257        ,\n    Mn =>  54.938044    , Sb => 121.760    , Os => 190.23       ,\n;\ngrammar Chemical_formula {\n    my @ATOMIC_SYMBOLS = %ATOMIC_MASS.keys.sort;\n\n    rule  TOP      { ^ (<lparen>|<rparen>|<element>)+ $ }\n    token quantity { \\d+ }\n    token lparen   { '(' }\n    token rparen   { ')'                    <quantity>? }\n    token element  { $<e>=[@ATOMIC_SYMBOLS] <quantity>? }\n}\nclass Chemical_formula_actions {\n    has @stack = 0;\n    method TOP     ($/) { $/.make: @stack }\n    method lparen  ($/) { push @stack, 0  }\n    method rparen  ($/) { my $m = @stack.pop;\n                          @stack[*-1] += ($<quantity> // 1) * $m }\n    method element ($/) { @stack[*-1] += ($<quantity> // 1) * %ATOMIC_MASS{~$<e>} }\n}\nsub molar_mass ( Str $formula --> Real ) {\n    Chemical_formula.parse( $formula, :actions(Chemical_formula_actions.new) )\n        orelse die \"Chemical formula not recognized: '$formula'\";\n    return $/.made.[0];\n}\nsay .&molar_mass.fmt('%7.3f '), $_ for <H H2 H2O Na2SO4 C6H12 COOH(C(CH3)2)3CH3>;\n\n```\n\nOutput:\n\n```\n  1.008 H\n  2.016 H2\n 18.015 H2O\n142.036 Na2SO4\n 84.162 C6H12\n186.295 COOH(C(CH3)2)3CH3\n```"}]}
{"messages": [{"role": "user", "content": "In 1939, Jack Chernick proved that, for **n\n≥\n3\n{\\displaystyle {\\displaystyle n\\geq 3}}** and **m\n≥\n1\n{\\displaystyle {\\displaystyle m\\geq 1}}**:\n\n```\n   \n  \n    \n      \n        \n          \n            U\n            (\n            n\n            ,\n            m\n            )\n            =\n            (\n            6\n            m\n            +\n            1\n            )\n            (\n            12\n            m\n            +\n            1\n            )\n            \n              ∏\n              \n                k\n                =\n                1\n              \n              \n                n\n                −\n                2\n              \n            \n            (\n            \n              2\n              \n                k\n              \n            \n            \n            9\n            m\n            +\n            1\n            )\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle U(n,m)=(6m+1)(12m+1)\\prod _{k=1}^{n-2}(2^{k}\\,9m+1)}}\n  \n\n\n```\n\nis a Carmichael number if all the factors are primes and, for **n\n>\n4\n{\\displaystyle {\\displaystyle n>4}}**, **m\n{\\displaystyle {\\displaystyle m}}** is a multiple of **2\n\n(\nn\n−\n4\n)\n{\\displaystyle {\\displaystyle 2^{(n-4)}}}**.\n\nExample\n\n```\n   \n  \n    \n      \n        \n          \n            U\n            (\n            3\n            ,\n            m\n            )\n            =\n            (\n            6\n            m\n            +\n            1\n            )\n            (\n            12\n            m\n            +\n            1\n            )\n            (\n            18\n            m\n            +\n            1\n            )\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle U(3,m)=(6m+1)(12m+1)(18m+1)}}\n  \n\n   \n  \n    \n      \n        \n          \n            U\n            (\n            4\n            ,\n            m\n            )\n            =\n            U\n            (\n            3\n            ,\n            m\n            )\n            (\n            \n              2\n              \n                2\n              \n            \n            9\n            m\n            +\n            1\n            )\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle U(4,m)=U(3,m)(2^{2}9m+1)}}\n  \n\n   \n  \n    \n      \n        \n          \n            U\n            (\n            5\n            ,\n            m\n            )\n            =\n            U\n            (\n            4\n            ,\n            m\n            )\n            (\n            \n              2\n              \n                3\n              \n            \n            9\n            m\n            +\n            1\n            )\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle U(5,m)=U(4,m)(2^{3}9m+1)}}\n  \n\n   \n  \n    \n      \n        \n          \n            ⋯\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\cdots }}\n  \n\n   \n  \n    \n      \n        \n          \n            U\n            (\n            n\n            ,\n            m\n            )\n            =\n            U\n            (\n            n\n            −\n            1\n            ,\n            m\n            )\n            (\n            \n              2\n              \n                (\n                n\n                −\n                2\n                )\n              \n            \n            9\n            m\n            +\n            1\n            )\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle U(n,m)=U(n-1,m)(2^{(n-2)}9m+1)}}\n  \n\n\n```\n\n* The smallest Chernick's Carmichael number with **3** prime factors, is: U(3, 1) = 1729.\n* The smallest Chernick's Carmichael number with **4** prime factors, is: U(4, 1) = 63973.\n* The smallest Chernick's Carmichael number with **5** prime factors, is: U(5, 380) = 26641259752490421121.\n\nFor **n = 5**, the smallest number **m** that satisfy Chernick's conditions, is **m = 380**, therefore **U(5, 380)** is the smallest Chernick's Carmichael number with **5** prime factors.\n\n**U(5, 380)** is a Chernick's Carmichael number because **m = 380** is a multiple of **2^(n-4)**, where **n = 5**, and the factors { (6\\*380 + 1), (12\\*380 + 1), (18\\*380 + 1), (36\\*380 + 1), (72\\*380 + 1) } are all prime numbers.\n\nTask\n\nFor **n ≥ 3**, let **a(n)** be the smallest Chernick's Carmichael number with **n** prime factors.\n\n* Compute **a(n)** for **n = 3..9**.\n* Optional: find **a(10)**.\n\n**Note**: it's perfectly acceptable to show the terms in factorized form:\n\n```\n a(3) = 7 * 13 * 19\n a(4) = 7 * 13 * 19 * 37\n a(5) = 2281 * 4561 * 6841 * 13681 * 27361\n ...\n\n```\n\nSee also\n\n* Jack Chernick, On Fermat's simple theorem (PDF), equation (8)\n\n* OEIS A318646: The least Chernick's \"universal form\" Carmichael number with n prime factors\n\nRelated tasks\n\n* Carmichael 3 strong pseudoprimes"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUse the ntheory library from Perl for primality testing since it is much, *much* faster than Raku's built-in .is-prime method.\n\n**Translation of**: Perl\n\n**Library:** ntheory\n\n```\nuse Inline::Perl5;\nuse ntheory:from<Perl5> <:all>;\n\nsub chernick-factors ($n, $m) {\n    6×$m + 1, 12×$m + 1, |((1 .. $n-2).map: { (1 +< $_) × 9×$m + 1 } )\n}\n\nsub chernick-carmichael-number ($n) {\n\n    my $multiplier = 1 +< (($n-4) max 0);\n    my $iterator   = $n < 5 ?? (1 .. *) !! (1 .. *).map: * × 5;\n\n    $multiplier × $iterator.first: -> $m {\n        [&&] chernick-factors($n, $m × $multiplier).map: { is_prime($_) }\n    }\n\n}\n\nfor 3 .. 9 -> $n {\n    my $m = chernick-carmichael-number($n);\n    my @f = chernick-factors($n, $m);\n    say \"U($n, $m): {[×] @f} = {@f.join(' ⨉ ')}\";\n}\n\n```\n\nOutput:\n\n```\nU(3, 1): 1729 = 7 ⨉ 13 ⨉ 19\nU(4, 1): 63973 = 7 ⨉ 13 ⨉ 19 ⨉ 37\nU(5, 380): 26641259752490421121 = 2281 ⨉ 4561 ⨉ 6841 ⨉ 13681 ⨉ 27361\nU(6, 380): 1457836374916028334162241 = 2281 ⨉ 4561 ⨉ 6841 ⨉ 13681 ⨉ 27361 ⨉ 54721\nU(7, 780320): 24541683183872873851606952966798288052977151461406721 = 4681921 ⨉ 9363841 ⨉ 14045761 ⨉ 28091521 ⨉ 56183041 ⨉ 112366081 ⨉ 224732161\nU(8, 950560): 53487697914261966820654105730041031613370337776541835775672321 = 5703361 ⨉ 11406721 ⨉ 17110081 ⨉ 34220161 ⨉ 68440321 ⨉ 136880641 ⨉ 273761281 ⨉ 547522561\nU(9, 950560): 58571442634534443082821160508299574798027946748324125518533225605795841 = 5703361 ⨉ 11406721 ⨉ 17110081 ⨉ 34220161 ⨉ 68440321 ⨉ 136880641 ⨉ 273761281 ⨉ 547522561 ⨉ 1095045121\n```"}]}
{"messages": [{"role": "user", "content": "Albert and Bernard just became friends with Cheryl, and they want to know when her birthday is.\n\nCheryl gave them a list of ten possible dates:\n\n```\n     May 15,     May 16,     May 19\n     June 17,    June 18\n     July 14,    July 16\n     August 14,  August 15,  August 17\n\n```\n\nCheryl then tells Albert the   *month*   of birth,   and Bernard the   *day*   (of the month)   of birth.\n\n```\n 1)  Albert:   I don't know when Cheryl's birthday is, but I know that Bernard does not know too.\n 2)  Bernard:  At first I don't know when Cheryl's birthday is, but I know now.\n 3)  Albert:   Then I also know when Cheryl's birthday is.\n\n```\n\nTask\n\nWrite a computer program to deduce, by successive elimination, Cheryl's birthday.\n\nRelated task\n\n* Sum and Product Puzzle\n\nReferences\n\n* Wikipedia article of the same name.\n* Tuple Relational Calculus"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @dates =\n    { :15day, :5month },\n    { :16day, :5month },\n    { :19day, :5month },\n    { :17day, :6month },\n    { :18day, :6month },\n    { :14day, :7month },\n    { :16day, :7month },\n    { :14day, :8month },\n    { :15day, :8month },\n    { :17day, :8month }\n;\n\n# Month can't have a unique day\nmy @filtered = @dates.grep(*.<month> != one(@dates.grep(*.<day> == one(@dates».<day>))».<month>));\n\n# Day must be unique and unambiguous in remaining months\nmy $birthday = @filtered.grep(*.<day> == one(@filtered».<day>)).classify({.<month>})\\\n    .first(*.value.elems == 1).value[0];\n\n# convenience array\nmy @months = <'' January February March April May June July August September October November December>;\n\nsay \"Cheryl's birthday is { @months[$birthday<month>] } {$birthday<day>}.\";\n\n```\n\nOutput:\n\n```\nCheryl's birthday is July 16.\n```"}]}
{"messages": [{"role": "user", "content": "Suppose   \n\nn\n\n1\n{\\displaystyle {\\displaystyle n\\_{1}}}\n,   \n\nn\n\n2\n{\\displaystyle {\\displaystyle n\\_{2}}}\n,   \n\n…\n{\\displaystyle {\\displaystyle \\ldots }}\n,   \n\nn\n\nk\n{\\displaystyle {\\displaystyle n\\_{k}}}\n   are positive integers that are pairwise co-prime.\n\nThen, for any given sequence of integers   \n\na\n\n1\n{\\displaystyle {\\displaystyle a\\_{1}}}\n,   \n\na\n\n2\n{\\displaystyle {\\displaystyle a\\_{2}}}\n,   \n\n…\n{\\displaystyle {\\displaystyle \\dots }}\n,   \n\na\n\nk\n{\\displaystyle {\\displaystyle a\\_{k}}}\n,   there exists an integer   \n\nx\n{\\displaystyle {\\displaystyle x}}\n   solving the following system of simultaneous congruences:\n\n:   :   :   x\n\n\n            ≡\n\n            a\n\n            1\n\n\n            (\n            mod\n\n\n            n\n\n            1\n            )\n\n\n            x\n\n\n            ≡\n\n            a\n\n            2\n\n\n            (\n            mod\n\n\n            n\n\n            2\n            )\n\n             \n             \n            ⋮\n\n\n            x\n\n\n            ≡\n\n            a\n\n            k\n\n\n            (\n            mod\n\n\n            n\n\n            k\n            )\n            {\\displaystyle {\\displaystyle {\\begin{aligned}x&\\equiv a\\_{1}{\\pmod {n\\_{1}}}\\\\x&\\equiv a\\_{2}{\\pmod {n\\_{2}}}\\\\&{}\\ \\ \\vdots \\\\x&\\equiv a\\_{k}{\\pmod {n\\_{k}}}\\end{aligned}}}}\n\nFurthermore, all solutions   \n\nx\n{\\displaystyle {\\displaystyle x}}\n   of this system are congruent modulo the product,   \n\nN\n=\n\nn\n\n1\n\nn\n\n2\n…\n\nn\n\nk\n{\\displaystyle {\\displaystyle N=n\\_{1}n\\_{2}\\ldots n\\_{k}}}\n.\n\nTask\n\nWrite a program to solve a system of linear congruences by applying the   Chinese Remainder Theorem.\n\nIf the system of equations cannot be solved, your program must somehow indicate this.\n\n(It may throw an exception or return a special false value.)\n\nSince there are infinitely many solutions, the program should return the unique solution   \n\ns\n{\\displaystyle {\\displaystyle s}}\n   where   \n\n0\n≤\ns\n≤\n\nn\n\n1\n\nn\n\n2\n…\n\nn\n\nk\n{\\displaystyle {\\displaystyle 0\\leq s\\leq n\\_{1}n\\_{2}\\ldots n\\_{k}}}\n.\n\n*Show the functionality of this program* by printing the result such that the   \n\nn\n{\\displaystyle {\\displaystyle n}}\n's   are   \n\n[\n3\n,\n5\n,\n7\n]\n{\\displaystyle {\\displaystyle [3,5,7]}}\n   and the   \n\na\n{\\displaystyle {\\displaystyle a}}\n's   are   \n\n[\n2\n,\n3\n,\n2\n]\n{\\displaystyle {\\displaystyle [2,3,2]}}\n.\n\n**Algorithm**:   The following algorithm only applies if the   \n\nn\n\ni\n{\\displaystyle {\\displaystyle n\\_{i}}}\n's   are pairwise co-prime.\n\nSuppose, as above, that a solution is required for the system of congruences:\n\n:   :   :   x\n            ≡\n\n            a\n\n            i\n\n\n            (\n            mod\n\n\n            n\n\n            i\n            )\n\n\n            f\n            o\n            r\n\n            i\n            =\n            1\n            ,\n            …\n            ,\n            k\n            {\\displaystyle {\\displaystyle x\\equiv a\\_{i}{\\pmod {n\\_{i}}}\\quad \\mathrm {for} \\;i=1,\\ldots ,k}}\n\nAgain, to begin, the product   \n\nN\n=\n\nn\n\n1\n\nn\n\n2\n…\n\nn\n\nk\n{\\displaystyle {\\displaystyle N=n\\_{1}n\\_{2}\\ldots n\\_{k}}}\n   is defined.\n\nThen a solution   \n\nx\n{\\displaystyle {\\displaystyle x}}\n   can be found as follows:\n\nFor each   \n\ni\n{\\displaystyle {\\displaystyle i}}\n,   the integers   \n\nn\n\ni\n{\\displaystyle {\\displaystyle n\\_{i}}}\n   and   \n\nN\n\n/\n\nn\n\ni\n{\\displaystyle {\\displaystyle N/n\\_{i}}}\n   are co-prime.\n\nUsing the   Extended Euclidean algorithm,   we can find integers   \n\nr\n\ni\n{\\displaystyle {\\displaystyle r\\_{i}}}\n   and   \n\ns\n\ni\n{\\displaystyle {\\displaystyle s\\_{i}}}\n   such that   \n\nr\n\ni\n\nn\n\ni\n+\n\ns\n\ni\nN\n\n/\n\nn\n\ni\n=\n1\n{\\displaystyle {\\displaystyle r\\_{i}n\\_{i}+s\\_{i}N/n\\_{i}=1}}\n.\n\nThen, one solution to the system of simultaneous congruences is:\n\n:   :   :   x\n            =\n\n            ∑\n\n            i\n            =\n            1\n\n            k\n\n            a\n\n            i\n\n            s\n\n            i\n            N\n\n            /\n\n            n\n\n            i\n            {\\displaystyle {\\displaystyle x=\\sum \\_{i=1}^{k}a\\_{i}s\\_{i}N/n\\_{i}}}\n\nand the minimal solution,\n\n:   :   :   x\n\n\n            (\n            mod\n\n            N\n            )\n            {\\displaystyle {\\displaystyle x{\\pmod {N}}}}\n            ."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: C\n\n**Works with**: Rakudo version 2015.12\n\n```\n# returns x where (a * x) % b == 1\nsub mul-inv($a is copy, $b is copy) {\n    return 1 if $b == 1;\n    my ($b0, @x) = $b, 0, 1;\n    ($a, $b, @x) = (\n\t$b,\n\t$a % $b,\n\t@x[1] - ($a div $b)*@x[0],\n\t@x[0]\n    ) while $a > 1;\n    @x[1] += $b0 if @x[1] < 0;\n    return @x[1];\n}\n\nsub chinese-remainder(*@n) {\n    my \\N = [*] @n;\n    -> *@a {\n\tN R% [+] map {\n\t    my \\p = N div @n[$_];\n\t    @a[$_] * mul-inv(p, @n[$_]) * p\n\t}, ^@n\n    }\n}\n\nsay chinese-remainder(3, 5, 7)(2, 3, 2);\n\n```\n\nOutput:\n\n```\n23\n```"}]}
{"messages": [{"role": "user", "content": "Determine the Chinese zodiac sign and related associations for a given year.\n\nIn the Chinese calendar, years are identified using two lists of labels, one of length 10 – the \"celestial\" (or \"heavenly\") \"stems\" – and one of length 12 – the \"terrestrial\" (or \"earthly\") \"branches\". The labels do not really have any meaning outside their positions in the two lists; they're simply a traditional enumeration device, used much as Westerners use letters and numbers. They were historically used for months and days as well as years, and the stems are still sometimes used for school grades.\n\nYears cycle through both lists concurrently, so that both stem and branch advance each year; if we used Roman letters for the stems and numbers for the branches, consecutive years would be labeled A1, B2, C3, etc. Since the two lists are different lengths, they cycle back to their beginning at different points: after J10 we get A11, and then after B12 we get C1. However, since both lists are of even length, only like-parity pairs occur (A1, A3, A5, but not A2, A4, A6), so only half of the 120 possible pairs are included in the sequence. The result is a repeating 60-year pattern within which each name pair occurs only once.\n\nMapping the branches to twelve traditional animal deities results in the well-known \"Chinese zodiac\", assigning each year to a given animal. For example, Wednesday, January 29, 2025 CE (in the common Gregorian calendar) begins the lunisolar Year of the Snake.\n\nThe stems do not have a one-to-one mapping like that of the branches to animals; however, the five *pairs* of consecutive stems are each associated with one of the traditional *wǔxíng* elements (Wood, Fire, Earth, Metal, and Water). Further, one of the two years within each element is assigned to *yin*, the other to *yang*.\n\nThus, the Chinese year beginning in 2025 CE is also the yin year of Wood. Since 12 is an even number, the association between animals and yin/yang aspect doesn't change; consecutive Years of the Snake will cycle through the five elements, but will always be yin.\n\nTask\n:   Create a subroutine or program that will return or output the animal, yin/yang association, and element for the lunisolar year that begins in a given CE year.\n\nYou may optionally provide more information in the form of the year's numerical position within the 60-year cycle and/or its actual Chinese stem-branch name (in Han characters or Pinyin transliteration).\n\nRequisite information\n\n* The animal cycle runs in this order: Rat, Ox, Tiger, Rabbit, Dragon, Snake, Horse, Goat, Monkey, Rooster, Dog, Pig.\n* The element cycle runs in this order: Wood, Fire, Earth, Metal, Water.\n* Each element gets two consecutive years; a yang followed by a yin.\n* The first year (Wood Rat, yang) of the current 60-year cycle began in 1984 CE.\n\nThe lunisolar year beginning in 2025 CE - which, as already noted, is the year of the Wood Snake (yin) - is the 42nd of the current cycle.\n\nInformation for optional task\n\n* The ten celestial stems are **甲** *jiă*, **乙** *yĭ*, **丙** *bĭng*, **丁** *dīng*, **戊** *wù*, **己** *jĭ*, **庚** *gēng*, **辛** *xīn*, **壬** *rén*, and **癸** *gŭi*. With the ASCII version of Pinyin tones, the names are written \"jia3\", \"yi3\", \"bing3\", \"ding1\", \"wu4\", \"ji3\", \"geng1\", \"xin1\", \"ren2\", and \"gui3\".\n* The twelve terrestrial branches are **子** *zĭ*, **丑** *chŏu*, **寅** *yín*, **卯** *măo*, **辰** *chén*, **巳** *sì*, **午** *wŭ*, **未** *wèi*, **申** *shēn*, **酉** *yŏu*, **戌** *xū*, **亥** *hài*. In ASCII Pinyin, those are \"zi3\", \"chou3\", \"yin2\", \"mao3\", \"chen2\", \"si4\", \"wu3\", \"wei4\", \"shen1\", \"you3\", \"xu1\", and \"hai4\".\n\nTherefore 1984 was **甲子** (*jiă-zĭ*, or jia3-zi3), while 2025 is **乙巳** (*yĭ-sì* or yi3-si4)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.01\n\n**Translation of**: Ruby\n\n```\nsub Chinese-zodiac ( Int $year ) {\n    my @heaven  = <甲 jiă 乙 yĭ 丙 bĭng 丁 dīng 戊 wù 己 jĭ 庚 gēng 辛 xīn 壬 rén 癸 gŭi>.pairup;\n    my @earth   = <子 zĭ 丑 chŏu 寅 yín 卯 măo 辰 chén 巳 sì 午 wŭ 未 wèi 申 shēn 酉 yŏu 戌 xū 亥 hài>.pairup;\n    my @animal  = <Rat Ox Tiger Rabbit Dragon Snake Horse Goat Monkey Rooster Dog Pig>;\n    my @element = <Wood Fire Earth Metal Water>;\n    my @aspect  = <yang yin>;\n\n    my $cycle_year = ($year - 4) % 60;\n    my $i2         = $cycle_year % 2;\n    my $i10        = $cycle_year % 10;\n    my $i12        = $cycle_year % 12;\n\n    %(\n        'Han'     => @heaven[$i10].key ~ @earth[$i12].key,\n        'pinyin'  => @heaven[$i10].value ~ @earth[$i12].value,\n        'heaven'  => @heaven[$i10],\n        'earth'   => @earth[$i12],\n        'element' => @element[$i10 div 2],\n        'animal'  => @animal[$i12],\n        'aspect'  => @aspect[$i2],\n        'cycle'   => $cycle_year + 1\n    )\n}\n\n# TESTING\nprintf \"%d: %s (%s, %s %s; %s - year %d in the cycle)\\n\",\n    $_, .&Chinese-zodiac<Han pinyin element animal aspect cycle>\n    for 1935, 1938, 1968, 1972, 1976, 1984, Date.today.year;\n\n```\n\nOutput:\n\n```\n1935: 乙亥 (yĭhài, Wood Pig; yin - year 12 in the cycle)\n1938: 戊寅 (wùyín, Earth Tiger; yang - year 15 in the cycle)\n1968: 戊申 (wùshēn, Earth Monkey; yang - year 45 in the cycle)\n1972: 壬子 (rénzĭ, Water Rat; yang - year 49 in the cycle)\n1976: 丙辰 (bĭngchén, Fire Dragon; yang - year 53 in the cycle)\n1984: 甲子 (jiăzĭ, Wood Rat; yang - year 1 in the cycle)\n2017: 丁酉 (dīngyŏu, Fire Rooster; yin - year 34 in the cycle)\n```"}]}
{"messages": [{"role": "user", "content": "Every symmetric, positive definite matrix A can be decomposed into a product of a unique lower triangular matrix L and its transpose:\n\n:   A\n    =\n    L\n\n    L\n\n    T\n    {\\displaystyle {\\displaystyle A=LL^{T}}}\n\nL\n{\\displaystyle {\\displaystyle L}}\n is called the *Cholesky factor* of \n\nA\n{\\displaystyle {\\displaystyle A}}\n, and can be interpreted as a generalized square root of \n\nA\n{\\displaystyle {\\displaystyle A}}\n, as described in Cholesky decomposition.\n\nIn a 3x3 example, we have to solve the following system of equations:\n\n:   A\n\n\n    =\n\n\n    (\n\n    a\n\n    11\n\n\n    a\n\n    21\n\n\n    a\n\n    31\n\n    a\n\n    21\n\n\n    a\n\n    22\n\n\n    a\n\n    32\n\n    a\n\n    31\n\n\n    a\n\n    32\n\n\n    a\n\n    33\n    )\n\n    =\n\n\n    (\n\n    l\n\n    11\n\n    0\n\n    0\n\n    l\n\n    21\n\n\n    l\n\n    22\n\n    0\n\n    l\n\n    31\n\n\n    l\n\n    32\n\n\n    l\n\n    33\n    )\n\n\n    (\n\n    l\n\n    11\n\n\n    l\n\n    21\n\n\n    l\n\n    31\n\n\n    0\n\n\n    l\n\n    22\n\n\n    l\n\n    32\n\n\n    0\n\n    0\n\n\n    l\n\n    33\n    )\n    ≡\n    L\n\n    L\n\n    T\n\n    =\n\n\n    (\n\n    l\n\n    11\n\n    2\n\n\n    l\n\n    21\n\n    l\n\n    11\n\n\n    l\n\n    31\n\n    l\n\n    11\n\n    l\n\n    21\n\n    l\n\n    11\n\n\n    l\n\n    21\n\n    2\n    +\n\n    l\n\n    22\n\n    2\n\n\n    l\n\n    31\n\n    l\n\n    21\n    +\n\n    l\n\n    32\n\n    l\n\n    22\n\n    l\n\n    31\n\n    l\n\n    11\n\n\n    l\n\n    31\n\n    l\n\n    21\n    +\n\n    l\n\n    32\n\n    l\n\n    22\n\n\n    l\n\n    31\n\n    2\n    +\n\n    l\n\n    32\n\n    2\n    +\n\n    l\n\n    33\n\n    2\n    )\n    {\\displaystyle {\\displaystyle {\\begin{aligned}A&={\\begin{pmatrix}a\\_{11}&a\\_{21}&a\\_{31}\\\\a\\_{21}&a\\_{22}&a\\_{32}\\\\a\\_{31}&a\\_{32}&a\\_{33}\\\\\\end{pmatrix}}\\\\&={\\begin{pmatrix}l\\_{11}&0&0\\\\l\\_{21}&l\\_{22}&0\\\\l\\_{31}&l\\_{32}&l\\_{33}\\\\\\end{pmatrix}}{\\begin{pmatrix}l\\_{11}&l\\_{21}&l\\_{31}\\\\0&l\\_{22}&l\\_{32}\\\\0&0&l\\_{33}\\end{pmatrix}}\\equiv LL^{T}\\\\&={\\begin{pmatrix}l\\_{11}^{2}&l\\_{21}l\\_{11}&l\\_{31}l\\_{11}\\\\l\\_{21}l\\_{11}&l\\_{21}^{2}+l\\_{22}^{2}&l\\_{31}l\\_{21}+l\\_{32}l\\_{22}\\\\l\\_{31}l\\_{11}&l\\_{31}l\\_{21}+l\\_{32}l\\_{22}&l\\_{31}^{2}+l\\_{32}^{2}+l\\_{33}^{2}\\end{pmatrix}}\\end{aligned}}}}\n\nWe can see that for the diagonal elements (\n\nl\n\nk\nk\n{\\displaystyle {\\displaystyle l\\_{kk}}}\n) of \n\nL\n{\\displaystyle {\\displaystyle L}}\n there is a calculation pattern:\n\n:   l\n\n    11\n    =\n\n    a\n\n    11\n    {\\displaystyle {\\displaystyle l\\_{11}={\\sqrt {a\\_{11}}}}}\n:   l\n\n    22\n    =\n\n    a\n\n    22\n    −\n\n    l\n\n    21\n\n    2\n    {\\displaystyle {\\displaystyle l\\_{22}={\\sqrt {a\\_{22}-l\\_{21}^{2}}}}}\n:   l\n\n    33\n    =\n\n    a\n\n    33\n    −\n    (\n\n    l\n\n    31\n\n    2\n    +\n\n    l\n\n    32\n\n    2\n    )\n    {\\displaystyle {\\displaystyle l\\_{33}={\\sqrt {a\\_{33}-(l\\_{31}^{2}+l\\_{32}^{2})}}}}\n\nor in general:\n\n:   l\n\n    k\n    k\n    =\n\n    a\n\n    k\n    k\n    −\n\n    ∑\n\n    j\n    =\n    1\n\n    k\n    −\n    1\n\n    l\n\n    k\n    j\n\n    2\n    {\\displaystyle {\\displaystyle l\\_{kk}={\\sqrt {a\\_{kk}-\\sum \\_{j=1}^{k-1}l\\_{kj}^{2}}}}}\n\nFor the elements below the diagonal (\n\nl\n\ni\nk\n{\\displaystyle {\\displaystyle l\\_{ik}}}\n, where \n\ni\n>\nk\n{\\displaystyle {\\displaystyle i>k}}\n) there is also a calculation pattern:\n\n:   l\n\n    21\n    =\n\n\n    1\n\n    l\n\n    11\n\n    a\n\n    21\n    {\\displaystyle {\\displaystyle l\\_{21}={\\frac {1}{l\\_{11}}}a\\_{21}}}\n:   l\n\n    31\n    =\n\n\n    1\n\n    l\n\n    11\n\n    a\n\n    31\n    {\\displaystyle {\\displaystyle l\\_{31}={\\frac {1}{l\\_{11}}}a\\_{31}}}\n:   l\n\n    32\n    =\n\n\n    1\n\n    l\n\n    22\n    (\n\n    a\n\n    32\n    −\n\n    l\n\n    31\n\n    l\n\n    21\n    )\n    {\\displaystyle {\\displaystyle l\\_{32}={\\frac {1}{l\\_{22}}}(a\\_{32}-l\\_{31}l\\_{21})}}\n\nwhich can also be expressed in a general formula:\n\n:   l\n\n    i\n    k\n    =\n\n\n    1\n\n    l\n\n    k\n    k\n\n    (\n\n\n    a\n\n    i\n    k\n    −\n\n    ∑\n\n    j\n    =\n    1\n\n    k\n    −\n    1\n\n    l\n\n    i\n    j\n\n    l\n\n    k\n    j\n    )\n    {\\displaystyle {\\displaystyle l\\_{ik}={\\frac {1}{l\\_{kk}}}\\left(a\\_{ik}-\\sum \\_{j=1}^{k-1}l\\_{ij}l\\_{kj}\\right)}}\n\n**Task description**\n\nThe task is to implement a routine which will return a lower Cholesky factor \n\nL\n{\\displaystyle {\\displaystyle L}}\n for every given symmetric, positive definite nxn matrix \n\nA\n{\\displaystyle {\\displaystyle A}}\n. You should then test it on the following two examples and include your output.\n\nExample 1:\n\n```\n25  15  -5                 5   0   0\n15  18   0         -->     3   3   0\n-5   0  11                -1   1   3\n\n```\n\nExample 2:\n\n```\n18  22   54   42           4.24264    0.00000    0.00000    0.00000\n22  70   86   62   -->     5.18545    6.56591    0.00000    0.00000\n54  86  174  134          12.72792    3.04604    1.64974    0.00000\n42  62  134  106           9.89949    1.62455    1.84971    1.39262\n\n```\n\nNote\n\n1. The Cholesky decomposition of a Pascal upper-triangle matrix is the Identity matrix of the same size.\n2. The Cholesky decomposition of a Pascal symmetric matrix is the Pascal lower-triangle matrix of the same size."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub cholesky(@A) {\n    my @L = @A »×» 0;\n    for ^@A -> \\i {\n        for 0..i -> \\j {\n            @L[i;j] = (i == j ?? &sqrt !! 1/@L[j;j] × * )\\      # select function\n                      (@A[i;j] - [+] (@L[i;*] Z× @L[j;*])[^j])  # provide value\n        }\n    }\n    @L\n}\n\n.fmt('%3d').say for cholesky [\n    [25],\n    [15, 18],\n    [-5,  0, 11],\n];\n\nsay '';\n\n.fmt('%6.3f').say for cholesky [\n    [18, 22,  54,  42],       \n    [22, 70,  86,  62],\n    [54, 86, 174, 134],       \n    [42, 62, 134, 106],\n];\n\n```\n\nOutput:\n\n```\n  5\n  3   3\n -1   1   3\n\n 4.243  0.000  0.000  0.000\n 5.185  6.566  0.000  0.000\n12.728  3.046  1.650  0.000\n 9.899  1.625  1.850  1.393\n```"}]}
{"messages": [{"role": "user", "content": "Chowla numbers are also known as:\n\n:   :   * Chowla's function\n        * chowla numbers\n        * the chowla function\n        * the chowla number\n        * the chowla sequence\n\nThe chowla number of   **n**   is   (as defined by Chowla's function):\n\n:   :   * the sum of the divisors of   **n**     excluding unity and   **n**\n        * where   **n**   is a positive integer\n\nThe sequence is named after   Sarvadaman D. S. Chowla,   (22 October 1907 ──► 10 December 1995),\n  \na London born Indian American mathematician specializing in *number theory*.\n\nGerman mathematician Carl Friedrich Gauss (1777─1855) said:\n\n```\n   \"Mathematics is the queen of the sciences ─ and number theory is the queen of mathematics\".\n\n```\n\nDefinitions\n\nChowla numbers can also be expressed as:\n\n```\n   \n   chowla(n) = sum of divisors of  n  excluding unity and  n\n   chowla(n) = sum(       divisors(n))   - 1  -  n \n   chowla(n) = sum( properDivisors(n))   - 1       \n   chowla(n) = sum(aliquotDivisors(n))   - 1        \n   chowla(n) = aliquot(n)                - 1       \n   chowla(n) = sigma(n)                  - 1  -  n \n   chowla(n) = sigmaProperDivisiors(n)   - 1       \n \n   chowla(a*b) =  a + b,    if  a  and  b  are distinct primes\n   if  chowla(n) =  0,       and n > 1,  then   n   is prime\n   if  chowla(n) =  n - 1,  and n > 1,  then   n   is a perfect number\n    \n\n```\n\nTask\n:   :   * create a   **chowla**   function that returns the   **chowla number**   for a positive integer   **n**\n        * Find and display   (1 per line)   for the 1st   **37**   integers:\n\n        :   :   * the integer   (the index)\n                * the chowla number for that integer\n\n        * For finding primes, use the   **chowla**   function to find values of zero\n        * Find and display the   *count*   of the primes up to              **100**\n        * Find and display the   *count*   of the primes up to           **1,000**\n        * Find and display the   *count*   of the primes up to         **10,000**\n        * Find and display the   *count*   of the primes up to       **100,000**\n        * Find and display the   *count*   of the primes up to    **1,000,000**\n        * Find and display the   *count*   of the primes up to  **10,000,000**\n        * For finding perfect numbers, use the   **chowla**   function to find values of   **n - 1**\n        * Find and display all   perfect numbers   up to   **35,000,000**\n        * use commas within appropriate numbers\n        * show all output here\n\nRelated tasks\n:   * totient function\n    * perfect numbers\n    * Proper divisors\n    * Sieve of Eratosthenes\n\nSee also\n:   * the OEIS entry for   A48050 Chowla's function."}, {"role": "assistant", "content": "(formerly Perl 6)\nMuch like in the Totient function task, we are using a thing poorly suited to finding prime numbers, to find large quantities of prime numbers.\n\n:   :   :   (From the task's author):   the object is not in the   *finding*   of prime numbers,   but in   *verifying*   that the Chowla function operates correctly   (and **can be** used for such a purpose, whatever the efficacy).   These types of comments belong in the *discussion* page.   Whether or not this function is poorly suited for finding prime numbers (or anything else) is not part of this task's purpose or objective.\n\n(For a more reasonable test, reduce the orders-of-magnitude range in the \"Primes count\" line from 2..7 to 2..5)\n\n```\nsub comma { $^i.flip.comb(3).join(',').flip }\n\nsub schnitzel (\\Radda, \\radDA = 0) {\n    Radda.is-prime ?? !Radda !! ?radDA ?? Radda\n    !! sum flat (2 .. Radda.sqrt.floor).map: -> \\RAdda {\n        my \\RADDA = Radda div RAdda;\n        next if RADDA * RAdda !== Radda;\n        RAdda !== RADDA ?? (RAdda, RADDA) !! RADDA\n    }\n}\n\nmy \\chowder = cache (1..Inf).hyper(:8degree).grep( !*.&schnitzel: 'panini' );\n\nmy \\mung-daal = lazy gather for chowder -> \\panini {\n    my \\gazpacho = 2**panini - 1;\n    take gazpacho * 2**(panini - 1) unless schnitzel gazpacho, panini;\n}\n\nprintf \"chowla(%2d) = %2d\\n\", $_, .&schnitzel for 1..37;\n\nsay '';\n\nprintf \"Count of primes up to %10s: %s\\n\", comma(10**$_),\n  comma chowder.first( * > 10**$_, :k) for 2..7;\n\nsay \"\\nPerfect numbers less than 35,000,000\";\n\n.&comma.say for mung-daal[^5];\n\n```\n\nOutput:\n\n```\nchowla( 1) =  0\nchowla( 2) =  0\nchowla( 3) =  0\nchowla( 4) =  2\nchowla( 5) =  0\nchowla( 6) =  5\nchowla( 7) =  0\nchowla( 8) =  6\nchowla( 9) =  3\nchowla(10) =  7\nchowla(11) =  0\nchowla(12) = 15\nchowla(13) =  0\nchowla(14) =  9\nchowla(15) =  8\nchowla(16) = 14\nchowla(17) =  0\nchowla(18) = 20\nchowla(19) =  0\nchowla(20) = 21\nchowla(21) = 10\nchowla(22) = 13\nchowla(23) =  0\nchowla(24) = 35\nchowla(25) =  5\nchowla(26) = 15\nchowla(27) = 12\nchowla(28) = 27\nchowla(29) =  0\nchowla(30) = 41\nchowla(31) =  0\nchowla(32) = 30\nchowla(33) = 14\nchowla(34) = 19\nchowla(35) = 12\nchowla(36) = 54\nchowla(37) =  0\n\nCount of primes up to        100: 25\nCount of primes up to      1,000: 168\nCount of primes up to     10,000: 1,229\nCount of primes up to    100,000: 9,592\nCount of primes up to  1,000,000: 78,498\nCount of primes up to 10,000,000: 664,579\n\nPerfect numbers less than 35,000,000\n6\n28\n496\n8,128\n33,550,336\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nIn the Church encoding of natural numbers, the number N is encoded by a function that applies its first argument N times to its second argument.\n\n* **Church zero** always returns the identity function, regardless of its first argument. In other words, the first argument is not applied to the second argument at all.\n* **Church one** applies its first argument f just once to its second argument x, yielding **f(x)**\n* **Church two** applies its first argument f twice to its second argument x, yielding **f(f(x))**\n* and each successive Church numeral applies its first argument one additional time to its second argument, **f(f(f(x)))**, **f(f(f(f(x))))** ... The Church numeral 4, for example, returns a quadruple composition of the function supplied as its first argument.\n\nArithmetic operations on natural numbers can be similarly represented as functions on Church numerals.\n\nIn your language define:\n\n* Church Zero,\n* a Church successor function (a function on a Church numeral which returns the next Church numeral in the series),\n* functions for Addition, Multiplication and Exponentiation over Church numerals,\n* a function to convert integers to corresponding Church numerals,\n* and a function to convert Church numerals to corresponding integers.\n\nYou should:\n\n* Derive Church numerals three and four in terms of Church zero and a Church successor function.\n* use Church numeral arithmetic to obtain the the sum and the product of Church 3 and Church 4,\n* similarly obtain 4^3 and 3^4 in terms of Church numerals, using a Church numeral exponentiation function,\n* convert each result back to an integer, and return it or print it to the console."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Traditional subs and sigils\n\n**Translation of**: Python\n\n```\nconstant $zero  = sub (Code $f) {\n                  sub (     $x) { $x }}\n\nconstant $succ  = sub (Code $n) {\n                  sub (Code $f) {\n                  sub (     $x) { $f($n($f)($x)) }}}\n\nconstant $add   = sub (Code $n) {\n                  sub (Code $m) {\n                  sub (Code $f) {\n                  sub (     $x) { $m($f)($n($f)($x)) }}}}\n\nconstant $mult  = sub (Code $n) {\n                  sub (Code $m) {\n                  sub (Code $f) {\n                  sub (     $x) { $m($n($f))($x) }}}}\n\nconstant $power = sub (Code $b) {\n                  sub (Code $e) { $e($b) }}\n\nsub to_int (Code $f) {\n    sub countup (Int $i) { $i + 1 }\n    return $f(&countup).(0)\n}\n\nsub from_int (Int $x) {\n    multi sub countdown (     0) { $zero }\n    multi sub countdown (Int $i) { $succ( countdown($i - 1) ) }\n    return countdown($x);\n}\n\nconstant $three = $succ($succ($succ($zero)));\nconstant $four  = from_int(4);\n\nsay map &to_int,\n    $add(   $three )( $four  ),\n    $mult(  $three )( $four  ),\n    $power( $four  )( $three ),\n    $power( $three )( $four  ),\n;\n\n```\n\n### Arrow subs without sigils\n\n**Translation of**: Julia\n\n```\nmy \\zero  = -> \\f {                 -> \\x { x               }}\nmy \\succ  = -> \\n {         -> \\f { -> \\x { f.(n.(f)(x))    }}}\nmy \\add   = -> \\n { -> \\m { -> \\f { -> \\x { m.(f)(n.(f)(x)) }}}}\nmy \\mult  = -> \\n { -> \\m { -> \\f { -> \\x { m.(n.(f))(x)    }}}}\nmy \\power = -> \\b {                 -> \\e { e.(b)           }}\n\nmy \\to_int   = -> \\f { f.( -> \\i { i + 1 } ).(0) }\nmy \\from_int = -> \\i { i == 0 ?? zero !! succ.( &?BLOCK(i - 1) ) }\n\nmy \\three = succ.(succ.(succ.(zero)));\nmy \\four  = from_int.(4);\n\nsay map -> \\f { to_int.(f) },\n    add.(   three )( four  ),\n    mult.(  three )( four  ),\n    power.( four  )( three ),\n    power.( three )( four  ),\n;\n\n```\n\nOutput:\n\n```\n(7 12 64 81)\n```"}]}
{"messages": [{"role": "user", "content": "**Cipolla's algorithm**\n\nSolve **x² ≡ n (mod p)**\n\nIn computational number theory, Cipolla's algorithm is a technique for solving an equation of the form **x² ≡ n (mod p)**, where p is an odd prime and x ,n ∊ Fp = {0, 1, ... p-1}.\n\nTo apply the algorithm we need the Legendre symbol, and arithmetic in Fp².\n\nLegendre symbol\n\n* The Legendre symbol ( a | p) denotes the value of a ^ ((p-1)/2) (mod p)\n* (a | p) ≡ 1 if a is a square (mod p)\n* (a | p) ≡ -1 if a is not a square (mod p)\n* (a | p) ≡ 0 is a ≡ 0\n\nArithmetic in Fp²\n\nLet ω a symbol such as ω² is a member of Fp and not a square, x and y members of Fp. The set Fp² is defined as {x + ω y }. The subset { x + 0 ω} of Fp² is Fp. Fp² is somewhat equivalent to the field of complex number, with ω analoguous to i, and i² = -1 . Remembering that all operations are modulo p, addition, multiplication and exponentiation in Fp² are defined as :\n\n* (x1 + ω y1) + (x2 + ω y2) := (x1 + x2 + ω (y1 + y2))\n* (x1 + ω y1) \\* (x2 + ω y2) := (x1\\*x2 + y1\\*y2\\*ω²) + ω (x1\\*y2 + x2\\*y1)\n  + (0 + ω) \\* (0 + ω) := (ω² + 0 ω) ≡ ω² in Fp\n* (x1 + ω y1) ^ n := (x + ω y) \\* (x + ω y) \\* ... ( n times) (1)\n\n**Algorithm pseudo-code**\n\n* Input : p an odd prime, and n ≠ 0 in Fp\n* Step 0. Check that n is indeed a square  : (n | p) must be ≡ 1\n* Step 1. Find, by trial and error, an a > 0 such as (a² - n) is **not** a square : (a²-n | p) must be ≡ -1.\n* Step 2. Let ω² = a² - n. Compute, in Fp2 : (a + ω) ^ ((p + 1)/2) (mod p)\n\nTo compute this step, use a pair of numbers, initially [a,1], and use repeated \"multiplication\" which is defined such that [c,d] times [e,f] is (mod p) [ c\\*c + ω²\\*f\\*f, d\\*e + c\\*f ].\n\n* Step 3. Check that the result is ≡ x + 0 \\* ω in Fp2, that is x in Fp.\n* Step 4. Output the two positive solutions, x and p - x (mod p).\n* Step 5. Check that x \\* x ≡ n (mod p)\n\n**Example** from Wikipedia\n\n```\nn := 10 , p := 13\nLegendre(10,13) → 1         // 10 is indeed a square\na := 2                      // try\nω² := a*a - 10             // ≡ 7 ≡ -6\nLegendre (ω² , 13) → -1    // ok - not square\n(2 + ω) ^ 7 → 6 + 0 ω      // by modular exponentiation (1)\n                            // 6 and (13 - 6) = 7 are solutions\n(6 * 6) % 13 → 10           // = n . Checked.\n\n```\n\n**Task**\n\nImplement the above.\n\nFind solutions (if any) for\n\n* n = 10 p = 13\n* n = 56 p = 101\n* n = 8218 p = 10007\n* n = 8219 p = 10007\n* n = 331575 p = 1000003\n\n**Extra credit**\n\n* n 665165880 p 1000000007\n* n 881398088036 p 1000000000039\n* n = 34035243914635549601583369544560650254325084643201 p = 10^50 + 151\n\nSee also:\n\n* Modular exponentiation\n* Tonelli-Shanks algorithm"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.10\n\n**Translation of**: Sidef\n\n```\n#  Legendre operator (𝑛│𝑝)\nsub infix:<│> (Int \\𝑛, Int \\𝑝 where 𝑝.is-prime && (𝑝 != 2)) {\n    given 𝑛.expmod( (𝑝-1) div 2, 𝑝 ) {\n        when 0  {  0 }\n        when 1  {  1 }\n        default { -1 }\n    }\n}\n\n# a coordinate in a Field of p elements\nclass Fp {\n    has Int $.x;\n    has Int $.y;\n}\n\nsub cipolla ( Int \\𝑛, Int \\𝑝 ) {\n    note \"Invalid parameters ({𝑛}, {𝑝})\"\n      and return Nil if (𝑛│𝑝) != 1;\n    my $ω2;\n    my $a = 0;\n    loop {\n        last if ($ω2 = ($a² - 𝑛) % 𝑝)│𝑝 < 0;\n        $a++;\n    }\n\n    # define a local multiply operator for Field coordinates\n    multi sub infix:<*> ( Fp $a, Fp $b ){\n        Fp.new: :x(($a.x * $b.x + $a.y * $b.y * $ω2) % 𝑝),\n                :y(($a.x * $b.y + $b.x * $a.y)       % 𝑝)\n    }\n\n    my $r = Fp.new: :x(1),  :y(0);\n    my $s = Fp.new: :x($a), :y(1);\n\n    for (𝑝+1) +> 1, * +> 1 ... 1 {\n        $r *= $s if $_ % 2;\n        $s *= $s;\n    }\n    return Nil if $r.y;\n    $r.x;\n}\n\nmy @tests = (\n    (10, 13),\n    (56, 101),\n    (8218, 10007),\n    (8219, 10007),\n    (331575, 1000003),\n    (665165880, 1000000007),\n    (881398088036, 1000000000039),\n    (34035243914635549601583369544560650254325084643201,\n      100000000000000000000000000000000000000000000000151)\n);\n\nfor @tests -> ($n, $p) {\n   my $r = cipolla($n, $p);\n   say $r ?? \"Roots of $n are ($r, {$p-$r}) mod $p\"\n          !! \"No solution for ($n, $p)\"\n}\n\n```\n\nOutput:\n\n```\nRoots of 10 are (6, 7) mod 13\nRoots of 56 are (37, 64) mod 101\nRoots of 8218 are (9872, 135) mod 10007\nInvalid parameters (8219, 10007)\nNo solution for (8219, 10007)\nRoots of 331575 are (855842, 144161) mod 1000003\nRoots of 665165880 are (475131702, 524868305) mod 1000000007\nRoots of 881398088036 are (791399408049, 208600591990) mod 1000000000039\nRoots of 34035243914635549601583369544560650254325084643201 are (82563118828090362261378993957450213573687113690751, 17436881171909637738621006042549786426312886309400) mod 100000000000000000000000000000000000000000000000151\n\n```"}]}
{"messages": [{"role": "user", "content": "2 circles with a given radius through 2 points in 2D space.\n\n2 circles with a given radius through 2 points in 2D space.\n\nGiven two points on a plane and a radius, usually two circles of given radius can be drawn through the points.\n\nExceptions\n\n1. r==0.0 should be treated as never describing circles (except in the case where the points are coincident).\n2. If the points are coincident then an infinite number of circles with the point on their circumference can be drawn, unless r==0.0 as well which then collapses the circles to a point.\n3. If the points form a diameter then return two identical circles *or* return a single circle, according to which is the most natural mechanism for the implementation language.\n4. If the points are too far apart then no circles can be drawn.\n\nTask detail\n\n* Write a function/subroutine/method/... that takes two points and a radius and returns the two circles through those points, *or some indication of special cases where two, possibly equal, circles cannot be returned*.\n* Show here the output for the following inputs:\n\n```\n      p1                p2           r\n0.1234, 0.9876    0.8765, 0.2345    2.0\n0.0000, 2.0000    0.0000, 0.0000    1.0\n0.1234, 0.9876    0.1234, 0.9876    2.0\n0.1234, 0.9876    0.8765, 0.2345    0.5\n0.1234, 0.9876    0.1234, 0.9876    0.0\n\n```\n\nRelated task\n\n* Total circles area.\n\nSee also\n\n* Finding the Center of a Circle from 2 Points and Radius from Math forum @ Drexel"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\n```\nmulti sub circles (@A, @B where ([and] @A Z== @B), 0.0) { 'Degenerate point' }\nmulti sub circles (@A, @B where ([and] @A Z== @B), $)   { 'Infinitely many share a point' }\nmulti sub circles (@A, @B, $radius) {\n    my @middle = (@A Z+ @B) X/ 2;\n    my @diff = @A Z- @B;\n    my $q = sqrt [+] @diff X** 2;\n    return 'Too far apart' if $q > $radius * 2;\n\n    my @orth = -@diff[0], @diff[1] X* sqrt($radius ** 2 - ($q / 2) ** 2) / $q;\n    return (@middle Z+ @orth), (@middle Z- @orth);\n}\n\nmy @input =\n    ([0.1234, 0.9876],  [0.8765, 0.2345],   2.0),\n    ([0.0000, 2.0000],  [0.0000, 0.0000],   1.0),\n    ([0.1234, 0.9876],  [0.1234, 0.9876],   2.0),\n    ([0.1234, 0.9876],  [0.8765, 0.2345],   0.5),\n    ([0.1234, 0.9876],  [0.1234, 0.9876],   0.0),\n    ;\n\nfor @input {\n    say .list.raku, ': ', circles(|$_).join(' and ');\n}\n\n```\n\nOutput:\n\n```\n([0.1234, 0.9876], [0.8765, 0.2345], 2.0): 1.86311180165819 1.97421180165819 and -0.863211801658189 -0.752111801658189\n([0.0, 2.0], [0.0, 0.0], 1.0): 0 1 and 0 1\n([0.1234, 0.9876], [0.1234, 0.9876], 2.0): Infinitely many share a point\n([0.1234, 0.9876], [0.8765, 0.2345], 0.5): Too far apart\n([0.1234, 0.9876], [0.1234, 0.9876], 0.0): Degenerate point\n```\n\nAnother possibility is to use the Complex plane,\nfor it often makes calculations easier with plane geometry:\n\n```\nmulti sub circles ($a, $b where $a == $b, 0.0) { 'Degenerate point' }\nmulti sub circles ($a, $b where $a == $b, $)   { 'Infinitely many share a point' }\nmulti sub circles ($a, $b, $r) {\n    my $h = ($b - $a) / 2;\n    my $l = sqrt($r**2 - $h.abs**2);\n    return 'Too far apart' if $l.isNaN;\n    return map { $a + $h + $l * $_ * $h / $h.abs }, i, -i;\n}\n\nmy @input =\n    (0.1234 + 0.9876i,  0.8765 + 0.2345i,   2.0),\n    (0.0000 + 2.0000i,  0.0000 + 0.0000i,   1.0),\n    (0.1234 + 0.9876i,  0.1234 + 0.9876i,   2.0),\n    (0.1234 + 0.9876i,  0.8765 + 0.2345i,   0.5),\n    (0.1234 + 0.9876i,  0.1234 + 0.9876i,   0.0),\n    ;\n\nfor @input {\n    say .join(', '), ': ', circles(|$_).join(' and ');\n}\n\n```\n\nOutput:\n\n```\n0.1234+0.9876i, 0.8765+0.2345i, 2: 1.86311180165819+1.97421180165819i and -0.863211801658189-0.752111801658189i\n0+2i, 0+0i, 1: 0+1i and 0+1i\n0.1234+0.9876i, 0.1234+0.9876i, 2: Infinitely many share a point\n0.1234+0.9876i, 0.8765+0.2345i, 0.5: Too far apart\n0.1234+0.9876i, 0.1234+0.9876i, 0: Degenerate point\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nA **circular prime** is a prime number with the property that the number generated at each intermediate step when cyclically permuting its (base 10) digits will also be prime.\n\nFor example:\n**1193** is a circular prime, since **1931**, **9311** and **3119** are all also prime.\n\nNote that a number which is a cyclic permutation of a smaller circular prime is not considered to be itself a circular prime. So **13** is a circular prime, but **31** is not.\n\nA **repunit** (denoted by R) is a number whose base 10 representation contains only the digit **1**.\n\nFor example:\nR(2) = 11 and R(5) = 11111 are repunits.\n\nTask\n\n* Find the first 19 circular primes.\n\n* If your language has access to arbitrary precision integer arithmetic, given that they are all repunits, find the next 4 circular primes.\n\n* (Stretch) Determine which of the following repunits are probably circular primes: R(5003), R(9887), R(15073), R(25031), R(35317) and R(49081). The larger ones may take a long time to process so just do as many as you reasonably can.\n\nSee also\n\n* Wikipedia article - Circular primes.\n* Wikipedia article - Repunit.\n* OEIS sequence A016114 - Circular primes."}, {"role": "assistant", "content": "Most of the repunit testing is relatively speedy using the ntheory library. The really slow ones are R(25031), at ~42 seconds and R(49081) at 922(!!) seconds.\n\n**Library:** ntheory\n\n```\nsub isCircular(\\n) {\n   return False unless n.is-prime;\n   my @circular = n.comb;\n   return False if @circular.min < @circular[0];\n   for 1 ..^ @circular -> $i {\n      return False unless .is-prime and $_ >= n given @circular.rotate($i).join;\n   }\n   True\n}\n\nsay \"The first 19 circular primes are:\";\nsay ((2..*).hyper.grep: { isCircular $_ })[^19];\n\nsay \"\\nThe next 4 circular primes, in repunit format, are:\";\nloop ( my $i = 7, my $count = 0; $count < 4; $i++ ) {\n   ++$count, say \"R($i)\" if (1 x $i).is-prime\n}\n\nuse ntheory:from<Perl5> qw[is_prime];\n\nsay \"\\nRepunit testing:\";\n\n(5003, 9887, 15073, 25031, 35317, 49081).map: {\n    my $now = now;\n    say \"R($_): Prime? \", ?is_prime(\"{1 x $_}\"), \"  {(now - $now).fmt: '%.2f'}\"\n}\n\n```\n\nOutput:\n\n```\nThe first 19 circular primes are:\n(2 3 5 7 11 13 17 37 79 113 197 199 337 1193 3779 11939 19937 193939 199933)\n\nThe next 4 circular primes, in repunit format, are:\nR(19)\nR(23)\nR(317)\nR(1031)\n\nRepunit testing:\nR(5003): Prime? False  0.00\nR(9887): Prime? False  0.01\nR(15073): Prime? False  0.02\nR(25031): Prime? False  41.40\nR(35317): Prime? False  0.32\nR(49081): Prime? True  921.73\n```"}]}
{"messages": [{"role": "user", "content": "Cistercian numerals were used across Europe by Cistercian monks during the Late Medieval Period as an alternative to Roman numerals. They were used to represent base 10 integers from **0** to **9999**.\n\nHow they work\n\nAll Cistercian numerals begin with a vertical line segment, which by itself represents the number **0**. Then, glyphs representing the digits **1** through **9** are optionally added to the four quadrants surrounding the vertical line segment. These glyphs are drawn with vertical and horizontal symmetry about the initial line segment. Each quadrant corresponds to a digit place in the number:\n\n:   * The **upper-right** quadrant represents the **ones** place.\n    * The **upper-left** quadrant represents the **tens** place.\n    * The **lower-right** quadrant represents the **hundreds** place.\n    * The **lower-left** quadrant represents the **thousands** place.\n\nPlease consult the following image for examples of Cistercian numerals showing each glyph: [1]\n\nTask\n\n:   * Write a function/procedure/routine to display any given Cistercian numeral. This could be done by drawing to the display, creating an image, or even as text (as long as it is a reasonable facsimile).\n\n:   * Use the routine to show the following Cistercian numerals:\n\n:   :   * 0\n        * 1\n        * 20\n        * 300\n        * 4000\n        * 5555\n        * 6789\n        * And a number of your choice!\n\nNotes\n\nDue to the inability to upload images to Rosetta Code as of this task's creation, showing output here on this page is not required. However, it is welcomed — especially for text output.\n\nSee also\n\n:   * **Numberphile - The Forgotten Number System**\n    * **dcode.fr - Online Cistercian numeral converter**"}, {"role": "assistant", "content": "Handles 0 through 9999 only. No error trapping. If you feed it an unsupported number it will truncate to maximum 4 digits.\n\n```\nmy @line-segments = (0, 0, 0, 100),\n    (0,  0, 35,  0), (0, 35, 35, 35), (0,  0, 35, 35), (0, 35, 35,  0), ( 35,  0, 35, 35),\n    (0,  0,-35,  0), (0, 35,-35, 35), (0,  0,-35, 35), (0, 35,-35,  0), (-35,  0,-35, 35),\n    (0,100, 35,100), (0, 65, 35, 65), (0,100, 35, 65), (0, 65, 35,100), ( 35, 65, 35,100),\n    (0,100,-35,100), (0, 65,-35, 65), (0,100,-35, 65), (0, 65,-35,100), (-35, 65,-35,100);\n\nmy @components = map {@line-segments[$_]}, |((0, 5, 10, 15).map: -> $m {\n    |((0,), (1,), (2,), (3,), (4,), (1,4), (5,), (1,5), (2,5), (1,2,5)).map: {$_ »+» $m}\n});\n\nmy $out = 'Cistercian-raku.svg'.IO.open(:w);\n\n$out.say: # insert header\nq|<svg  width=\"875\" height=\"470\" style=\"stroke:black;\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">\n <rect width=\"100%\" height=\"100%\" style=\"fill:white;\"/>|;\n\nmy $hs = 50; # horizontal spacing\nmy $vs = 25; # vertical spacing\n\nfor flat ^10, 20, 300, 4000, 5555, 6789, 9394, (^10000).pick(14) -> $cistercian {\n\n    $out.say: |@components[0].map: { # draw zero / base vertical bar\n        qq|<line x1=\"{.[0] + $hs}\" y1=\"{.[1] + $vs}\" x2=\"{.[2] + $hs}\" y2=\"{.[3] + $vs}\"/>|\n    };\n\n    my @orders-of-magnitude = $cistercian.polymod(10 xx *);\n\n    for @orders-of-magnitude.kv -> $order, $value {\n        next unless $value; # skip zeros, already drew zero bar\n        last if $order > 3; # truncate too large integers\n\n        # draw the component line segments\n        $out.say: join \"\\n\", @components[$order * 10 + $value].map: {\n            qq|<line x1=\"{.[0] + $hs}\" y1=\"{.[1] + $vs}\" x2=\"{.[2] + $hs}\" y2=\"{.[3] + $vs}\"/>|\n        }\n    }\n\n    # insert the decimal number below\n    $out.say: qq|<text x=\"{$hs - 5}\" y=\"{$vs + 120}\">{$cistercian}</text>|;\n\n    if ++$ %% 10 { # next row\n        $hs = -35;\n        $vs += 150;\n    }\n\n    $hs += 85; # increment horizontal spacing\n\n\n}\n$out.say: q|</svg>|; # insert footer\n\n```\n\nOutput:"}]}
{"messages": [{"role": "user", "content": "In object-oriented programming **class** is a set (a transitive closure) of types bound by the relation of inheritance. It is said that all types derived from some base type T and the type T itself form a class T.\n\nThe first type T from the class T sometimes is called the **root type** of the class.\n\nA class of types itself, as a type, has the values and operations of its own.\nThe operations of are usually called **methods** of the root type.\nBoth operations and values are called polymorphic.\n\nA polymorphic operation (method) selects an implementation depending on the actual specific type of the polymorphic argument.\n\nThe action of choice the type-specific implementation of a polymorphic operation is called **dispatch**. Correspondingly, polymorphic operations are often called **dispatching** or **virtual**.\nOperations with multiple arguments and/or the results of the class are called **multi-methods**.\nA further generalization of is the operation with arguments and/or results from different classes.\n\n* single-dispatch languages are those that allow only one argument or result to control the dispatch. Usually it is the first parameter, often hidden, so that a prefix notation *x*.*f*() is used instead of mathematical *f*(*x*).\n* multiple-dispatch languages allow many arguments and/or results to control the dispatch.\n\nA polymorphic value has a type tag indicating its specific type from the class and the corresponding specific value of that type.\nThis type is sometimes called **the most specific type** of a [polymorphic] value.\nThe type tag of the value is used in order to resolve the dispatch.\nThe set of polymorphic values of a class is a transitive closure of the sets of values of all types from that class.\n\nIn many OO languages\nthe type of the class of T and T itself are considered equivalent.\nIn some languages they are distinct (like in Ada).\nWhen class T and T are equivalent, there is no way to distinguish\npolymorphic and specific values.\n\nTask\n\nCreate a basic class with a method, a constructor, an instance variable and how to instantiate it."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nclass Camel { has Int $.humps = 1; }\n\nmy Camel $a .= new;\nsay $a.humps;  # Automatically generated accessor method.\n\nmy Camel $b .= new: humps => 2;\nsay $b.humps;\n```\n\nA more complex example:\n\n```\nclass Butterfly {\n    has Int $!age;   # With the ! twigil, no public accessor method is generated\n    has Str $.name;\n    has Str $.color;\n    has Bool $.wings;\n\n    submethod BUILD(:$!name = 'Camelia', :$!age = 2, :$!color = 'pink') {\n        # BUILD is called by bless. Its primary use is to to control\n        # object initialization.\n        $!wings = $!age > 1;\n    }\n\n    method flap() {\n        say ($.wings\n          ?? 'Watch out for that hurricane!'\n          !! 'No wings to flap.');\n    }\n}\n\nmy Butterfly $a .= new: age => 5;\nsay \"Name: {$a.name}, Color: {$a.color}\";\n$a.flap;\n\nmy Butterfly $b .= new(name => 'Osgood', age => 4);\nsay \"Name: {$b.name}, Color: {$b.color}\";\n$b.flap;\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Closest pair of points problem. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nProvide a function to find the closest two points among a set of given points in two dimensions,   i.e. to solve the   Closest pair of points problem   in the   *planar*   case.\n\nThe straightforward solution is a   O(n2)   algorithm   (which we can call *brute-force algorithm*);   the pseudo-code (using indexes) could be simply:\n\n```\nbruteForceClosestPair of P(1), P(2), ... P(N)\nif N < 2 then\n  return ∞\nelse\n  minDistance ← |P(1) - P(2)|\n  minPoints ← { P(1), P(2) }\n  foreach i ∈ [1, N-1]\n    foreach j ∈ [i+1, N]\n      if |P(i) - P(j)| < minDistance then\n        minDistance ← |P(i) - P(j)|\n        minPoints ← { P(i), P(j) } \n      endif\n    endfor\n  endfor\n  return minDistance, minPoints\n endif\n\n```\n\nA better algorithm is based on the recursive divide&conquer approach,   as explained also at   Wikipedia's Closest pair of points problem,   which is   O(*n* log *n*);   a pseudo-code could be:\n\n```\nclosestPair of (xP, yP)\n               where xP is P(1) .. P(N) sorted by x coordinate, and\n                     yP is P(1) .. P(N) sorted by y coordinate (ascending order)\nif N ≤ 3 then\n  return closest points of xP using brute-force algorithm\nelse\n  xL ← points of xP from 1 to ⌈N/2⌉\n  xR ← points of xP from ⌈N/2⌉+1 to N\n  xm ← xP(⌈N/2⌉)x\n  yL ← { p ∈ yP : px ≤ xm }\n  yR ← { p ∈ yP : px > xm }\n  (dL, pairL) ← closestPair of (xL, yL)\n  (dR, pairR) ← closestPair of (xR, yR)\n  (dmin, pairMin) ← (dR, pairR)\n  if dL < dR then\n    (dmin, pairMin) ← (dL, pairL)\n  endif\n  yS ← { p ∈ yP : |xm - px| < dmin }\n  nS ← number of points in yS\n  (closest, closestPair) ← (dmin, pairMin)\n  for i from 1 to nS - 1\n    k ← i + 1\n    while k ≤ nS and yS(k)y - yS(i)y < dmin\n      if |yS(k) - yS(i)| < closest then\n        (closest, closestPair) ← (|yS(k) - yS(i)|, {yS(k), yS(i)})\n      endif\n      k ← k + 1\n    endwhile\n  endfor\n  return closest, closestPair\nendif\n\n```\n\nReferences and further readings\n\n* Closest pair of points problem\n* Closest Pair (McGill)\n* Closest Pair (UCSB)\n* Closest pair (WUStL)\n* Closest pair (IUPUI)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl 5\n\nUsing concurrency, the 'simple' routine beats the (supposedly) more efficient one for all but the smallest sets of input.\n\n```\nsub MAIN ($N = 5000) {\n    my @points = (^$N).map: { [rand × 20 - 10, rand × 20 - 10] }\n\n    my @candidates = @points.sort(*.[0]).rotor( 10 => -2, :partial).race.map: { closest-pair-simple(@$_) }\n    say 'simple ' ~ (@candidates.sort: *.[2]).head(1).gist;\n    @candidates    = @points.sort(*.[0]).rotor( 10 => -2, :partial).race.map: { closest-pair(@$_)        }\n    say 'real '   ~ (@candidates.sort: *.[2]).head(1).gist;\n}\n\nsub dist-squared(@a, @b) { (@a[0] - @b[0])² + (@a[1] - @b[1])² }\n\nsub closest-pair-simple(@points is copy) {\n    return ∞ if @points < 2;\n    my ($a, $b, $d) = |@points[0,1], dist-squared(|@points[0,1]);\n    while @points {\n        my \\p = pop @points;\n        for @points -> \\l {\n            ($a, $b, $d) = p, l, $_ if $_ < $d given dist-squared(p, l);\n        }\n    }\n    $a, $b, $d.sqrt\n}\n\nsub closest-pair(@r) {\n    closest-pair-real (@r.sort: *.[0]), (@r.sort: *.[1])\n}\n\nsub closest-pair-real(@rx, @ry) {\n    return closest-pair-simple(@rx) if @rx ≤ 3;\n\n    my \\N  = @rx;\n    my \\midx = ceiling(N/2) - 1;\n    my @PL := @rx[     0 ..  midx];\n    my @PR := @rx[midx+1 ..^ N   ];\n    my \\xm  = @rx[midx;0];\n    (.[0] ≤ xm ?? my @yR !! my @yL).push: @$_ for @ry;\n    my (\\al, \\bl, \\dL) = closest-pair-real(@PL, @yR);\n    my (\\ar, \\br, \\dR) = closest-pair-real(@PR, @yL);\n    my ($w1, $w2, $closest) = dR < dL ?? (ar, br, dR) !! (al, bl, dL);\n    my @yS = @ry.grep: { (xm - .[0]).abs < $closest }\n\n    for 0 ..^ @yS -> \\i {\n        for i+1 ..^ @yS -> \\k {\n            next unless @yS[k;1] - @yS[i;1] < $closest;\n            ($w1, $w2, $closest) = |@yS[k, i], $_ if $_ < $closest given dist-squared(|@yS[k, i]).sqrt;\n        }\n    }\n    $w1, $w2, $closest\n}\n\n```\n\nOutput:\n\n```\nsimple (([-1.1560800527301716 -9.214015073077793] [-1.1570263876019649 -9.213340680530798] 0.0011620477602117762))\n  real (([-1.1570263876019649 -9.213340680530798] [-1.1560800527301716 -9.214015073077793] 0.0011620477602117762))\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a list of ten functions, in the simplest manner possible   (anonymous functions are encouraged),   such that the function at index    ***i***     (you may choose to start     ***i***     from either    **0**    or    **1**),    when run, should return the square of the index,   that is,     ***i***  2.\n\nDisplay the result of running any but the last function, to demonstrate that the function indeed remembers its value.\n\nGoal\n\nDemonstrate how to create a series of independent closures based on the same template but maintain separate copies of the variable closed over.\n\nIn imperative languages, one would generally use a loop with a mutable counter variable.\n\nFor each function to maintain the correct number, it has to capture the *value* of the variable at the time it was created, rather than just a reference to the variable, which would have a different value by the time the function was run.\n\nSee also: Multiple distinct objects"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\nAll blocks are anonymous closures in Raku, and parameters are lexicals, so it's easy to generate a list of them. We'll use a gather/take generator loop, and call the closures in random order, just to keep things interesting.\n\n```\nmy @c = gather for ^10 -> $i {\n    take { $i * $i }\n}\n\n.().say for @c.pick(*);  # call them in random order\n```\n\nOutput:\n\n```\n36\n64\n25\n1\n16\n0\n4\n9\n81\n49\n```\n\nOr equivalently, using a more functional notation:\n\n```\nsay .() for pick *, map -> $i { -> {$i * $i} }, ^10\n```"}]}
{"messages": [{"role": "user", "content": "First, show the shortest possible program that will emit the nine-character string “Code Golf”, without the quotation marks and without anything after the final “f”. Then show the shortest possible program that does the same thing but without itself containing any string or character literals, and without requiring any input or any environment variables or command-line arguments, though the name of the running program can be used.\n\nExtra credit: how big is the executable required to perform the first task? Skip details about any prior compilation steps that might be involved."}, {"role": "assistant", "content": "Not very interesting, as it's pretty much just standard, non-obscure Raku. The output string is so short, there isn't any easy way to golf it shorter than just printing it directly. 17 bytes.\n\n```\nprint <Code Golf>\n\n```\n\nOutput:\n\n```\nCode Golf\n```\n\nAssuming we can't use the string literal in the source, the shortest I've come up with is:\n\n```\nprint chrs 37,9,2,3,70,33,9,10,0 X+^102 # 39 chars, 39 bytes\n\n```\n\nTry it online!\n\n```\nprint chrs -3,㊶,㉚,㉛,-㊳,1,㊶,㊳,㉜X+㉎ # 33 Chars, 49 bytes\n\n```\n\nTry it online!\n\n```\nprint <Dpef!Hpmg>.ords».pred.chrs # 33 Chars, 34 bytes. Somewhat cheaty as it _does_ contain a string literal, but not the same literal as the output\n\n```\n\nSame output for each. Of course, to actually run any of that code you need the Raku compiler at 18.0Kb, the nqp vm interpreter at 17.9 Kb and the moar virtual machine at 17.9Kb. (Or the Java virtual machine, which is remarkably difficult to come up with a size for...)"}]}
{"messages": [{"role": "user", "content": "Some advanced applications, such as memory resident applications, daemons and memory demanding applications unload unrequired parts of the application during use (such as initialization code that will no longer be used again once the application is operational) to free up memory and resources. Demonstrate or explain how to unload an unused section of code from memory.\n\nNote that it is sufficient to flag the memory area as being available for reuse by the memory management system, without the need to demonstrate the zeroing of the bytes and performing a memory shuffle, unless such actions are required to free up the code segment.\n\nLanguages that do not have the facility to free up their code segment (such as scripting languages) can be omitted."}, {"role": "assistant", "content": "(formerly Perl 6)\nIn general, there is no specific mechanism to do a timely destruction of an object, be it code, data, variables, whatever. Raku does automatic garbage collection on objects that are no longer being used. Unlike Perl, from which Raku is loosely derived, it doesn't use reference counting to track when memory may be garbage collected as that tends to be very difficult to get correct and performant in multi-threaded applications. Rather it performs a \"reachability analysis\" to determine when objects can be evicted from memory and safely removed.\n\nRaku objects can provide a \"DESTROY\" method, but you cannot be sure when (if ever) it will be called. Raku tends to not be very memory frugal. If there is lots of memory to be had, it will cheerfully use lots of it. It gets more aggressive about conserving if memory is tight, but usually will trade memory for performance. If and when garbage collection *has* run, the freed memory is then available to to the general OS pool for any process to claim.\n\nThere are some specific details that will allow some finer control of garbage collection in special circumstances, but the average Raku programmer will not need to know about or deal with them."}]}
{"messages": [{"role": "user", "content": "Task\n\nCollect and sort square numbers in ascending order from three lists.\n  \nlist[1] = [3,4,34,25,9,12,36,56,36]\n  \nlist[2] = [2,8,81,169,34,55,76,49,7]\n  \nlist[3] = [75,121,75,144,35,16,46,35]"}, {"role": "assistant", "content": "```\nmy $s = cache sort ( my $l = ( cache flat\n\n[3,4,34,25,9,12,36,56,36],\n[2,8,81,169,34,55,76,49,7],\n[75,121,75,144,35,16,46,35]\n\n)).grep: * ∈ cache {$++²}…*>$l.max;\n\nput 'Added - Sorted';\nput ' ' ~ $s.sum ~ '  ' ~ $s.gist;\n\n```\n\n```\nAdded - Sorted\n 690  (4 9 16 25 36 36 49 81 121 144 169)\n\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nCollections are abstractions to represent sets of values.\n\nIn statically-typed languages, the values are typically of a common data type.\n\nTask\n\nCreate a collection, and add a few values to it.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku has both mutable and immutable containers of various sorts. Here are some of the most common ones:\n\n### Mutable\n\n```\n# Array\nmy @array = 1,2,3;\n@array.push: 4,5,6;\n\n# Hash\nmy %hash = 'a' => 1, 'b' => 2;\n%hash<c d> = 3,4;\n%hash.push: 'e' => 5, 'f' => 6;\n\n# SetHash\nmy $s = SetHash.new: <a b c>;\n$s ∪= <d e f>;\n\n# BagHash\nmy $b = BagHash.new: <b a k l a v a>;\n$b ⊎= <a b c>;\n```\n\n### Immutable\n\n```\n# List\nmy @list := 1,2,3;\nmy @newlist := |@list, 4,5,6; # |@list will slip @list into the surrounding list instead of creating a list of lists\n\n# Set\nmy $set = set <a b c>;\nmy $newset = $set ∪ <d e f>;\n\n# Bag\nmy $bag = bag <b a k l a v a>;\nmy $newbag = $bag ⊎ <b e e f>;\n```\n\n### Pair list (cons list)\n\n```\nmy $tail = d => e => f => Nil;\nmy $new = a => b => c => $tail;\n```\n\n### P6opaque object (immutable in structure)\n\n```\nclass Something { has $.foo; has $.bar };\nmy $obj = Something.new: foo => 1, bar => 2;\nmy $newobj = $obj but role { has $.baz = 3 } # anonymous mixin\n```"}]}
{"messages": [{"role": "user", "content": "## The CIE ΔE2000 color difference formula\n\nThe **ΔE2000 color difference formula** is a widely used metric for comparing two colors in the CIE 1976 color space. It enhances the earlier CIE76 algorithm by integrating additional perceptual factors, resulting in more accurate **color matching**.\n\n### Task\n\nGiven the first six values, obtain the results in column seven, accurate to 10 decimal places.\n\n| L1 | a1 | b1 | L2 | a2 | b2 | ΔE2000 |\n| --- | --- | --- | --- | --- | --- | --- |\n| 73.0 | 49.0 | 39.4 | 73.0 | 49.0 | 39.4 | 0.0 |\n| 30.0 | -41.0 | -119.1 | 30.0 | -41.0 | -119.0 | 0.0134319631 |\n| 79.0 | -117.0 | -100.4 | 79.5 | -117.0 | -100.0 | 0.3572501235 |\n| 15.0 | -55.0 | 6.7 | 14.0 | -55.0 | 7.0 | 0.6731711696 |\n| 83.0 | 98.0 | -59.5 | 85.2 | 98.0 | -59.5 | 1.4597018301 |\n| 59.0 | -11.0 | -95.0 | 56.3 | -11.0 | -95.0 | 2.4566352112 |\n| 74.0 | -1.0 | 68.6 | 81.0 | -1.0 | 69.0 | 4.9755487499 |\n| 46.4 | 125.0 | 6.0 | 40.0 | 125.0 | 6.0 | 5.8974138376 |\n| 18.0 | -5.0 | 68.0 | 20.0 | 5.0 | 82.0 | 6.8542258013 |\n| 35.5 | -99.0 | 109.0 | 25.0 | -99.0 | 109.0 | 8.1462591143 |\n| 59.0 | 77.0 | 41.5 | 63.3 | 77.0 | 12.4 | 13.1325726695 |\n| 40.0 | -92.0 | 7.7 | 58.0 | -92.0 | -8.0 | 19.1411733022 |\n| 49.0 | -9.0 | -74.5 | 51.1 | 31.0 | 16.0 | 48.1082375109 |\n| 88.0 | -124.0 | 56.0 | 97.0 | 62.0 | -28.0 | 63.9449872676 |\n| 98.0 | 75.7 | 11.0 | 3.0 | -62.0 | 11.0 | 126.5088270078 |\n\n* **L1 and L2** nominally ranges from 0 (white) to 100 (black)\n* **a1 and a2** are unbounded and commonly clamped to the range of -128 (green) to 127 (red)\n* **b1 and b2** are unbounded and commonly clamped to the range of -128 (blue) to 127 (yellow)"}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20250609 Raku programming solution\n\nsub hypot(\\x, \\y) { sqrt(x² + y²) }\n\n# The classic CIE ΔE2000 implementation, which operates on two L*a*b* colors, and returns their difference.\nsub ciede_2000(\\L1, \\A1, \\B1, \\L2, \\A2, \\B2) {\n    \n   # Kl, Kc, Kh are parametric factors to be adjusted according to\n   # different viewing parameters such as textures, backgrounds...\n   my (\\Kl, \\Kc, \\Kh) = 1.0 xx 3;      \n\n   my $n = ((hypot(A1, B1) + hypot(A2, B2)) * 0.5)⁷;\n   $n = 1.0 + 0.5 * (1.0 - sqrt($n / ($n + 6103515625.0)));\n    \n   # hypot calculates the Euclidean distance while avoiding overflow/underflow.\n   my (\\C1, \\C2) = ( [A1 * $n, B1], [A2 * $n, B2] ).map: { hypot |$_ }; \n\n   # atan2 is preferred over atan because it accurately computes the angle of\n   # a point (x, y) in all quadrants, handling the signs of both coordinates.\n   my \\H1 = $ = atan2(B1, A1 * $n);\n   my \\H2 = $ = atan2(B2, A2 * $n);\n\n   if H1 < 0.0 { H1 += 2.0 * π }\n   if H2 < 0.0 { H2 += 2.0 * π }\n    \n   $n = abs(H2 - H1);\n    \n   # Cross-implementation consistent rounding.\n   $n = π if π - 1e-14 < $n && $n < π + 1e-14; \n    \n   # When the hue angles lie in different quadrants, the straightforward\n   # average can produce a mean that incorrectly suggests a hue angle in\n   # the wrong quadrant, the next lines handle this issue.\n   my \\Hm = $ = (H1 + H2) * 0.5;\n   my \\Hd = $ = (H2 - H1) * 0.5;\n    \n   if π < $n {\n      0.0 < Hd ?? ( Hd -= π ) !! Hd += π;\n      Hm += π;\n   }\n    \n   my \\p = 36.0 * Hm - 55.0 * π;\n   $n = ((C1 + C2) * 0.5)⁷;\n    \n   # The hue rotation correction term is designed to account for the\n   # non-linear behavior of hue differences in the blue region.\n   my \\Rt = -2.0 * sqrt( $n/($n+6103515625.0)) * sin(π/3.0*exp(p²/(-25.0*π²)) );\n   $n = ((L1 + L2) * 0.5 - 50.0)²;    \n\n   # Lightness.\n   my \\l = (L2 - L1) / (Kl * (1.0 + 0.015 * $n / sqrt(20.0 + $n)));\n    \n   # These coefficients adjust the impact of different harmonic\n   # components on the hue difference calculation.\n   my \\t = 1.0 + 0.24*sin(2.0*Hm + π*0.5) + 0.32*sin(3.0*Hm + 8.0*π/15.0) - \n           0.17*sin(Hm + π/3.0) - 0.20*sin(4.0 * Hm + 3.0*π/20.0);\n   $n = C1 + C2;\n    \n   # Hue.\n   my \\h = 2.0 * sqrt(C1 * C2) * sin(Hd) / (Kh * (1.0 + 0.0075 * $n * t));\n    \n   # Chroma.\n   my \\c = (C2 - C1) / (Kc * (1.0 + 0.0225 * $n));\n    \n   # Returning the square root ensures that the result represents\n   # the \"true\" geometric distance in the color space.\n   return sqrt(l² + h² + c² + c * h * Rt)\n}\n\nsay \"   L1     a1     b1     L2     a2     b2        ΔE2000\";\nsay \"------------------------------------------------------------\";\n\nfor [\n   [73.0, 49.0, 39.4, 73.0, 49.0, 39.4],\n   [30.0, -41.0, -119.1, 30.0, -41.0, -119.0],\n   [79.0, -117.0, -100.4, 79.5, -117.0, -100.0],\n   [15.0, -55.0, 6.7, 14.0, -55.0, 7.0],\n   [83.0, 98.0, -59.5, 85.2, 98.0, -59.5],\n   [59.0, -11.0, -95.0, 56.3, -11.0, -95.0],\n   [74.0, -1.0, 68.6, 81.0, -1.0, 69.0],\n   [46.4, 125.0, 6.0, 40.0, 125.0, 6.0],\n   [18.0, -5.0, 68.0, 20.0, 5.0, 82.0],\n   [35.5, -99.0, 109.0, 25.0, -99.0, 109.0],\n   [59.0, 77.0, 41.5, 63.3, 77.0, 12.4],\n   [40.0, -92.0, 7.7, 58.0, -92.0, -8.0],\n   [49.0, -9.0, -74.5, 51.1, 31.0, 16.0],\n   [88.0, -124.0, 56.0, 97.0, 62.0, -28.0],\n   [98.0, 75.7, 11.0, 3.0, -62.0, 11.0],\n] { printf \"%6.1f \" x 6 ~ \"%14.10f\\n\", $_[^6], ciede_2000 |$_[^6] }\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task\n\nGet color information from an arbitrary pixel on the screen, such as the current location of the mouse cursor.\n\nThe mouse cursor may or may not have to be active in a GUI created by your program. These functions are OS related."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis example works with MacOS, customize with the appropriate screencapture utility for other OSes.\n\n```\nuse GD::Raw;\n\nmy $file = '/tmp/one-pixel-screen-capture.png';\n\nqqx/screencapture -R 123,456,1,1 $file/;\n\nmy $fh    = fopen($file, \"rb\") or die;\nmy $image = gdImageCreateFromPng($fh);\nmy $pixel = gdImageGetPixel($image, 0, 0);\nmy ($red,$green,$blue) =\n    gdImageRed(  $image, $pixel),\n    gdImageGreen($image, $pixel),\n    gdImageBlue( $image, $pixel);\n\nsay \"RGB: $red, $green, $blue\";\n\nfclose($fh);\nunlink $file;\n\n```\n\nOutput:\n\n```\nRGB: 20, 2, 124\n```\n\nAlternately, a version that should work in any X11 environment. Needs X11::xdo and MagickWand installed.\n\n```\nsignal(SIGINT).tap: { sleep .1; cleanup(); print \"\\n\" xx 50, \"\\e[H\\e[J\"; exit(0) }\n\nmulti MAIN () {\n    use X11::libxdo;\n    my $xdo = Xdo.new;\n    my ($lx, $ly) = 0, 0;\n    loop {\n        sleep .1;\n        my ($x, $y, $) = $xdo.get-mouse-location;\n        next if $lx == $x and $ly == $y;\n        ($lx, $ly) = $x, $y;\n        display $x, $y, |get-pixel($x, $y);\n    }\n}\n\nmy %*SUB-MAIN-OPTS = :named-anywhere;\n\nmulti MAIN (\n    Int $x,    #= Integer x coordinate to pick\n    Int $y,    #= Integer y coordinate to pick\n    $q = False #= Boolean \"quiet\" mode, set truthy for decimal values, set to h for hex values\n  ) {\n    my ($red, $green, $blue) = get-pixel($x, $y);\n\n    if $q {\n        $q.lc eq 'h' ??\n          ( printf \"%02X:%02X:%02X\\n\", $red, $green, $blue ) !!\n          ( printf \"%03d:%03d:%03d\\n\", $red, $green, $blue );\n    } else {\n        display($x, $y, $red, $green, $blue);\n        cleanup();\n    }\n    exit(0);\n}\n\nsub get-pixel ($x, $y) {\n    my $xcolor =\n      qqx/import -window root -crop 1x1+{$x-1 max 0}+{$y-2 max 0} -depth 8 txt:-/\n      .comb(/<?after '#'><xdigit> ** 6/);\n\n    |$xcolor.comb(2)».parse-base(16);\n}\n\nsub display ($x, $y, $r, $g, $b) {\n    print \"\\e[?25l\\e[48;2;0;0;0m\\e[38;2;255;255;255m\\e[H\\e[J\";\n    printf \"  x: %4d y: $y\\n\", $x;\n    printf \"  RGB: %03d:%03d:%03d \\n  HEX: %02X:%02X:%02X\\n\",\n            $r, $g, $b, $r, $g, $b;\n    print \"\\e[38;2;{$r};{$g};{$b}m \",\n           ('█' x 18 xx 6).join(\"\\n \"), \"\\n\\n\";\n}\n\nsub cleanup { print \"\\e[0m\\e[?25h\" }\n\n```"}]}
{"messages": [{"role": "user", "content": "full color\n\nExample: Gimp 16 color\n\nColor quantization is the process of reducing number of colors used in an image while trying to maintain the visual appearance of the original image. In general, it is a form of cluster analysis, if each RGB color value is considered as a coordinate triple in the 3D colorspace. There are some well know algorithms [1], each with its own advantages and drawbacks.\n\n**Task**: Take an RGB color image and reduce its colors to some smaller number (< 256). For this task, use the frog as input and reduce colors to 16, and output the resulting colors. The chosen colors should be adaptive to the input image, meaning you should *not* use a fixed palette such as Web colors or Windows system palette. Dithering is not required.\n\nNote: the funny color bar on top of the frog image is intentional."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.10\n\n```\nuse MagickWand;\nuse MagickWand::Enums;\n\nmy $frog = MagickWand.new;\n$frog.read(\"./Quantum_frog.png\");\n$frog.quantize(16, RGBColorspace, 0, True, False);\n$frog.write('./Quantum-frog-16-perl6.png');\n\n```\n\nSee: Quantum-frog-16-perl6.png (offsite .png image)"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function to draw a HSV color wheel completely with code.\n\nThis is strictly for learning purposes only. It's highly recommended that you use an image in an actual application to actually draw the color wheel   (as procedurally drawing is super slow). This does help you understand how color wheels work and this can easily be used to determine a color value based on a position within a circle."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.08\n\nFile:Color-wheel-perl6.png\n\n```\nuse Image::PNG::Portable;\n\nmy ($w, $h) = 300, 300;\n\nmy $out = Image::PNG::Portable.new: :width($w), :height($h);\n\nmy $center = $w/2 + $h/2*i;\n\ncolor-wheel($out);\n\n$out.write: 'Color-wheel-perl6.png';\n\nsub color-wheel ( $png ) {\n    ^$w .race.map: -> $x {\n        for ^$h -> $y {\n            my $vector    = $center - $x - $y*i;\n            my $magnitude = $vector.abs * 2 / $w;\n            my $direction = ( π + atan2( |$vector.reals ) ) / τ;\n            $png.set: $x, $y, |hsv2rgb( $direction, $magnitude, $magnitude < 1 );\n        }\n    }\n}\n\nsub hsv2rgb ( $h, $s, $v ){\n    my $c = $v * $s;\n    my $x = $c * (1 - abs( (($h*6) % 2) - 1 ) );\n    my $m = $v - $c;\n    (do given $h {\n        when   0..^1/6 { $c, $x, 0 }\n        when 1/6..^1/3 { $x, $c, 0 }\n        when 1/3..^1/2 { 0, $c, $x }\n        when 1/2..^2/3 { 0, $x, $c }\n        when 2/3..^5/6 { $x, 0, $c }\n        when 5/6..1    { $c, 0, $x }\n    } ).map: ((*+$m) * 255).Int\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "A **colorful number** is a non-negative base 10 integer where the product of every sub group of consecutive digits is unique.\n\nE.G.\n\n24753 is a colorful number. 2, 4, 7, 5, 3, (2×4)8, (4×7)28, (7×5)35, (5×3)15, (2×4×7)56, (4×7×5)140, (7×5×3)105, (2×4×7×5)280, (4×7×5×3)420, (2×4×7×5×3)840\n\nEvery product is unique.\n\n2346 is **not** a colorful number. 2, 3, 4, **6**, (2×3)**6**, (3×4)12, (4×6)24, (2×3×4)48, (3×4×6)72, (2×3×4×6)144\n\nThe product **6** is repeated.\n\nSingle digit numbers **are** considered to be colorful. A colorful number larger than 9 cannot contain a repeated digit, the digit 0 or the digit 1. As a consequence, there is a firm upper limit for colorful numbers; no colorful number can have more than 8 digits.\n\nTask\n\n* Write a routine (subroutine, function, procedure, whatever it may be called in your language) to test if a number is a colorful number or not.\n* Use that routine to find all of the colorful numbers less than 100.\n* Use that routine to find the largest possible colorful number.\n\nStretch\n\n* Find and display the count of colorful numbers in each order of magnitude.\n* Find and show the total count of **all** colorful numbers.\n\n*Colorful numbers have no real number theory application. They are more a recreational math puzzle than a useful tool.*"}, {"role": "assistant", "content": "```\nsub is-colorful (Int $n) {\n    return True if 0 <= $n <= 9;\n    return False if $n.contains(0) || $n.contains(1) || $n < 0;\n    my @digits = $n.comb;\n    my %sums = @digits.Bag;\n    return False if %sums.values.max > 1;\n    for 2..@digits -> $group {\n        @digits.rotor($group => 1 - $group).map: { %sums{ [×] $_ }++ }\n        return False if %sums.values.max > 1;\n    }\n    True\n}\n\nput \"Colorful numbers less than 100:\\n\" ~ (^100).hyper.grep( &is-colorful).batch(10)».fmt(\"%2d\").join: \"\\n\";\n\nmy ($start, $total) = 23456789, 10;\n\nprint \"\\nLargest magnitude colorful number: \";\n.put and last if .Int.&is-colorful for $start.flip … $start;\n\n\nput \"\\nCount of colorful numbers for each order of magnitude:\\n\" ~\n    \"1 digit colorful number count: $total - 100%\";\n\nfor 2..8 {\n   put \"$_ digit colorful number count: \",\n   my $c = +(flat $start.comb.combinations($_).map: {.permutations».join».Int}).hyper.grep( &is-colorful ),\n   \" - {($c / (exp($_,10) - exp($_-1,10) ) * 100).round(.001)}%\";\n   $total += $c;\n}\n\nsay \"\\nTotal colorful numbers: $total\";\n\n```\n\nOutput:\n\n```\nColorful numbers less than 100:\n 0  1  2  3  4  5  6  7  8  9\n23 24 25 26 27 28 29 32 34 35\n36 37 38 39 42 43 45 46 47 48\n49 52 53 54 56 57 58 59 62 63\n64 65 67 68 69 72 73 74 75 76\n78 79 82 83 84 85 86 87 89 92\n93 94 95 96 97 98\n\nLargest magnitude colorful number: 98746253\n\nCount of colorful numbers for each order of magnitude:\n1 digit colorful number count: 10 - 100%\n2 digit colorful number count: 56 - 62.222%\n3 digit colorful number count: 328 - 36.444%\n4 digit colorful number count: 1540 - 17.111%\n5 digit colorful number count: 5514 - 6.127%\n6 digit colorful number count: 13956 - 1.551%\n7 digit colorful number count: 21596 - 0.24%\n8 digit colorful number count: 14256 - 0.016%\n\nTotal colorful numbers: 57256\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay a series of vertical color bars across the width of the display.\n\nThe color bars should either use:\n\n:   :   :   * the system palette,   or\n            * the sequence of colors:\n\n            :   :   :   * black\n                        * red\n                        * green\n                        * blue\n                        * magenta\n                        * cyan\n                        * yellow\n                        * white"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.10\n\n```\nmy ($x,$y) = 1280, 720;\n\nmy @colors = map -> $r, $g, $b { Buf.new: |(($r, $g, $b) xx $x div 8) },\n      0,   0,   0,\n    255,   0,   0,\n      0, 255,   0,\n      0,   0, 255,\n    255,   0, 255,\n      0, 255, 255,\n    255, 255,   0,\n    255, 255, 255;\n\nmy $img = open \"colorbars.ppm\", :w orelse die \"Can't create colorbars.ppm: $_\";\n\n$img.print: qq:to/EOH/;\n    P6\n    # colorbars.ppm\n    $x $y\n    255\n    EOH\n\nfor ^$y {\n    for ^@colors -> $h {\n        $img.write: @colors[$h];\n    }\n}\n\n$img.close;\n\n```"}]}
{"messages": [{"role": "user", "content": "The task is to create 1 pixel wide coloured vertical pinstripes with a sufficient number of pinstripes to span the entire width of the graphics display.\n\nThe pinstripes should either follow the system palette sequence,   or a sequence that includes:\n  \nblack,   red,   green,   blue,   magenta,   cyan,   yellow,   and   white:\n\n:   :   * after filling the top quarter, switch to a wider 2 pixel wide vertical pinstripe pattern,\n        * halfway down the display, switch to 3 pixel wide vertical pinstripe,\n        * finally to a 4 pixels wide vertical pinstripe for the last quarter of the display.\n\nSee also\n\n* display black and white\n* print colour"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy ($x,$y) = 1280, 720;\n\nmy @colors = map -> $r, $g, $b { [$r, $g, $b] },\n     0,   0,   0,\n   255,   0,   0,\n     0, 255,   0,\n     0,   0, 255,\n   255,   0, 255,\n     0, 255, 255,\n   255, 255,   0,\n   255, 255, 255;\n\nmy $img = open \"pinstripes.ppm\", :w orelse die \"Can't create pinstripes.ppm: $_\";\n\n$img.print: qq:to/EOH/;\n    P3\n    # pinstripes.ppm\n    $x $y\n    255\n    EOH\n\nmy $vzones = $y div 4;\nfor 1..4 -> $width {\n    my $stripes = ceiling $x / $width / +@colors;\n    my $row = [flat ((@colors Xxx $width) xx $stripes).map: *.values].splice(0,$x);\n    $img.put: $row for ^$vzones;\n}\n\n$img.close;\n\n```"}]}
{"messages": [{"role": "user", "content": "The task is to create 1 point wide colour vertical pinstripes with a sufficient number of pinstripes to span the entire width of the colour graphics printer. The pinstripes should alternate between each individual cartridge ink and ink pair and black and white pinstripes should be included. A typical pinstripe sequence woud be black, red, green, blue, magenta, cyan, yellow, white.\n\nAfter the first inch of printing, we switch to a wider 2 pixel wide vertical pinstripe pattern. and to 3 point wide vertical for the next inch, and then 4 point wide, etc. This trend continues for the entire length of the page (or for 12 inches of run length in the case of a printer using continuous roll stationery). After printing the test pattern the page is ejected (or the test pattern is rolled clear of the printer enclosure, in the case of continuous roll printers).\n\nNote that it is an acceptable solution to use the smallest marks that the language provides, rather than working at native printer resolution, where this is not achievable from within the language.\n\nOptionally, on systems where the printer resolution cannot be determined, it is permissible to prompt the user for printer resolution, and to calculate point size based on user input, enabling fractional point sizes to be used."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.01\n\nNote that Raku does not attempt to be a printer driver. This example allows users to specify the dpi and paper size, then generates an image and passes it to the default printer. Defaults to 300 dpi and US letter paper.\n\n```\nunit sub MAIN ($dpi = 300, $size = 'letter');\n\nmy $filename = './Color-pinstripe-printer-perl6.png';\n\nmy %paper = (\n    'letter' => { :width(8.5),    :height(11.0) }\n    'A4'     => { :width(8.2677), :height(11.6929)}\n);\n\nmy ($w, $h) = %paper{$size}<width height> »*» $dpi;\n\n# ROYGBIVK\nmy @color = (1,0,0),(1,.598,0),(1,1,0),(0,1,0),(0,0,1),(.294,0,.51),(.58,0,.827),(0,0,0);\n\nmy $gap = floor $w % ($dpi * +@color) / 2;\n\nmy $rows = (1, * * 2 … * > $dpi).elems;\n\nmy $height = $dpi;\n\nuse Cairo;\n\nmy @colors = @color.map: { Cairo::Pattern::Solid.new.create(|$_) };\n\ngiven Cairo::Image.create(Cairo::FORMAT_ARGB32, $w, $h) -> $image {\n    given Cairo::Context.new($image) {\n        my Cairo::Pattern::Solid $bg .= create(1,1,1);\n        .rectangle(0, 0, $w, $h);\n        .pattern($bg);\n        .fill;\n        $bg.destroy;\n\n        my $y = $gap;\n        for ^$rows -> $row {\n            my $x = $gap;\n            my $width = $dpi / (2 ** $row);\n            for @colors -> $this {\n                my $v = 0;\n                while $v++ < (2 ** ($row - 1)) {\n                    given Cairo::Context.new($image) -> $block {\n                        $block.rectangle($x, $y, $width, $height);\n                        $block.pattern($this);\n                        $block.fill;\n                        $block.destroy;\n                    }\n                    $x += $width;\n                    $x += $width if $row;\n                }\n            }\n        $y += $height;\n        }\n    }\n    $image.write_png($filename);\n}\n\n# Uncomment next line if you actually want to print it\n#run('lp', $filename)\n\n```\n\nSee Color-pinstripe-printer-perl6.png (offsite png image)"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven non-negative integers    **m**    and    **n**,   generate all size    **m**    combinations   of the integers from    **0**   (zero)   to    **n-1**    in sorted order   (each combination is sorted and the entire table is sorted).\n\nExample\n\n**3**   comb    **5**      is:\n\n```\n0 1 2\n0 1 3\n0 1 4\n0 2 3\n0 2 4\n0 3 4\n1 2 3\n1 2 4\n1 3 4\n2 3 4\n\n```\n\nIf it is more \"natural\" in your language to start counting from    **1**   (unity) instead of    **0**   (zero),\n  \nthe combinations can be of the integers from    **1**   to    **n**.\n\nSee also\n\n:   :   :   :   The number of samples of size k from n objects.\n                  \n                  \n                With   combinations and permutations   generation tasks.\n\n                |  | Order Unimportant | Order Important |\n                | --- | --- | --- |\n                | Without replacement | (  n k  )  =  n  C  k =    n ( n − 1 ) … ( n − k + 1 )  k ( k − 1 ) … 1 {\\displaystyle {\\displaystyle {\\binom {n}{k}}=^{n}\\operatorname {C} \\_{k}={\\frac {n(n-1)\\ldots (n-k+1)}{k(k-1)\\dots 1}}}} | n  P  k = n ⋅ ( n − 1 ) ⋅ ( n − 2 ) ⋯ ( n − k + 1 ) {\\displaystyle {\\displaystyle ^{n}\\operatorname {P} \\_{k}=n\\cdot (n-1)\\cdot (n-2)\\cdots (n-k+1)}} |\n                | Task: Combinations | Task: Permutations |\n                | With replacement | (   n + k − 1 k  )  =  n + k − 1  C  k =    ( n + k − 1 ) !  ( n − 1 ) ! k ! {\\displaystyle {\\displaystyle {\\binom {n+k-1}{k}}=^{n+k-1}\\operatorname {C} \\_{k}={(n+k-1)! \\over (n-1)!k!}}} | n  k {\\displaystyle {\\displaystyle n^{k}}} |\n                | Task: Combinations with repetitions | Task: Permutations with repetitions |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015.12\n\nThere actually is a builtin:\n\n```\n.say for combinations(5,3);\n```\n\nOutput:\n\n```\n(0 1 2)\n(0 1 3)\n(0 1 4)\n(0 2 3)\n(0 2 4)\n(0 3 4)\n(1 2 3)\n(1 2 4)\n(1 3 4)\n(2 3 4)\n```\n\nHere is an iterative routine with the same output:\n\n```\nsub combinations(Int $n, Int $k) {\n    return ([],) unless $k;\n    return if $k > $n || $n <= 0;\n    my @c = ^$k;\n    gather loop {\n      take [@c];\n      next if @c[$k-1]++ < $n-1;\n      my $i = $k-2;\n      $i-- while $i >= 0 && @c[$i] >= $n-($k-$i);\n      last if $i < 0;\n      @c[$i]++;\n      while ++$i < $k { @c[$i] = @c[$i-1] + 1; }\n    }\n}\n.say for combinations(5,3);\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Combination. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\n|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Permutation. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nImplement the combination    (nCk)    and permutation    (nPk)    operators in the target language:\n\n:   :   :   * n\n\n              C\n\n              k\n              =\n\n              (\n\n              n\n              k\n\n              )\n              =\n\n              n\n              (\n              n\n              −\n              1\n              )\n              …\n              (\n              n\n              −\n              k\n              +\n              1\n              )\n\n              k\n              (\n              k\n              −\n              1\n              )\n              …\n              1\n              {\\displaystyle {\\displaystyle ^{n}\\operatorname {C} \\_{k}={\\binom {n}{k}}={\\frac {n(n-1)\\ldots (n-k+1)}{k(k-1)\\dots 1}}}}\n\n:   :   :   * n\n\n              P\n\n              k\n              =\n              n\n              ⋅\n              (\n              n\n              −\n              1\n              )\n              ⋅\n              (\n              n\n              −\n              2\n              )\n              ⋯\n              (\n              n\n              −\n              k\n              +\n              1\n              )\n              {\\displaystyle {\\displaystyle ^{n}\\operatorname {P} \\_{k}=n\\cdot (n-1)\\cdot (n-2)\\cdots (n-k+1)}}\n\nSee the Wikipedia articles for a more detailed description.\n\n**To test**, generate and print examples of:\n\n* A sample of permutations from 1 to 12 and Combinations from 10 to 60 using exact Integer arithmetic.\n* A sample of permutations from 5 to 15000 and Combinations from 100 to 1000 using approximate Floating point arithmetic.  \n   This 'floating point' code could be implemented using an approximation, e.g., by calling the Gamma function.\n\nRelated task\n\n* Evaluate binomial coefficients\n\n:   :   :   :   The number of samples of size k from n objects.\n                  \n                  \n                With   combinations and permutations   generation tasks.\n\n                |  | Order Unimportant | Order Important |\n                | --- | --- | --- |\n                | Without replacement | (  n k  )  =  n  C  k =    n ( n − 1 ) … ( n − k + 1 )  k ( k − 1 ) … 1 {\\displaystyle {\\displaystyle {\\binom {n}{k}}=^{n}\\operatorname {C} \\_{k}={\\frac {n(n-1)\\ldots (n-k+1)}{k(k-1)\\dots 1}}}} | n  P  k = n ⋅ ( n − 1 ) ⋅ ( n − 2 ) ⋯ ( n − k + 1 ) {\\displaystyle {\\displaystyle ^{n}\\operatorname {P} \\_{k}=n\\cdot (n-1)\\cdot (n-2)\\cdots (n-k+1)}} |\n                | Task: Combinations | Task: Permutations |\n                | With replacement | (   n + k − 1 k  )  =  n + k − 1  C  k =    ( n + k − 1 ) !  ( n − 1 ) ! k ! {\\displaystyle {\\displaystyle {\\binom {n+k-1}{k}}=^{n+k-1}\\operatorname {C} \\_{k}={(n+k-1)! \\over (n-1)!k!}}} | n  k {\\displaystyle {\\displaystyle n^{k}}} |\n                | Task: Combinations with repetitions | Task: Permutations with repetitions |"}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku can't compute arbitrary large floating point values, thus we will use logarithms, as is often needed when dealing with combinations. We'll also use a Stirling method to approximate \n\nln\n⁡\n(\nn\n!\n)\n{\\displaystyle {\\displaystyle \\ln(n!)}}\n:\n\nln\n⁡\nn\n!\n≈\n\n\n1\n2\nln\n⁡\n(\n2\nπ\nn\n)\n+\nn\nln\n⁡\n\n(\n\nn\ne\n+\n\n\n1\n\n12\ne\nn\n)\n{\\displaystyle {\\displaystyle \\ln n!\\approx {\\frac {1}{2}}\\ln(2\\pi n)+n\\ln \\left({\\frac {n}{e}}+{\\frac {1}{12en}}\\right)}}\n\nNotice that Raku can process arbitrary long integers, though. So it's not clear whether using floating points is useful in this case.\n\n```\nmulti P($n, $k) { [*] $n - $k + 1 .. $n }\nmulti C($n, $k) { P($n, $k) / [*] 1 .. $k }\n \nsub lstirling(\\n) {\n    n < 10 ?? lstirling(n+1) - log(n+1) !!\n    .5*log(2*pi*n)+ n*log(n/e+1/(12*e*n))\n}\n \nrole Logarithm {\n    method gist {\n\tmy $e = (self/10.log).Int;\n\tsprintf \"%.8fE%+d\", exp(self - $e*10.log), $e;\n    }\n}\nmulti P($n, $k, :$float!) {\n    (lstirling($n) - lstirling($n -$k))\n    but Logarithm\n}\nmulti C($n, $k, :$float!) {\n    (lstirling($n) - lstirling($n -$k) - lstirling($k))\n    but Logarithm\n}\n \nsay \"Exact results:\";\nfor 1..12 -> $n {\n    my $p = $n div 3;\n    say \"P($n, $p) = \", P($n, $p);\n}\n \nfor 10, 20 ... 60 -> $n {\n    my $p = $n div 3;\n    say \"C($n, $p) = \", C($n, $p);\n}\n \nsay '';\nsay \"Floating point approximations:\";\nfor 5, 50, 500, 1000, 5000, 15000 -> $n {\n    my $p = $n div 3;\n    say \"P($n, $p) = \", P($n, $p, :float);\n}\n \nfor 100, 200 ... 1000 -> $n {\n    my $p = $n div 3;\n    say \"C($n, $p) = \", C($n, $p, :float);\n}\n\n```\n\nOutput:\n\n```\nExact results:\nP(1, 0) = 1\nP(2, 0) = 1\nP(3, 1) = 3\nP(4, 1) = 4\nP(5, 1) = 5\nP(6, 2) = 30\nP(7, 2) = 42\nP(8, 2) = 56\nP(9, 3) = 504\nP(10, 3) = 720\nP(11, 3) = 990\nP(12, 4) = 11880\nC(10, 3) = 120\nC(20, 6) = 38760\nC(30, 10) = 30045015\nC(40, 13) = 12033222880\nC(50, 16) = 4923689695575\nC(60, 20) = 4191844505805495\n\nFloating point approximations:\nP(5, 1) = 5.00000000E+0\nP(50, 16) = 1.03017326E+26\nP(500, 166) = 3.53487492E+434\nP(1000, 333) = 5.96932629E+971\nP(5000, 1666) = 6.85674576E+6025\nP(15000, 5000) = 9.64985399E+20469\nC(100, 33) = 2.94692433E+26\nC(200, 66) = 7.26975256E+53\nC(300, 100) = 4.15825147E+81\nC(400, 133) = 1.25794868E+109\nC(500, 166) = 3.92602839E+136\nC(600, 200) = 2.50601778E+164\nC(700, 233) = 8.10320356E+191\nC(800, 266) = 2.64562336E+219\nC(900, 300) = 1.74335637E+247\nC(1000, 333) = 5.77613455E+274\n```"}]}
{"messages": [{"role": "user", "content": "The set of combinations with repetitions is computed from a set, \n\nS\n{\\displaystyle {\\displaystyle S}}\n (of cardinality \n\nn\n{\\displaystyle {\\displaystyle n}}\n), and a size of resulting selection, \n\nk\n{\\displaystyle {\\displaystyle k}}\n, by reporting the sets of cardinality \n\nk\n{\\displaystyle {\\displaystyle k}}\n where each member of those sets is chosen from \n\nS\n{\\displaystyle {\\displaystyle S}}\n.\nIn the real world, it is about choosing sets where there is a “large” supply of each type of element and where the order of choice does not matter.\nFor example:\n\n:   Q: How many ways can a person choose two doughnuts from a store selling three types of doughnut: iced, jam, and plain? (i.e., \n\n    S\n    {\\displaystyle {\\displaystyle S}}\n     is \n\n    {\n\n    i\n    c\n    e\n    d\n    ,\n\n    j\n    a\n    m\n    ,\n\n    p\n    l\n    a\n    i\n    n\n    }\n    {\\displaystyle {\\displaystyle \\{\\mathrm {iced} ,\\mathrm {jam} ,\\mathrm {plain} \\}}}\n    , \n\n    |\n    S\n\n    |\n    =\n    3\n    {\\displaystyle {\\displaystyle |S|=3}}\n    , and \n\n    k\n    =\n    2\n    {\\displaystyle {\\displaystyle k=2}}\n    .)\n\n:   A: 6: {iced, iced}; {iced, jam}; {iced, plain}; {jam, jam}; {jam, plain}; {plain, plain}.\n\nNote that both the order of items within a pair, and the order of the pairs given in the answer is not significant; the pairs represent multisets.\n  \nAlso note that *doughnut* can also be spelled *donut*.\n\nTask\n\n* Write a function/program/routine/.. to generate all the combinations with repetitions of \n\n  n\n  {\\displaystyle {\\displaystyle n}}\n   types of things taken \n\n  k\n  {\\displaystyle {\\displaystyle k}}\n   at a time and use it to *show* an answer to the doughnut example above.\n* For extra credit, use the function to compute and show *just the number of ways* of choosing three doughnuts from a choice of ten types of doughnut. Do not show the individual choices for this part.\n\nReferences\n\n* k-combination with repetitions\n\nSee also\n\n:   :   :   :   The number of samples of size k from n objects.\n                  \n                  \n                With   combinations and permutations   generation tasks.\n\n                |  | Order Unimportant | Order Important |\n                | --- | --- | --- |\n                | Without replacement | (  n k  )  =  n  C  k =    n ( n − 1 ) … ( n − k + 1 )  k ( k − 1 ) … 1 {\\displaystyle {\\displaystyle {\\binom {n}{k}}=^{n}\\operatorname {C} \\_{k}={\\frac {n(n-1)\\ldots (n-k+1)}{k(k-1)\\dots 1}}}} | n  P  k = n ⋅ ( n − 1 ) ⋅ ( n − 2 ) ⋯ ( n − k + 1 ) {\\displaystyle {\\displaystyle ^{n}\\operatorname {P} \\_{k}=n\\cdot (n-1)\\cdot (n-2)\\cdots (n-k+1)}} |\n                | Task: Combinations | Task: Permutations |\n                | With replacement | (   n + k − 1 k  )  =  n + k − 1  C  k =    ( n + k − 1 ) !  ( n − 1 ) ! k ! {\\displaystyle {\\displaystyle {\\binom {n+k-1}{k}}=^{n+k-1}\\operatorname {C} \\_{k}={(n+k-1)! \\over (n-1)!k!}}} | n  k {\\displaystyle {\\displaystyle n^{k}}} |\n                | Task: Combinations with repetitions | Task: Permutations with repetitions |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nOne could simply generate all permutations, and then remove \"duplicates\":\n\n**Works with**: Rakudo version 2016.07\n\n```\nmy @S = <iced jam plain>;\nmy $k = 2;\n\n.put for [X](@S xx $k).unique(as => *.sort.cache, with => &[eqv])\n\n```\n\nOutput:\n\n```\niced iced\niced jam\niced plain\njam jam\njam plain\nplain plain\n\n```\n\nAlternatively, a recursive solution:\n\n**Translation of**: Haskell\n\n```\nproto combs_with_rep (UInt, @) {*}\n \nmulti combs_with_rep (0,  @)  { () }\nmulti combs_with_rep (1,  @a)  { map { $_, }, @a }\nmulti combs_with_rep ($,  []) { () }\nmulti combs_with_rep ($n, [$head, *@tail]) {\n    |combs_with_rep($n - 1, ($head, |@tail)).map({ $head, |@_ }),\n    |combs_with_rep($n, @tail);\n}\n \n.say for combs_with_rep( 2, [< iced jam plain >] );\n \n# Extra credit:\nsub postfix:<!> { [*] 1..$^n }\nsub combs_with_rep_count ($k, $n) { ($n + $k - 1)! / $k! / ($n - 1)! }\n \nsay combs_with_rep_count( 3, 10 );\n\n```\n\nOutput:\n\n```\n(iced iced)\n(iced jam)\n(iced plain)\n(jam jam)\n(jam plain)\n(plain plain)\n220\n```"}]}
{"messages": [{"role": "user", "content": "Iterated digits squaring introduces RC the Project Euler Task #92. Combinations with repetitions introduce RC to the concept of generating all the combinations with repetitions of n types of things taken k at a time.\n\nThe purpose of this task is to combine these tasks as follows:\n\n:   The collections of k items will be taken from [0,1,4,9,16,25,36,49,64,81] and must be obtained using code from Combinations with repetitions. The collection of k zeroes is excluded.\n:   For each collection of k items determine if it translates to 1 using the rules from Iterated digits squaring\n:   For each collection which translates to 1 determine the number of different ways, c say, in which the k items can be uniquely ordered.\n:   Keep a running total of all the values of c obtained\n:   Answer the Project Euler Task #92 question (k=7).\n:   Answer the equivalent question for k=8,11,14.\n:   Optionally answer the question for k=17. These numbers will be larger than the basic integer type for many languages, if it is not easy to use larger numbers it is not necessary for this task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Kotlin\n\n```\nuse v6;\n\nsub endsWithOne($n --> Bool) {\n   my $digit;\n   my $sum = 0;\n   my $nn = $n;\n   loop {\n      while ($nn > 0) {\n         $digit = $nn % 10;\n         $sum += $digit²;\n         $nn = $nn div 10;\n      }\n      ($sum == 1) and return True;\n      ($sum == 89) and return False;\n      $nn = $sum;\n      $sum = 0;\n   }\n}\n\nmy @ks = (7, 8, 11, 14, 17);\n\nfor @ks -> $k {\n   my @sums is default(0) = 1,0;\n   my $s;\n   for (1 .. $k) -> $n {\n      for ($n*81 ... 1) -> $i {\n         for (1 .. 9) -> $j {\n            $s = $j²;\n            if ($s > $i) { last };\n            @sums[$i] += @sums[$i-$s];\n         }\n      }\n   }\n   my $count1 = 0;\n   for (1 .. $k*81) -> $i { if (endsWithOne($i)) {$count1 += @sums[$i]} }\n   my $limit = 10**$k - 1;\n   say \"For k = $k in the range 1 to $limit\";\n   say \"$count1 numbers produce 1 and \",$limit-$count1,\" numbers produce 89\";\n}\n\n```\n\nOutput:\n\n```\nFor k = 7 in the range 1 to 9999999\n1418853 numbers produce 1 and 8581146 numbers produce 89\nFor k = 8 in the range 1 to 99999999\n14255666 numbers produce 1 and 85744333 numbers produce 89\nFor k = 11 in the range 1 to 99999999999\n15091199356 numbers produce 1 and 84908800643 numbers produce 89\nFor k = 14 in the range 1 to 99999999999999\n13770853279684 numbers produce 1 and 86229146720315 numbers produce 89\nFor k = 17 in the range 1 to 99999999999999999\n12024696404768024 numbers produce 1 and 87975303595231975 numbers produce 89\n```"}]}
{"messages": [{"role": "user", "content": "Comma quibbling is a task originally set by Eric Lippert in his blog.\n\nTask\n\nWrite a function to generate a string output which is the concatenation of input words from a list/sequence where:\n\n1. An input of no words produces the output string of just the two brace characters \"{}\".\n2. An input of just one word, e.g. [\"ABC\"], produces the output string of the word inside the two braces, e.g. \"{ABC}\".\n3. An input of two words, e.g. [\"ABC\", \"DEF\"], produces the output string of the two words inside the two braces with the words separated by the string \" and \", e.g. \"{ABC and DEF}\".\n4. An input of three or more words, e.g. [\"ABC\", \"DEF\", \"G\", \"H\"], produces the output string of all but the last word separated by \", \" with the last word separated by \" and \" and all within braces; e.g. \"{ABC, DEF, G and H}\".\n\nTest your function with the following series of inputs showing your output here on this page:\n\n* [] # (No input words).\n* [\"ABC\"]\n* [\"ABC\", \"DEF\"]\n* [\"ABC\", \"DEF\", \"G\", \"H\"]\n\nNote: Assume words are non-empty strings of uppercase characters for this task.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub comma-quibbling(@A) {\n    <{ }>.join: @A < 2 ?? @A !! \"@A[0..*-2].join(', ') and @A[*-1]\";\n}\n\nsay comma-quibbling($_) for\n    [], [<ABC>], [<ABC DEF>], [<ABC DEF G H>];\n\n```\n\nOutput:\n\n```\n{}\n{ABC}\n{ABC and DEF}\n{ABC, DEF, G and H}\n```"}]}
{"messages": [{"role": "user", "content": "Retrieve the list of command-line arguments given to the program. For programs that only print the arguments when run directly, see Scripted main.\n\nSee also Program name.\n\nFor parsing command line arguments intelligently, see Parsing command-line arguments.\n\nExample command line:\n\n```\nmyprogram -c \"alpha beta\" -h \"gamma\"\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\nPerl 5's `@ARGV` is available as `@*ARGS`. Alternatively, if you define a subroutine named `MAIN`, Perl will automatically process `@*ARGS` according to Unix conventions and `MAIN`'s signature (or signatures, if your `MAIN` is a multi sub) and then call `MAIN` with appropriate arguments; for more detailed information see: https://docs.raku.org/language/create-cli\n\n```\n# with arguments supplied\n$ raku -e 'sub MAIN($x, $y) { say $x + $y }' 3 5\n8\n\n# missing argument:\n$ raku -e 'sub MAIN($x, $y) { say $x + $y }' 3 \nUsage:\n-e '...' x y\n```\n\nIf the program is stored in a file, the file name is printed instead of `-e '...'`."}]}
{"messages": [{"role": "user", "content": "*Commatizing*   numbers (as used here, is a handy expedient made-up word) is the act of adding commas to a number (or string), or to the numeric part of a larger string.\n\nTask\n\nWrite a function that takes a string as an argument with optional arguments or parameters (the format of parameters/options is left to the programmer) that in general, adds commas (or some\nother characters, including blanks or tabs) to the first numeric part of a string (if it's suitable for commatizing as per the rules below), and returns that newly commatized string.\n\nSome of the commatizing rules (specified below) are arbitrary, but they'll be a part of this task requirements, if only to make the results consistent amongst national preferences and other disciplines.\n\nThe number may be part of a larger (non-numeric) string such as:\n\n:   :   :   :   * «US$1744 millions»       ──or──\n                * ±25000 motes.\n\nThe string may possibly *not* have a number suitable for commatizing, so it should be untouched and *no error generated*.\n\nIf any argument (option) is invalid, nothing is changed and no error *need be* generated (quiet execution, no fail execution).   Error message generation is optional.\n\nThe exponent part of a number is never commatized.   The following string isn't suitable for commatizing:   9.7e+12000\n\nLeading zeroes are never commatized.   The string   0000000005714.882   after commatization is:   0000000005,714.882\n\nAny   *period*   (**.**)   in a number is assumed to be a   *decimal point*.\n\nThe original string is never changed   *except*   by the addition of commas   [or whatever character(s) is/are used for insertion], if at all.\n\nTo wit, the following should be preserved:\n\n:   :   * leading signs (**+**, **-**)       ── even superfluous signs\n        * leading/trailing/embedded blanks, tabs, and other whitespace\n        * the case (upper/lower) of the exponent indicator, e.g.:   4.8903d-002\n\nAny exponent character(s) should be supported:\n\n:   :   :   :   :   :   * 1247e12\n                        * 57256.1D-4\n                        * 4444^60\n                        * 7500**∙**10\\*\\*35\n                        * 8500x10\\*\\*35\n                        * 9500↑35\n                        * +55000↑3\n                        * 1000\\*\\*100\n                        * 2048²\n                        * 409632\n                        * 10000pow(pi)\n\nNumbers may be terminated with any non-digit character, including subscripts and/or superscript:   41421356243   or   7320509076(base 24).\n\nThe character(s) to be used for the comma can be specified, and may contain blanks, tabs, and other whitespace characters, as well as multiple characters.   The default is the comma (**,**) character.\n\nThe   *period length*   can be specified   (sometimes referred to as \"thousands\" or \"thousands separators\").   The   *period length*   can be defined as the length (or number) of the decimal digits between commas.   The default period length is   3.\n\n:   :   :   E.G.:   in this example, the   *period length*   is five:   56789,12340,14148\n\nThe location of where to start the scanning for the target field (the numeric part) should be able to be specified.   The default is   1.\n\nThe character strings below may be placed in a file (and read) or stored as simple strings within the program.\n\nStrings to be used as a minimum\n\nThe value of   pi   (expressed in base 10)   should be separated with blanks every   **5**   places past the decimal point,\n  \nthe Zimbabwe dollar amount should use a decimal point for the \"comma\" separator:\n\n:   * pi=3.14159265358979323846264338327950288419716939937510582097494459231\n    * The author has two Z$100000000000000 Zimbabwe notes (100 trillion).\n    * \"-in Aus$+1411.8millions\"\n    * ===US$0017440 millions=== (in 2000 dollars)\n    * 123.e8000 is pretty big.\n    * The land area of the earth is 57268900(29% of the surface) square miles.\n    * Ain't no numbers in this here words, nohow, no way, Jose.\n    * James was never known as 0000000007\n    * Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.\n    * ␢␢␢$-140000±100 millions.\n    * 6/9/1946 was a good year for some.\n\nwhere the penultimate string has three leading blanks   (real blanks are to be used).\n\nAlso see\n\n* The Wiki entry:   (sir) Arthur Eddington's number of protons in the universe."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nfor ('pi=3.14159265358979323846264338327950288419716939937510582097494459231', {:6at, :5by, :ins(' ')}),\n    ('The author has two Z$100000000000000 Zimbabwe notes (100 trillion).', {:ins<.>}),\n    '-in Aus$+1411.8millions',\n    '===US$0017440 millions=== (in 2000 dollars)',\n    '123.e8000 is pretty big.',\n    'The land area of the earth is  57268900(29% of the surface)  square miles.',\n    'Ain\\'t no numbers in this here words, nohow, no way, Jose.',\n    'James was never known as  0000000007',\n    'Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.',\n    '   $-140000±100  millions.',\n    '6/9/1946 was a good year for some.'\n    {\n        say \"Before: \", .[0];\n        say \" After: \", .[1] ?? .[0].&commatize( |.[1] ) !! .&commatize;\n    }\n \nsub commatize($s, :$at = 0, :$ins = ',', :$by = 3) {\n    $s.subst: :continue($at), :1st, / <[1..9]> <[0..9]>* /,\n        *.flip.comb(/<{ \".**1..$by\" }>/).join($ins).flip;\n}\n\n```\n\nOutput:\n\n```\nBefore: pi=3.14159265358979323846264338327950288419716939937510582097494459231\n After: pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231\nBefore: The author has two Z$100000000000000 Zimbabwe notes (100 trillion).\n After: The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).\nBefore: -in Aus$+1411.8millions\n After: -in Aus$+1,411.8millions\nBefore: ===US$0017440 millions=== (in 2000 dollars)\n After: ===US$0017,440 millions=== (in 2000 dollars)\nBefore: 123.e8000 is pretty big.\n After: 123.e8000 is pretty big.\nBefore: The land area of the earth is  57268900(29% of the surface)  square miles.\n After: The land area of the earth is  57,268,900(29% of the surface)  square miles.\nBefore: Ain't no numbers in this here words, nohow, no way, Jose.\n After: Ain't no numbers in this here words, nohow, no way, Jose.\nBefore: James was never known as  0000000007\n After: James was never known as  0000000007\nBefore: Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.\n After: Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.\nBefore:    $-140000±100  millions.\n After:    $-140,000±100  millions.\nBefore: 6/9/1946 was a good year for some.\n After: 6/9/1946 was a good year for some.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow all ways to include text in a language source file\nthat's completely ignored by the compiler or interpreter.\n\nRelated tasks\n\n* Documentation\n* Here\\_document\n\nSee also\n\n* Wikipedia\n* xkcd (Humor: hand gesture denoting `//` for \"commenting out\" people.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Single-line comments**\n\nA single-line comment starts with # and extends to the end of the line.\n\n```\n# the answer to everything\nmy $x = 42;\n```\n\n**Multi-line comments**\n\nA multi-line comment starts with #` and followed by the commented text enclosed by bracketing characters (e.g., (), [], {}, 「」, etc.).\n\n```\n#`( \n    Comments beginning with a backtick and one or more opening bracketing characters are embedded comments.\n    They can span more than one line…\n)\n\nmy $y = #`{ …or only part of a line. } 3;\n```\n\nMulti-line comments can also be embedded into code.\n\n```\nfor #`(each element in) my @array {\n    say #`(or print element) $_ #`(with a newline);\n}\n```\n\nUsing more than one bracketing character lets you include an unmatched close bracket, as shown below.\n\n```\n#`{{\n  This close curly brace } won't terminate the comment early.\n}}\n```\n\n**Pod comments**\n\n```\n=begin comment\n\nPod is the successor to Perl 5's POD. This is the simplest way to use it for multi-line comments.\nFor more about Pod, see Pod: https://docs.perl6.org/language/pod\n\n=end comment\n```\n\nPod also provides declarator blocks which are special comments that attach to some source code and can be extracted as documentation. They are either #| or #= and must be immediately followed by either a space or an opening curly brace. In short, blocks starting with #| are attached to the code after them, and blocks starting with #= are attached to the code before them.\n\n```\n#| Compute the distance between two points in the plane.\nsub distance(\n    Rat \\x1, #= First point's abscissa,\n    Rat \\y1, #= First point's ordinate, \n    Rat \\x2, #= Second point's abscissa, \n    Rat \\y2, #= Second point's ordinate, \n){\n    return sqrt((x2 - x1)**2 + (y2 - y1)**2)\n}\n```"}]}
{"messages": [{"role": "user", "content": "Given an integer array **nums**, find the common list elements.\n\nExample\n\n**nums** = [2,5,1,3,8,9,4,6], [3,5,6,2,9,8,4], [1,3,7,6,9]\n\n**output** = [3,6,9]\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nput [∩] [2,5,1,3,8,9,4,6], [3,5,6,2,9,8,4], [1,3,7,6,9,3];\n\n```\n\nOutput:\n\n```\n6 9 3\n```"}]}
{"messages": [{"role": "user", "content": "Given an integer array **nums**, the goal is create common sorted list with unique elements.\n\nExample\n\n**nums** = [5,1,3,8,9,4,8,7], [3,5,9,8,4], [1,3,7,9]\n\n**output** = [1,3,4,5,7,8,9]"}, {"role": "assistant", "content": "```\nput sort keys [∪] [5,1,3,8,9,4,8,7], [3,5,9,8,4], [1,3,7,9];\nput sort keys [∪] [5,1,3,8,9,4,8,7], [3,5,9,8,4], [1,3,7,9], [<not everything is an integer so why not avoid special cases # ~ 23 4.2>];\n\n```\n\nOutput:\n\n```\n1 3 4 5 7 8 9\n# 1 3 4 4.2 5 7 8 9 23 an avoid cases everything integer is not so special why ~\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a   list   of arbitrarily many strings, show how to:\n\n* test if they are all lexically **equal**\n* test if every string is lexically **less than** the one after it *(i.e. whether the list is in strict ascending order)*\n\nEach of those two tests should result in a single true or false value, which could be used as the condition of an    `if`    statement or similar.\n\nIf the input list has less than two elements, the tests should always return true.\n\nThere is *no* need to provide a complete program and output.\n\nAssume that the strings are already stored in an array/list/sequence/tuple variable (whatever is most idiomatic) with the name   `strings`,   and just show the expressions for performing those two tests on it (plus of course any includes and custom functions etc. that it needs),   with as little distractions as possible.\n\nTry to write your solution in a way that does not modify the original list,   but if it does then please add a note to make that clear to readers.\n\n*If you need further guidance/clarification,   see #Perl and #Python for solutions that use implicit short-circuiting loops,   and #Raku for a solution that gets away with simply using a built-in language feature.*\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nIn Raku, putting square brackets around an infix operator turns it into a listop that effectively works as if the operator had been put in between all of the elements of the argument list *(or in technical terms, it folds/reduces the list using that operator, while taking into account the operator's inherent associativity and identity value)*:\n\n```\n[eq] @strings  # All equal\n[lt] @strings  # Strictly ascending\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven two strings of different length, determine which string is longer or shorter. Print both strings and their length, one on each line. Print the longer one first.\n\nMeasure the length of your string in terms of bytes or characters, as appropriate for your language. If your language doesn't have an operator for measuring the length of a string, note it.\n\nExtra credit\n\nGiven more than two strings:\n  \nlist = [\"abcd\",\"123456789\",\"abcdef\",\"1234567\"]\n  \nShow the strings in descending length order.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "So... In what way does this task differ significantly from String length? Other than being horribly under specified?\n\nIn the modern world, string \"length\" is pretty much a useless measurement, especially in the absence of a specified encoding; hence Raku not even having an operator: \"length\" for strings.\n\n```\nsay 'Strings (👨‍👩‍👧‍👦, 🤔🇺🇸, BOGUS!) sorted: \"longest\" first:';\nsay \"$_: characters:{.chars},  Unicode code points:{.codes},  UTF-8 bytes:{.encode('UTF8').bytes},  UTF-16 bytes:{.encode('UTF16').bytes}\" for <👨‍👩‍👧‍👦 BOGUS! 🤔🇺🇸>.sort: -*.chars;\n\n```\n\nOutput:\n\n```\nStrings (👨‍👩‍👧‍👦, 🤔🇺🇸, BOGUS!) sorted: \"longest\" first:\nBOGUS!: characters:6,  Unicode code points:6,  UTF-8 bytes:6,  UTF-16 bytes:12\n🤔🇺🇸: characters:2,  Unicode code points:3,  UTF-8 bytes:12,  UTF-16 bytes:12\n👨‍👩‍👧‍👦: characters:1,  Unicode code points:7,  UTF-8 bytes:25,  UTF-16 bytes:22\n```"}]}
{"messages": [{"role": "user", "content": "Measure a relative performance of sorting algorithms implementations.\n\nPlot **execution time vs. input sequence length** dependencies for various implementation of sorting algorithm and different input sequence types (example figures).\n\nConsider three type of input sequences:\n\n:   * ones: sequence of all *1'*s.   Example: {1, 1, 1, 1, 1}\n    * range: ascending sequence, i.e. already sorted.   Example: {1, 2, 3, 10, 15}\n    * shuffled range: sequence with elements randomly distributed.   Example: {5, 3, 9, 6, 8}\n\nConsider at least two different sorting functions (different algorithms or/and different implementation of the same algorithm).\n\nFor example, consider Bubble Sort, Insertion sort, Quicksort or/and implementations of Quicksort with different pivot selection mechanisms.   Where possible, use existing implementations.\n\nPreliminary subtask:\n\n:   * Bubble Sort, Insertion sort, Quicksort, Radix sort, Shell sort\n    * Query Performance\n    * Write float arrays to a text file\n    * Plot x, y arrays\n    * Polynomial Fitting\n\nGeneral steps:\n\n:   1. Define sorting routines to be considered.\n    2. Define appropriate sequence generators and write timings.\n    3. Plot timings.\n    4. What conclusions about relative performance of the sorting routines could be made based on the plots?"}, {"role": "assistant", "content": "**Translation of**: Julia\n\n```\n# 20221114 Raku programming solution\n\nmy ($rounds,$size) = 3, 2000;\nmy @allones        = 1 xx $size;\nmy @sequential     = 1 .. $size;\nmy @randomized     = @sequential.roll xx $size; \n\nsub insertion_sort ( @a is copy ) { # rosettacode.org/wiki/Sorting_algorithms/Insertion_sort#Raku\n   for 1 .. @a.end -> \\k {\n      loop (my ($j,\\value)=k-1,@a[k];$j>-1&&@a[$j]>value;$j--) {@a[$j+1]=@a[$j]}\n      @a[$j+1] = value;\n   }\n   return @a;\n}\n\nsub merge_sort ( @a ) { # rosettacode.org/wiki/Sorting_algorithms/Merge_sort#Raku\n    return @a if @a <= 1;\n\n    my $m = @a.elems div 2;\n    my @l = merge_sort @a[  0 ..^ $m ];\n    my @r = merge_sort @a[ $m ..^ @a ];\n\n    return flat @l, @r if @l[*-1] !after @r[0];\n    return flat gather {\n        take @l[0] before @r[0] ?? @l.shift !! @r.shift\n            while @l and @r;\n        take @l, @r;\n    }\n}\n\nsub quick-sort(@data) { # andrewshitov.com/2019/06/23/101-quick-sort-in-perl-6/\n    return @data if @data.elems <= 1;\n\n    my ($pivot,@left, @right) = @data[0];\n\n    for @data[1..*] -> $x { $x < $pivot ?? push @left, $x !! push @right, $x }\n\n    return flat(quick-sort(@left), $pivot, quick-sort(@right));\n}\n\nsub comparesorts($rounds, @tosort) {\n   my ( $iavg, $mavg, $qavg, $t );\n\n   for (<i m q> xx $rounds).flat.pick(*) -> \\sort_type {\n      given sort_type {\n         when 'i' { $t = now ; insertion_sort @tosort ; $iavg += now - $t } \n         when 'm' { $t = now ; merge_sort     @tosort ; $mavg += now - $t } \n\t when 'q' { $t = now ; quick-sort     @tosort ; $qavg += now - $t }\n      }\n   }\n   return $iavg, $mavg, $qavg  »/»  $rounds\n}\n\nfor <ones presorted randomized>Z(@allones,@sequential,@randomized) -> ($t,@d) {\n   say \"Average sort times for $size $t:\";\n   { say \"\\tinsertion sort\\t$_[0]\\n\\tmerge sort\\t$_[1]\\n\\tquick sort\\t$_[2]\" }(comparesorts $rounds,@d)\n}\n\n```\n\nOutput:\n\n```\nAverage sort times for 2000 ones:\n        insertion sort  0.112333083\n        merge sort      0.506624066\n        quick sort      5.899009606666667\nAverage sort times for 2000 presorted:\n        insertion sort  0.03596163\n        merge sort      0.474839352\n        quick sort      5.896118350666666\nAverage sort times for 2000 randomized:\n        insertion sort  5.352926729\n        merge sort      0.784896982\n        quick sort      0.11422247299999999\n```"}]}
{"messages": [{"role": "user", "content": "Some programming languages allow calculation of values at compile time.\n\nTask\n\nCalculate    10!    (ten factorial)   at compile time.\n\nPrint the result when the program is run.\n\nDiscuss what limitations apply to compile-time calculations in your language."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nconstant $tenfact = [*] 2..10; \nsay $tenfact;\n\n```\n\nLike Perl 5, we also have a BEGIN block, but it also works to introduce a blockless statement,\nthe value of which will be stored up to be used as an expression at run time:\n\n```\n say BEGIN [*] 2..10;\n\n```"}]}
{"messages": [{"role": "user", "content": "Code Generator\n\nA code generator translates the output of the syntax analyzer and/or semantic analyzer\ninto lower level code, either assembly, object, or virtual.\n\nTask\n\nTake the output of the Syntax analyzer task - which is a flattened Abstract Syntax Tree (AST) - and convert it to virtual machine code, that can be run by the\nVirtual machine interpreter. The output is in text format, and represents virtual assembly code.\n\nThe program should read input from a file and/or stdin, and write output to a file and/or\nstdout.\n\nExample - given the simple program (below), stored in a file called while.t, create the list of tokens, using one of the Lexical analyzer solutions\n\n```\nlex < while.t > while.lex\n\n```\n\nRun one of the Syntax analyzer solutions\n\n```\nparse < while.lex > while.ast\n\n```\n\nwhile.ast can be input into the code generator.\n\nThe following table shows the input to lex, lex output, the AST produced by the parser, and the generated virtual assembly code.\n\n```\nRun as:  lex < while.t | parse | gen\n\n```\n\n| Input to lex | Output from lex, input to parse | Output from parse | Output from gen, input to VM |\n| --- | --- | --- | --- |\n| ``` count = 1; while (count < 10) {     print(\"count is: \", count, \"\\n\");     count = count + 1; }  ``` | **```     1      1   Identifier      count     1      7   Op_assign     1      9   Integer              1     1     10   Semicolon     2      1   Keyword_while     2      7   LeftParen     2      8   Identifier      count     2     14   Op_less     2     16   Integer             10     2     18   RightParen     2     20   LeftBrace     3      5   Keyword_print     3     10   LeftParen     3     11   String          \"count is: \"     3     23   Comma     3     25   Identifier      count     3     30   Comma     3     32   String          \"\\n\"     3     36   RightParen     3     37   Semicolon     4      5   Identifier      count     4     11   Op_assign     4     13   Identifier      count     4     19   Op_add     4     21   Integer              1     4     22   Semicolon     5      1   RightBrace     6      1   End_of_input ```** | **``` Sequence Sequence ; Assign Identifier    count Integer       1 While Less Identifier    count Integer       10 Sequence Sequence ; Sequence Sequence Sequence ; Prts String        \"count is: \" ; Prti Identifier    count ; Prts String        \"\\n\" ; Assign Identifier    count Add Identifier    count Integer       1 ```** | **``` Datasize: 1 Strings: 2 \"count is: \" \"\\n\"    0 push  1    5 store [0]   10 fetch [0]   15 push  10   20 lt   21 jz     (43) 65   26 push  0   31 prts   32 fetch [0]   37 prti   38 push  1   43 prts   44 fetch [0]   49 push  1   54 add   55 store [0]   60 jmp    (-51) 10   65 halt ```** |\n\nInput format\n\nAs shown in the table, above, the output from the syntax analyzer is a flattened AST.\n\nIn the AST, Identifier, Integer, and String, are terminal nodes, e.g, they do not have child nodes.\n\nLoading this data into an internal parse tree should be as simple as:\n\n```\ndef load_ast()\n    line = readline()\n    # Each line has at least one token\n    line_list = tokenize the line, respecting double quotes\n\n    text = line_list[0] # first token is always the node type\n\n    if text == \";\"\n        return None\n\n    node_type = text # could convert to internal form if desired\n\n    # A line with two tokens is a leaf node\n    # Leaf nodes are: Identifier, Integer String\n    # The 2nd token is the value\n    if len(line_list) > 1\n        return make_leaf(node_type, line_list[1])\n\n    left = load_ast()\n    right = load_ast()\n    return make_node(node_type, left, right)\n\n```\n\nOutput format - refer to the table above\n\n* The first line is the header: Size of data, and number of constant strings.\n  + size of data is the number of 32-bit unique variables used. In this example, one variable, **count**\n  + number of constant strings is just that - how many there are\n* After that, the constant strings\n* Finally, the assembly code\n\nRegisters\n\n* sp: the stack pointer - points to the next top of stack. The stack is a 32-bit integer array.\n\n* pc: the program counter - points to the current instruction to be performed. The code is an array of bytes.\n\nData\n\n32-bit integers and strings\n\nInstructions\n\nEach instruction is one byte. The following instructions also have a 32-bit integer operand:\n\n```\nfetch [index]\n\n```\n\nwhere index is an index into the data array.\n\n```\nstore [index]\n\n```\n\nwhere index is an index into the data array.\n\n```\npush n\n\n```\n\nwhere value is a 32-bit integer that will be pushed onto the stack.\n\n```\njmp (n) addr\n\n```\n\nwhere (n) is a 32-bit integer specifying the distance between the current location and the\ndesired location. addr is an unsigned value of the actual code address.\n\n```\njz (n) addr\n\n```\n\nwhere (n) is a 32-bit integer specifying the distance between the current location and the\ndesired location. addr is an unsigned value of the actual code address.\n\nThe following instructions do not have an operand. They perform their operation directly\nagainst the stack:\n\nFor the following instructions, the operation is performed against the top two entries in\nthe stack:\n\n```\nadd\nsub\nmul\ndiv\nmod\nlt\ngt\nle\nge\neq\nne\nand\nor\n\n```\n\nFor the following instructions, the operation is performed against the top entry in the\nstack:\n\n```\nneg\nnot\n\n```\n\n```\nprtc\n\n```\n\nPrint the word at stack top as a character.\n\n```\nprti\n\n```\n\nPrint the word at stack top as an integer.\n\n```\nprts\n\n```\n\nStack top points to an index into the string pool. Print that entry.\n\n```\nhalt\n\n```\n\nUnconditional stop.\n\nAdditional examples\n\nYour solution should pass all the test cases above and the additional tests found **Here**.\n\nReference\n\nThe C and Python versions can be considered reference implementations.\n\nRelated Tasks\n\n* Lexical Analyzer task\n* Syntax Analyzer task\n* Virtual Machine Interpreter task\n* AST Interpreter task\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\nUsing 'while-count' example, input used is here: ast.txt\n\n**Translation of**: Perl\n\n```\nmy %opnames = <\n    Less   lt     LessEqual    le     Multiply mul    Subtract sub    NotEqual ne\n    Divide div    GreaterEqual ge     Equal    eq     Greater  gt     Negate   neg\n>;\n\nmy (@AST, %strings, %names);\nmy $string-count = my $name-count = my $pairsym = my $pc = 0;\n\nsub tree {\n    my ($A, $B) = ( '_' ~ ++$pairsym, '_' ~ ++$pairsym );\n    my $line = @AST.shift // return '';\n    $line ~~ /^ $<instr> = (\\w+|';') [\\s+ $<arg> =(.*)]? / or die \"bad input $line\";\n    given $<instr> {\n        when 'Identifier' { \"fetch [{%names{$<arg>} //= $name-count++ }]\\n\" }\n        when 'Sequence'   { tree() ~ tree() }\n        when 'Integer'    { \"push  $<arg>\\n\" }\n        when 'String'     { \"push  { %strings{$<arg>} //= $string-count++ }\\n\" }\n        when 'Assign'     { join '', reverse (tree().subst( /fetch/, 'store')), tree() }\n        when 'While'      { \"$A:\\n{ tree() }jz    $B\\n{ tree() }jmp   $A\\n$B:\\n\" }\n        when 'If'         { tree() ~ \"jz    $A\\n{ !@AST.shift ~ tree() }jmp   $B\\n$A:\\n{ tree() }$B:\\n\" }\n        when ';'          { '' }\n        default           { tree() ~ tree() ~ (%opnames{$<instr>} // $<instr>.lc) ~ \"\\n\" }\n    }\n}\n\n@AST = slurp('ast.txt').lines;\nmy $code = tree() ~ \"halt\\n\";\n\n$code ~~ s:g/^^ jmp \\s+ (\\S+) \\n ('_'\\d+:\\n) $0:\\n/$1/;                                          # remove jmp next\n$code ~~ s:g/^^ (<[a..z]>\\w* (\\N+)? ) $$/{my $l=$pc.fmt(\"%4d \"); $pc += $0[0] ?? 5 !! 1; $l}$0/; # add locations\nmy %labels = ($code ~~ m:g/^^ ('_' \\d+) ':' \\n \\s* (\\d+)/)».Slip».Str;                           # pc addr of labels\n$code ~~ s:g/^^ \\s* (\\d+) \\s j[z|mp] \\s* <(('_'\\d+)/ ({%labels{$1} - $0 - 1}) %labels{$1}/;      # fix jumps\n$code ~~ s:g/^^ '_'\\d+.*?\\n//;                                                                   # remove labels\n\nsay \"Datasize: $name-count Strings: $string-count\\n\"\n   ~ join('', %strings.keys.sort.reverse «~» \"\\n\")\n   ~ $code;\n\n```\n\nOutput:\n\n```\nDatasize: 1 Strings: 2\n\"count is: \"\n\"\\n\"\n   0 push  1\n   5 store [0]\n  10 fetch [0]\n  15 push  10\n  20 lt\n  21 jz     (43) 65\n  26 push  0\n  31 prts\n  32 fetch [0]\n  37 prti\n  38 push  1\n  43 prts\n  44 fetch [0]\n  49 push  1\n  54 add\n  55 store [0]\n  60 jmp    (-51) 10\n  65 halt\n```"}]}
{"messages": [{"role": "user", "content": "Lexical Analyzer\n\nDefinition from Wikipedia:\n\n:   *Lexical analysis is the process of converting a sequence of characters (such as in a computer program or web page) into a sequence of tokens (strings with an identified \"meaning\"). A program that performs lexical analysis may be called a lexer, tokenizer, or scanner (though \"scanner\" is also used to refer to the first stage of a lexer).*\n\nCreate a lexical analyzer for the simple programming language specified below. The\nprogram should read input from a file and/or stdin, and write output to a file and/or\nstdout. If the language being used has a lexer module/library/class, it would be great\nif two versions of the solution are provided: One without the lexer module, and one with.\n\nInput Specification\n\nThe simple programming language to be analyzed is more or less a subset of C. It supports the following tokens:\n\nOperators\n\n:   :   :   | Name | Common name | Character sequence |\n            | --- | --- | --- |\n            | Op\\_multiply | multiply | \\* |\n            | Op\\_divide | divide | / |\n            | Op\\_mod | mod | % |\n            | Op\\_add | plus | + |\n            | Op\\_subtract | minus | - |\n            | Op\\_negate | unary minus | - |\n            | Op\\_less | less than | < |\n            | Op\\_lessequal | less than or equal | <= |\n            | Op\\_greater | greater than | > |\n            | Op\\_greaterequal | greater than or equal | >= |\n            | Op\\_equal | equal | == |\n            | Op\\_notequal | not equal | != |\n            | Op\\_not | unary not | ! |\n            | Op\\_assign | assignment | = |\n            | Op\\_and | logical and | && |\n            | Op\\_or | logical or | ¦¦ |\n\n* The `-` token should always be interpreted as Op\\_subtract by the lexer. Turning some Op\\_subtract into Op\\_negate will be the job of the syntax analyzer, which is not part of this task.\n\nSymbols\n\n:   :   :   | Name | Common name | Character |\n            | --- | --- | --- |\n            | LeftParen | left parenthesis | ( |\n            | RightParen | right parenthesis | ) |\n            | LeftBrace | left brace | { |\n            | RightBrace | right brace | } |\n            | Semicolon | semi-colon | ; |\n            | Comma | comma | , |\n\nKeywords\n\n:   :   :   | Name | Character sequence |\n            | --- | --- |\n            | Keyword\\_if | if |\n            | Keyword\\_else | else |\n            | Keyword\\_while | while |\n            | Keyword\\_print | print |\n            | Keyword\\_putc | putc |\n\nIdentifiers and literals\n\nThese differ from the the previous tokens, in that each occurrence of them has a value associated with it.\n\n:   :   :   | Name | Common name | Format description | Format regex | Value |\n            | --- | --- | --- | --- | --- |\n            | Identifier | identifier | one or more letter/number/underscore characters, but not starting with a number | `[_a-zA-Z][_a-zA-Z0-9]*` | as is |\n            | Integer | integer literal | one or more digits | `[0-9]+` | as is, interpreted as a number |\n            | Integer | char literal | exactly one character (anything except newline or single quote) or one of the allowed escape sequences, enclosed by single quotes | `'([^'\\n]|\\\\n|\\\\\\\\)'` | the ASCII code point number of the character, e.g. 65 for `'A'` and 10 for `'\\n'` |\n            | String | string literal | zero or more characters (anything except newline or double quote), enclosed by double quotes | `\"[^\"\\n]*\"` | the characters without the double quotes and with escape sequences converted |\n\n* For char and string literals, the `\\n` escape sequence is supported to represent a new-line character.\n* For char and string literals, to represent a backslash, use `\\\\`.\n* No other special sequences are supported. This means that:\n  + Char literals cannot represent a single quote character (value 39).\n  + String literals cannot represent strings containing double quote characters.\n\nZero-width tokens\n\n:   :   :   | Name | Location |\n            | --- | --- |\n            | End\\_of\\_input | when the end of the input stream is reached |\n\nWhite space\n\n* Zero or more whitespace characters, or comments enclosed in `/* ... */`, are allowed between any two tokens, with the exceptions noted below.\n* \"Longest token matching\" is used to resolve conflicts (e.g., in order to match **<=** as a single token rather than the two tokens **<** and **=**).\n* Whitespace is *required* between two tokens that have an alphanumeric character or underscore at the edge.\n  + This means: keywords, identifiers, and integer literals.\n  + e.g. `ifprint` is recognized as an identifier, instead of the keywords if and print.\n  + e.g. `42fred` is invalid, and neither recognized as a number nor an identifier.\n* Whitespace is *not allowed* inside of tokens (except for chars and strings where they are part of the value).\n  + e.g. `& &` is invalid, and not interpreted as the && operator.\n\nFor example, the following two program fragments are equivalent, and should produce the same token stream except for the line and column positions:\n\n* ```\n  if ( p /* meaning n is prime */ ) {\n      print ( n , \" \" ) ;\n      count = count + 1 ; /* number of primes found so far */\n  }\n\n  ```\n* ```\n  if(p){print(n,\" \");count=count+1;}\n\n  ```\n\nComplete list of token names\n\n```\nEnd_of_input  Op_multiply   Op_divide     Op_mod       Op_add     Op_subtract\nOp_negate     Op_not        Op_less       Op_lessequal Op_greater Op_greaterequal\nOp_equal      Op_notequal   Op_assign     Op_and       Op_or      Keyword_if\nKeyword_else  Keyword_while Keyword_print Keyword_putc LeftParen  RightParen\nLeftBrace     RightBrace    Semicolon     Comma        Identifier Integer\nString\n\n```\n\nOutput Format\n\nThe program output should be a sequence of lines, each consisting of the following whitespace-separated fields:\n\n1. the line number where the token starts\n2. the column number where the token starts\n3. the token name\n4. the token value (only for Identifier, Integer, and String tokens)\n5. the number of spaces between fields is up to you. Neatly aligned is nice, but not a requirement.\n\nThis task is intended to be used as part of a pipeline, with the other compiler tasks - for example:\n  \n**lex < hello.t | parse | gen | vm**\n\nOr possibly:\n  \n**lex hello.t lex.out**\n  \n**parse lex.out parse.out**\n  \n**gen parse.out gen.out**\n  \n**vm gen.out**\n\nThis implies that the output of this task (the lexical analyzer) should be suitable as input to any of the Syntax Analyzer task programs.\n\nDiagnostics\n\nThe following error conditions should be caught:\n\n:   :   :   | Error | Example |\n            | --- | --- |\n            | Empty character constant | `''` |\n            | Unknown escape sequence. | `\\r` |\n            | Multi-character constant. | `'xx'` |\n            | End-of-file in comment. Closing comment characters not found. |\n            | End-of-file while scanning string literal. Closing string character not found. |\n            | End-of-line while scanning string literal. Closing string character not found before end-of-line. |\n            | Unrecognized character. |  |\n            | Invalid number. Starts like a number, but ends in non-numeric characters. | `123abc` |\n\nTest Cases\n\n:   | Input | Output |\n    | --- | --- |\n    | Test Case 1:  ``` /*   Hello world  */ print(\"Hello, World!\\n\");  ``` | **```     4      1 Keyword_print     4      6 LeftParen     4      7 String         \"Hello, World!\\n\"     4     24 RightParen     4     25 Semicolon     5      1 End_of_input  ```** |\n    | Test Case 2:  ``` /*   Show Ident and Integers  */ phoenix_number = 142857; print(phoenix_number, \"\\n\");  ``` | **```     4      1 Identifier     phoenix_number     4     16 Op_assign     4     18 Integer         142857     4     24 Semicolon     5      1 Keyword_print     5      6 LeftParen     5      7 Identifier     phoenix_number     5     21 Comma     5     23 String         \"\\n\"     5     27 RightParen     5     28 Semicolon     6      1 End_of_input  ```** |\n    | Test Case 3:  ``` /*   All lexical tokens - not syntactically correct, but that will   have to wait until syntax analysis  */ /* Print   */  print    /* Sub     */  - /* Putc    */  putc     /* Lss     */  < /* If      */  if       /* Gtr     */  > /* Else    */  else     /* Leq     */  <= /* While   */  while    /* Geq     */  >= /* Lbrace  */  {        /* Eq      */  == /* Rbrace  */  }        /* Neq     */  != /* Lparen  */  (        /* And     */  && /* Rparen  */  )        /* Or      */  || /* Uminus  */  -        /* Semi    */  ; /* Not     */  !        /* Comma   */  , /* Mul     */  *        /* Assign  */  = /* Div     */  /        /* Integer */  42 /* Mod     */  %        /* String  */  \"String literal\" /* Add     */  +        /* Ident   */  variable_name /* character literal */  '\\n' /* character literal */  '\\\\' /* character literal */  ' '  ``` | **```     5     16   Keyword_print     5     40   Op_subtract     6     16   Keyword_putc     6     40   Op_less     7     16   Keyword_if     7     40   Op_greater     8     16   Keyword_else     8     40   Op_lessequal     9     16   Keyword_while     9     40   Op_greaterequal    10     16   LeftBrace    10     40   Op_equal    11     16   RightBrace    11     40   Op_notequal    12     16   LeftParen    12     40   Op_and    13     16   RightParen    13     40   Op_or    14     16   Op_subtract    14     40   Semicolon    15     16   Op_not    15     40   Comma    16     16   Op_multiply    16     40   Op_assign    17     16   Op_divide    17     40   Integer             42    18     16   Op_mod    18     40   String          \"String literal\"    19     16   Op_add    19     40   Identifier      variable_name    20     26   Integer             10    21     26   Integer             92    22     26   Integer             32    23      1   End_of_input  ```** |\n    | Test Case 4:  ``` /*** test printing, embedded \\n and comments with lots of '*' ***/ print(42); print(\"\\nHello World\\nGood Bye\\nok\\n\"); print(\"Print a slash n - \\\\n.\\n\");  ``` | **```     2      1 Keyword_print     2      6 LeftParen     2      7 Integer            42     2      9 RightParen     2     10 Semicolon     3      1 Keyword_print     3      6 LeftParen     3      7 String          \"\\nHello World\\nGood Bye\\nok\\n\"     3     38 RightParen     3     39 Semicolon     4      1 Keyword_print     4      6 LeftParen     4      7 String          \"Print a slash n - \\\\n.\\n\"     4     33 RightParen     4     34 Semicolon     5      1 End_of_input  ```** |\n\nAdditional examples\n\nYour solution should pass all the test cases above and the additional tests found **Here**.\n\nReference\n\nThe C and Python versions can be considered reference implementations.\n\nRelated Tasks\n\n* Syntax Analyzer task\n* Code Generator task\n* Virtual Machine Interpreter task\n* AST Interpreter task\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\nThis is more complicated than strictly necessary for this task. It is set up to be easily adapted to do syntax analysis.\n\n(Note: there are several bogus comments added solely to help with syntax highlighting.)\n\n**Works with**: Rakudo version 2016.08\n\n```\ngrammar tiny_C {\n    rule TOP { ^ <.whitespace>? <tokens> + % <.whitespace> <.whitespace> <eoi> }\n\n    rule whitespace { [ <comment> + % <ws> | <ws> ] }\n\n    token comment    { '/*' ~ '*/' .*? }\n\n    token tokens {\n        [\n        | <operator>   { make $/<operator>.ast   }\n        | <keyword>    { make $/<keyword>.ast    }\n        | <symbol>     { make $/<symbol>.ast     }\n        | <identifier> { make $/<identifier>.ast }\n        | <integer>    { make $/<integer>.ast    }\n        | <char>       { make $/<char>.ast       }\n        | <string>     { make $/<string>.ast     }\n        | <error>\n        ]\n    }\n\n    proto token operator    {*}\n    token operator:sym<*>   { '*'               { make 'Op_multiply'    } }\n    token operator:sym</>   { '/'<!before '*'>  { make 'Op_divide'      } }\n    token operator:sym<%>   { '%'               { make 'Op_mod'         } }\n    token operator:sym<+>   { '+'               { make 'Op_add'         } }\n    token operator:sym<->   { '-'               { make 'Op_subtract'    } }\n    token operator:sym('<='){ '<='              { make 'Op_lessequal'   } }\n    token operator:sym('<') { '<'               { make 'Op_less'        } }\n    token operator:sym('>='){ '>='              { make 'Op_greaterequal'} }\n    token operator:sym('>') { '>'               { make 'Op_greater'     } }\n    token operator:sym<==>  { '=='              { make 'Op_equal'       } }\n    token operator:sym<!=>  { '!='              { make 'Op_notequal'    } }\n    token operator:sym<!>   { '!'               { make 'Op_not'         } }\n    token operator:sym<=>   { '='               { make 'Op_assign'      } }\n    token operator:sym<&&>  { '&&'              { make 'Op_and'         } }\n    token operator:sym<||>  { '||'              { make 'Op_or'          } }\n\n    proto token keyword      {*}\n    token keyword:sym<if>    { 'if'    { make 'Keyword_if'    } }\n    token keyword:sym<else>  { 'else'  { make 'Keyword_else'  } }\n    token keyword:sym<putc>  { 'putc'  { make 'Keyword_putc'  } }\n    token keyword:sym<while> { 'while' { make 'Keyword_while' } }\n    token keyword:sym<print> { 'print' { make 'Keyword_print' } }\n\n    proto token symbol  {*}\n    token symbol:sym<(> { '(' { make 'LeftParen'  } }\n    token symbol:sym<)> { ')' { make 'RightParen' } }\n    token symbol:sym<{> { '{' { make 'LeftBrace'  } }\n    token symbol:sym<}> { '}' { make 'RightBrace' } }\n    token symbol:sym<;> { ';' { make 'Semicolon'   } }\n    token symbol:sym<,> { ',' { make 'Comma'       } }\n\n    token identifier { <[_A..Za..z]><[_A..Za..z0..9]>* { make 'Identifier ' ~ $/ } }\n    token integer    { <[0..9]>+                       { make 'Integer '    ~ $/ } }\n\n    token char {\n        '\\'' [<-[']> | '\\n' | '\\\\\\\\'] '\\''\n        { make 'Char_Literal ' ~ $/.subst(\"\\\\n\", \"\\n\").substr(1, *-1).ord }\n    }\n\n    token string {\n        '\"' <-[\"\\n]>* '\"' #'\n        {\n            make 'String ' ~ $/;\n            note 'Error: Unknown escape sequence.' and exit if (~$/ ~~ m:r/ <!after <[\\\\]>>[\\\\<-[n\\\\]>]<!before <[\\\\]>> /);\n        }\n    }\n\n    token eoi { $ { make 'End_of_input' } }\n\n    token error {\n        | '\\'''\\''                   { note 'Error: Empty character constant.' and exit }\n        | '\\'' <-[']> ** {2..*} '\\'' { note 'Error: Multi-character constant.' and exit }\n        | '/*' <-[*]>* $             { note 'Error: End-of-file in comment.'   and exit }\n        | '\"' <-[\"]>* $              { note 'Error: End-of-file in string.'    and exit }\n        | '\"' <-[\"]>*? \\n            { note 'Error: End of line in string.'    and exit } #'\n    }\n}\n\nsub parse_it ( $c_code ) {\n    my $l;\n    my @pos = gather for $c_code.lines>>.chars.kv -> $line, $v {\n        take [ $line + 1, $_ ] for 1 .. ($v+1); # v+1 for newline\n        $l = $line+2;\n    }\n    @pos.push: [ $l, 1 ]; # capture eoi\n\n    for flat $c_code<tokens>.list, $c_code<eoi> -> $m {\n        say join \"\\t\", @pos[$m.from].fmt('%3d'), $m.ast;\n    }\n}\n\nmy $tokenizer = tiny_C.parse(@*ARGS[0].IO.slurp);\nparse_it( $tokenizer );\n\n```\n\nOutput  —  test case 3:\n\n```\n  5  16 Keyword_print\n  5  40 Op_subtract\n  6  16 Keyword_putc\n  6  40 Op_less\n  7  16 Keyword_if\n  7  40 Op_greater\n  8  16 Keyword_else\n  8  40 Op_lessequal\n  9  16 Keyword_while\n  9  40 Op_greaterequal\n 10  16 LeftBrace\n 10  40 Op_equal\n 11  16 RightBrace\n 11  40 Op_notequal\n 12  16 LeftParen\n 12  40 Op_and\n 13  16 RightParen\n 13  40 Op_or\n 14  16 Op_subtract\n 14  40 Semicolon\n 15  16 Op_not\n 15  40 Comma\n 16  16 Op_multiply\n 16  40 Op_assign\n 17  16 Op_divide\n 17  40 Integer 42\n 18  16 Op_mod\n 18  40 String \"String literal\"\n 19  16 Op_add\n 19  40\tIdentifier variable_name\n 20  26\tChar_Literal 10\n 21  26\tChar_Literal 92\n 22  26\tChar_Literal 32\n 23   1\tEnd_of_input\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n**Introduction**\n  \n  \nMany programming languages allow file inclusion, so that for example, standard declarations or code-snippets can be stored in a separate source file and be included into the programs that require them at compile-time, without the need for cut-and-paste.\n  \n  \nProbably the C pre-processor is the most well-known example.\n  \n  \nThe purpose of this task is to demonstrate how a file inclusion pre-processor could be implemented in your language, for your language. This does not mean to imply that your language needs a file inclusion pre-processor - many languages don't have such a facility.\n  \nOther languages, on the other hand do have file inclusion, e.g.: C, COBOL, PL/1.\n  \n  \nThe distinction between compiled and interpreted languages should be irrelevent - this is a specialised text processing exercise - reading a source file and producing a modified source file that aldo contains the contents of one or more other files.\n  \n  \nHopefully, the solutions to this task will enable the file inclusion facilities of the languages to be compared, even for languages that don't need such facilities because they have sophisticated equivalents.\n  \n  \n**The pre-processor**\n  \n  \nCreate a simple pre-processor that implements file-inclusion for your language.\n  \n  \nThe pre-processor need not check the validity of the resultant source. The pre-processor's job is purely to insert te specified files into the source at the required points. Whether the result is syntacticly valid or not is a matter for the compiler/interpreter when it is presented with the source.\n  \n  \nThe syntax accepted for your pre-processor should be as per the standard for your language, should your language have such a facility.\nE.g. for C the pre-processor must recognise and handle \"#include\" directives. For PL/1, %include statements would be processed and for COBOL, COPY statements, and so on.\n  \n  \nIf your language does not have a standard facility for file-inclusion, implement that used by a popular compiler/interpreter for the language.\n  \nIf there is no such feature, either use the C style #include directive or choose something of your own invention, e.g., #include would be problematic for languages where # introduces a comment.\n  \n  \nState the syntax expected and any limitations, including whether nested includes are supported and if so, how deep the nesting can be.\n  \n  \n**Minimum requirements**\n  \n  \nAs a minimum, your pre-procdessor must be able to process a source file (read from a file or standard input, as you prefer) and generate another source file (written to a file or standard output, as you prefer). The file-inclusion directives in the source should be replaced by the contents of the specified files. Implementing nested file inclusion directives (i.e., if an included file contains another file-inclusion directive) is optional.\n  \n  \nPre-processors for some languages offer additional facilities, such as macro expansion and conditional compilation. Your pre-processor need not implement such things.\n  \n  \n**Notes**\n\n* implementors: The Task is about implementing a pre-processor for your language, not just describing it's features. Just as the task Calculating the value of e is not about using your language's in-built exp function but showing how e could be calculated, this is about showing how file inclusion could be implemented - even if the compiler/interpreter you are using already has such a facility.\n* the pre-processors on this page are supplied as-is, with no warranty - use at your own peril : )\n\nSee Also\n\n* include a file"}, {"role": "assistant", "content": "A file pre-processor is very nearly pointless for Raku. Raku is nominally an interpreted language; in actuality, it does single pass, just-in-time compilation on the fly as it loads the file. For libraries and constants (or semi constant variables) there is a robust built-in library (module) include system for code that can be pre-compiled and used on demand. `use some-library;` to import any objects exported by the module.\n\nThat's great for code references and constants, but isn't really intended for text inclusion of external files. Since the text file can not be pre-compiled, there isn't much point to having such a system. (For code at least, there are many different templating system modules for text templates; primarily, though not exclusively used for on-the-fly generation of dynamic HTML / XML documents.) One of those could certainly be bent into doing something like what this task is asking for, but are probably both over- and under-powered for the job.\n\n1. they are mostly intended for text, not code.\n2. they tend to be more geared toward inserting the content of a variable rather than the content of a file, although that could be subverted pretty easily.\n\nSo in Raku, there isn't a readily available system to do this, there isn't much point, and it's probably a bad idea...\n\nAh well, that never stopped us before.\n\nA Raku script to do source filtering / preprocessing: save it and call it 'include'\n\n```\nunit sub MAIN ($file-name);\nmy $file = slurp $file-name;\nput $file.=subst(/[^^|['{{' \\s*]] '#include' \\s+ (\\S+) \\s* '}}'?/, {run(«$*EXECUTABLE-NAME $*PROGRAM-NAME $0», :out).out.slurp(:close).trim}, :g);\n\n```\n\nThis will find: any line starting with '#include' followed by a (absolute or relative) path to a file, or #include ./path/to/file.name enclosed in double curly brackets anywhere in the file.\n\nIt will replace the #include notation by the contents of the file referenced, will follow nested #includes arbitrarily deeply, and echo the processed file to STDOUT.\n\nLet's test it out. Here is a test script and a bunch of include files.\n\nTop level named... whatever, let's call it 'preprocess.raku'\n\n```\n# Top level test script file for #include Rosettacode\n# 'Compiler/Simple file inclusion pre processor' task\n\n# some code\n\nsay .³ for ^10;\n\n#include ./include1.file\n\n```\n\ninclude1.file\n\n```\n# included #include1 file >1>\n# test to ensure it only tries to execute #include of the right format\n\n# more code\nsay .³³ for ^10;\n# and more comments\n\n#include    ./include2.file    # comments ok at end of include line\n# <1<\n```\n\ninclude2.file\n\n```\n# nested #include2.file >2>\nsay \"Test for an nested include inside a line: {{ #include ./include3.file }}\";\n# pointless but why not? <2<\n```\n\ninclude3.file\n\n```\n>3> Yep, it works! <3<\n\n```\n\nInvoke at a command line:\n\n`raku include preprocess.raku`\n\nOutput:\n\n```\n# Top level test script file for #include Rosettacode\n# 'Compiler/Simple file inclusion pre processor' task\n\n# some code\n\nsay .³ for ^10;\n\n# included #include1 file >1>\n# test to ensure it only tries to execute #include of the right format\n\n# more code\nsay .³³ for ^10;\n# and more comments\n\n# nested #include2.file >2>\nsay \"Test for an nested include inside a line: >3> Yep, it works! <3<\";\n# pointless but why not? <2<# comments ok at end of include line\n# <1<\n\n```\n\nYou can either redirect that into a file, or just pass it back into the compiler to execute it:\n\n`raku include preprocess.raku | raku`\n\nOutput:\n\n```\n0\n1\n8\n27\n64\n125\n216\n343\n512\n729\n0\n1\n8589934592\n5559060566555523\n73786976294838206464\n116415321826934814453125\n47751966659678405306351616\n7730993719707444524137094407\n633825300114114700748351602688\n30903154382632612361920641803529\nTest for an nested include inside a line: >3> Yep, it works! <3<\n```\n\nNote that this is not very robust, (it's 3 lines of code, what do you expect?) but it satisfies the task requirements as far as I can tell."}]}
{"messages": [{"role": "user", "content": "**Verifying Syntax**   \nA Syntax Analyzer that verifies a token stream,   \noutputs a string \"true\" if the token stream matches the grammar requirement,   \noutputs a string \"false\" if the token stream does not match the grammar.\n\n**Task**   \nThe program reads input from a file of token stream,   \nreads it and outputs a string \"true\" if the token stream matches the grammar,   \noutputs a string \"false\" and error messages if the token stream does not match the grammar,   \nbased on the grammar below. The grammar is written in Extended Backus-Naur Form (EBNF).\n\n**Grammar**\n\n```\nstmt         =         expr ; \n\nexpr         =         expr_level_2; \nexpr_level_2 =         expr_level_3 {\"or\" expr_level_3} ; \nexpr_level_3 =         expr_level_4 {\"and\" expr_level_4} ; \nexpr_level_4 = [\"not\"] expr_level_5 [('=' | '<') expr_level_5] ; \nexpr_level_5 =         expr_level_6 {('+' | '-') expr_level_6} ; \nexpr_level_6 =         primary      {('*' | '/') primary} ; \n\nprimary      =         Identifier\n                     | Integer\n                     | '(' expr ')'\n                     | \"true\"\n                     | \"false\"\n                     ;\nInteger      =         Digit {Digit};\n\nIdentifier   =         Letter {Letter | Digit | '_'};\n\nDigit        =         \"0\" | \"1\" | \"2\" | \"3\" | \"4\" | \"5\" | \"6\" | \"7\" | \"8\" | \"9\" ;\n\nLetter       =         \"a\" | \"b\" | \"c\" | \"d\" | \"e\" | \"f\" | \"g\" | \"h\" | \"i\" | \"j\" \n                     | \"k\" | \"l\" | \"m\" | \"n\" | \"o\" | \"p\" | \"q\" | \"r\" | \"s\" | \"t\" \n                     | \"u\" | \"v\" | \"w\" | \"x\" | \"y\" | \"z\" | \"A\" | \"B\" | \"C\" | \"D\" \n                     | \"E\" | \"F\" | \"G\" | \"H\" | \"I\" | \"J\" | \"K\" | \"L\" | \"M\" | \"N\" \n                     | \"O\" | \"P\" | \"Q\" | \"R\" | \"S\" | \"T\" | \"U\" | \"V\" | \"W\" | \"X\" \n                     | \"Y\" | \"Z\" ;\n\n```"}, {"role": "assistant", "content": "Format of task grammar is changed from EBNF to ABNF to cater for the Grammar::ABNF module and testing data is taken from the Perl entry.\n\n```\n# 20200511 Raku programming solution\n\nuse Grammar::ABNF;\n\ngrammar G is Grammar::ABNF { token CRLF { \"\\n\" } };\n\nmy $g = G.generate(Q:to<RULES>\nstmt         =          expr\nexpr         =          expr_level_2\nexpr_level_2 =          expr_level_3 *(      \" or \"       expr_level_3 )\nexpr_level_3 =          expr_level_4 *(      \" and \"      expr_level_4 )\nexpr_level_4 = [\"not \"] expr_level_5  [ [ \" = \" / \" < \" ] expr_level_5 ]\nexpr_level_5 =          expr_level_6 *( [ \" + \" / \" - \" ] expr_level_6 )\nexpr_level_6 =          primary      *( [ \" * \" / \" / \" ] primary )\nInteger      =  Digit  *( Digit )\nIdentifier   =  Letter *( Letter / Digit / \"_\" )\nprimary      =  Identifier / Integer / \"(\" expr \")\" / \" true \" / \" false \"\nDigit        =  \"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\"\nLetter       =  \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\" / \"g\" / \"h\" / \"i\" / \"j\" \n               / \"k\" / \"l\" / \"m\" / \"n\" / \"o\" / \"p\" / \"q\" / \"r\" / \"s\" / \"t\"\n               / \"u\" / \"v\" / \"w\" / \"x\" / \"y\" / \"z\" / \"A\" / \"B\" / \"C\" / \"D\"\n               / \"E\" / \"F\" / \"G\" / \"H\" / \"I\" / \"J\" / \"K\" / \"L\" / \"M\" / \"N\"\n               / \"O\" / \"P\" / \"Q\" / \"R\" / \"S\" / \"T\" / \"U\" / \"V\" / \"W\" / \"X\"   \n               / \"Y\" / \"Z\"\nRULES\n);\n\nmy \\DATA = Q:to<DATA>;\n3 + not 5\n3 + (not 5)\n(42 + 3\n(42 + 3 syntax_error\nnot 3 < 4 or (true or 3 / 4 + 8 * 5 - 5 * 2 < 56) and 4 * 3 < 12 or not true\nand 3 < 2\nnot 7 < 2\n2 < 3 < 4\n2 < foobar - 3 < 4\n2 < foobar and 3 < 4\n4 * (32 - 16) + 9 = 73\n235 76 + 1\na + b = not c and false\na + b = (not c) and false\na + b = (not c and false)\nab_c / bd2 or < e_f7\ng not = h\ni++\nj & k\nl or _m\nUPPER_cAsE_aNd_letter_and_12345_test\nDATA\n\nsay $g.parse($_).Bool, \"\\t\", $_ for DATA.lines\n\n```\n\nOutput:\n\n```\nFalse   3 + not 5\nTrue    3 + (not 5)\nFalse   (42 + 3\nFalse   (42 + 3 syntax_error\nTrue    not 3 < 4 or (true or 3 / 4 + 8 * 5 - 5 * 2 < 56) and 4 * 3 < 12 or not true\nFalse   and 3 < 2\nTrue    not 7 < 2\nFalse   2 < 3 < 4\nFalse   2 < foobar - 3 < 4\nTrue    2 < foobar and 3 < 4\nTrue    4 * (32 - 16) + 9 = 73\nFalse   235 76 + 1\nFalse   a + b = not c and false\nTrue    a + b = (not c) and false\nTrue    a + b = (not c and false)\nFalse   ab_c / bd2 or < e_f7\nFalse   g not = h\nFalse   i++\nFalse   j & k\nFalse   l or _m\nTrue    UPPER_cAsE_aNd_letter_and_12345_test\n\n```"}]}
{"messages": [{"role": "user", "content": "Virtual Machine Interpreter\n\nA virtual machine implements a computer in software.\n\nWrite a virtual machine interpreter. This interpreter should be able to run virtual\nassembly language programs created via the task. This is a\nbyte-coded, 32-bit word stack based virtual machine.\n\nThe program should read input from a file and/or stdin, and write output to a file and/or\nstdout.\n\nInput format\n\nGiven the following program:\n\n```\ncount = 1;\nwhile (count < 10) {\n    print(\"count is: \", count, \"\\n\");\n    count = count + 1;\n}\n\n```\n\nThe output from the Code generator is a virtual assembly code program:\n\n| Output from gen, input to VM |\n| --- |\n| **``` Datasize: 1 Strings: 2 \"count is: \" \"\\n\"     0 push  1     5 store [0]    10 fetch [0]    15 push  10    20 lt    21 jz     (43) 65    26 push  0    31 prts    32 fetch [0]    37 prti    38 push  1    43 prts    44 fetch [0]    49 push  1    54 add    55 store [0]    60 jmp    (-51) 10    65 halt ```** |\n\nThe first line of the input specifies the datasize required and the number of constant\nstrings, in the order that they are reference via the code.\n\nThe data can be stored in a separate array, or the data can be stored at the beginning of\nthe stack. Data is addressed starting at 0. If there are 3 variables, the 3rd one if\nreferenced at address 2.\n\nIf there are one or more constant strings, they come next. The code refers to these\nstrings by their index. The index starts at 0. So if there are 3 strings, and the code\nwants to reference the 3rd string, 2 will be used.\n\nNext comes the actual virtual assembly code. The first number is the code address of that\ninstruction. After that is the instruction mnemonic, followed by optional operands,\ndepending on the instruction.\n\nRegisters\n\nsp:\n\n```\n   the stack pointer - points to the next top of stack.  The stack is a 32-bit integer\n   array.\n\n```\n\npc:\n\n```\n   the program counter - points to the current instruction to be performed.  The code is an\n   array of bytes.\n\n```\n\nData:\n\n```\n   data\n   string pool\n\n```\n\nInstructions\n\nEach instruction is one byte. The following instructions also have a 32-bit integer\noperand:\n\n```\nfetch [index]\n\n```\n\nwhere index is an index into the data array.\n\n```\nstore [index]\n\n```\n\nwhere index is an index into the data array.\n\n```\npush n\n\n```\n\nwhere value is a 32-bit integer that will be pushed onto the stack.\n\n```\njmp (n) addr\n\n```\n\nwhere (n) is a 32-bit integer specifying the distance between the current location and the\ndesired location. addr is an unsigned value of the actual code address.\n\n```\njz (n) addr\n\n```\n\nwhere (n) is a 32-bit integer specifying the distance between the current location and the\ndesired location. addr is an unsigned value of the actual code address.\n\nThe following instructions do not have an operand. They perform their operation directly\nagainst the stack:\n\nFor the following instructions, the operation is performed against the top two entries in\nthe stack:\n\n```\nadd\nsub\nmul\ndiv\nmod\nlt\ngt\nle\nge\neq\nne\nand\nor\n\n```\n\nFor the following instructions, the operation is performed against the top entry in the\nstack:\n\n```\nneg\nnot\n\n```\n\nPrint the word at stack top as a character.\n\n```\nprtc\n\n```\n\nPrint the word at stack top as an integer.\n\n```\nprti\n\n```\n\nStack top points to an index into the string pool. Print that entry.\n\n```\nprts\n\n```\n\nUnconditional stop.\n\n```\nhalt\n\n```\n\nA simple example virtual machine\n\n```\ndef run_vm(data_size)\n    int stack[data_size + 1000]\n    set stack[0..data_size - 1] to 0\n    int pc = 0\n    while True:\n        op = code[pc]\n        pc += 1\n\n        if op == FETCH:\n            stack.append(stack[bytes_to_int(code[pc:pc+word_size])[0]]);\n            pc += word_size\n        elif op == STORE:\n            stack[bytes_to_int(code[pc:pc+word_size])[0]] = stack.pop();\n            pc += word_size\n        elif op == PUSH:\n            stack.append(bytes_to_int(code[pc:pc+word_size])[0]);\n            pc += word_size\n        elif op == ADD:   stack[-2] += stack[-1]; stack.pop()\n        elif op == SUB:   stack[-2] -= stack[-1]; stack.pop()\n        elif op == MUL:   stack[-2] *= stack[-1]; stack.pop()\n        elif op == DIV:   stack[-2] /= stack[-1]; stack.pop()\n        elif op == MOD:   stack[-2] %= stack[-1]; stack.pop()\n        elif op == LT:    stack[-2] = stack[-2] <  stack[-1]; stack.pop()\n        elif op == GT:    stack[-2] = stack[-2] >  stack[-1]; stack.pop()\n        elif op == LE:    stack[-2] = stack[-2] <= stack[-1]; stack.pop()\n        elif op == GE:    stack[-2] = stack[-2] >= stack[-1]; stack.pop()\n        elif op == EQ:    stack[-2] = stack[-2] == stack[-1]; stack.pop()\n        elif op == NE:    stack[-2] = stack[-2] != stack[-1]; stack.pop()\n        elif op == AND:   stack[-2] = stack[-2] and stack[-1]; stack.pop()\n        elif op == OR:    stack[-2] = stack[-2] or  stack[-1]; stack.pop()\n        elif op == NEG:   stack[-1] = -stack[-1]\n        elif op == NOT:   stack[-1] = not stack[-1]\n        elif op == JMP:   pc += bytes_to_int(code[pc:pc+word_size])[0]\n        elif op == JZ:    if stack.pop() then pc += word_size else pc += bytes_to_int(code[pc:pc+word_size])[0]\n        elif op == PRTC:  print stack[-1] as a character; stack.pop()\n        elif op == PRTS:  print the constant string referred to by stack[-1]; stack.pop()\n        elif op == PRTI:  print stack[-1] as an integer; stack.pop()\n        elif op == HALT:  break\n\n```\n\nAdditional examples\n\nYour solution should pass all the test cases above and the additional tests found **Here**.\n\nReference\n\nThe C and Python versions can be considered reference implementations.\n\nRelated Tasks\n\n* Lexical Analyzer task\n* Syntax Analyzer task\n* Code Generator task\n* AST Interpreter task\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\nNon-standard size of instructions (not byte-coded, 'Datasize' is 3 not 1) required adjusting the jump offsets.\n\nNOTE: I don't think you are allowed to change the jump offsets.\nThey come from another program from another company from another planet from another galaxy.\n\nWIP: discovered 'P5pack' module, this may allow for completing the task properly, using correct offsets\n\n**Translation of**: Perl\n\n```\nmy @CODE = q:to/END/.lines;\nDatasize: 3 Strings: 2\n\"count is: \"\n\"\\n\"\n    0 push  1\n    5 store [0]\n   10 fetch [0]\n   15 push  10\n   20 lt\n   21 jz     (68) 65    # jump value adjusted\n   26 push  0\n   31 prts\n   32 fetch [0]\n   37 prti\n   38 push  1\n   43 prts\n   44 fetch [0]\n   49 push  1\n   54 add\n   55 store [0]\n   60 jmp    (-87) 10   # jump value adjusted\n   65 halt\nEND\n\nmy (@stack, @strings, @data, $memory);\nmy $pc = 0;\n\n(@CODE.shift) ~~ /'Datasize:' \\s+ (\\d+) \\s+ 'Strings:' \\s+ (\\d+)/ or die \"bad header\";\nmy $w = $0; # 'wordsize' of op-codes and 'width' of data values\n@strings.push: (my $s = @CODE.shift) eq '\"\\n\"' ?? \"\\n\" !! $s.subst(/'\"'/, '', :g) for 1..$1;\n\nsub value { substr($memory, ($pc += $w) - $w, $w).trim }\n\nmy %ops = (\n  'no-op' => sub { },\n  'add'   => sub { @stack[*-2]  +=   @stack.pop },\n  'sub'   => sub { @stack[*-2]  -=   @stack.pop },\n  'mul'   => sub { @stack[*-2]  *=   @stack.pop },\n  'div'   => sub { @stack[*-2]  /=   @stack.pop },\n  'mod'   => sub { @stack[*-2]  %=   @stack.pop },\n  'neg'   => sub { @stack[*-1]   = - @stack[*-1] },\n  'and'   => sub { @stack[*-2] &&=   @stack[*-1]; @stack.pop },\n  'or'    => sub { @stack[*-2] ||=   @stack[*-1]; @stack.pop },\n  'not'   => sub { @stack[*-1]   =   @stack[*-1]               ?? 0 !! 1 },\n  'lt'    => sub { @stack[*-1]   =   @stack[*-2] <  @stack.pop ?? 1 !! 0 },\n  'gt'    => sub { @stack[*-1]   =   @stack[*-2] >  @stack.pop ?? 1 !! 0 },\n  'le'    => sub { @stack[*-1]   =   @stack[*-2] <= @stack.pop ?? 1 !! 0 },\n  'ge'    => sub { @stack[*-1]   =   @stack[*-2] >= @stack.pop ?? 1 !! 0 },\n  'ne'    => sub { @stack[*-1]   =   @stack[*-2] != @stack.pop ?? 1 !! 0 },\n  'eq'    => sub { @stack[*-1]   =   @stack[*-2] == @stack.pop ?? 1 !! 0 },\n  'store' => sub { @data[&value] =   @stack.pop },\n  'fetch' => sub { @stack.push:      @data[&value] // 0 },\n  'push'  => sub { @stack.push:      value() },\n  'jmp'   => sub { $pc += value() - $w },\n  'jz'    => sub { $pc += @stack.pop ?? $w !! value() - $w },\n  'prts'  => sub { print @strings[@stack.pop] },\n  'prti'  => sub { print @stack.pop },\n  'prtc'  => sub { print chr @stack.pop },\n  'halt'  => sub { exit }\n);\n\nmy %op2n = %ops.keys.sort Z=> 0..*;\nmy %n2op = %op2n.invert;\n%n2op{''} = 'no-op';\n\nfor @CODE -> $_ {\n    next unless /\\w/;\n    /^ \\s* \\d+ \\s+ (\\w+)/ or die \"bad line $_\";\n    $memory ~= %op2n{$0}.fmt(\"%{$w}d\");\n    /'(' ('-'?\\d+) ')' | (\\d+) ']'? $/;\n    $memory ~= $0 ?? $0.fmt(\"%{$w}d\") !! ' ' x $w;\n}\n\nloop {\n    my $opcode = substr($memory, $pc, $w).trim;\n    $pc += $w;\n    %ops{%n2op{ $opcode }}();\n}\n\n```\n\nOutput:\n\n```\ncount is: 1\ncount is: 2\ncount is: 3\ncount is: 4\ncount is: 5\ncount is: 6\ncount is: 7\ncount is: 8\ncount is: 9\n```"}]}
{"messages": [{"role": "user", "content": "Find the composite numbers **k** in base 10, that have no single digit prime factors and whose prime factors are all a substring of **k**.\n\nTask\n\n* Find and show here, on this page, the first ten elements of the sequence.\n\nStretch\n\n* Find and show the next ten elements."}, {"role": "assistant", "content": "```\nuse Prime::Factor;\nuse Lingua::EN::Numbers;\n\nput (2..∞).hyper(:5000batch).map( {\n    next if (1 < $_ gcd 210) || .is-prime || any .&prime-factors.map: -> $n { !.contains: $n };\n    $_\n} )[^20].batch(10)».&comma».fmt(\"%10s\").join: \"\\n\";\n\n```\n\nOutput:\n\n```\n    15,317     59,177     83,731    119,911    183,347    192,413  1,819,231  2,111,317  2,237,411  3,129,361\n 5,526,173 11,610,313 13,436,683 13,731,373 13,737,841 13,831,103 15,813,251 17,692,313 19,173,071 28,118,827\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a compound data type:\n\n```\n  Point(x,y) \n\n```\n\nA compound data type is one that holds multiple independent values.\n\nRelated task\n\n* Enumeration\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #24 \"Seoul\"\n\n### Array\n\n```\nmy @point = 3, 8;\n\nmy Int @point = 3, 8; # or constrain to integer elements\n```\n\n### Hash\n\n```\nmy %point = x => 3, y => 8;\n\nmy Int %point = x => 3, y => 8; # or constrain the hash to have integer values\n```\n\n### Class instance\n\n```\nclass Point { has Real ($.x, $.y) is rw; }\nmy Point $point .= new: x => 3, y => 8;\n```\n\n### Set\n\n```\nmy $s1 = set <a b c d>; # order is not preserved\nmy $s2 = set <c d e f>;\nsay $s1 (&) $s2; # OUTPUT«set(c, e)»\nsay $s1 ∩ $s2; # we also do Unicode\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show here when the concatenation of two primes   (**p1**,  **p2**)   shown in base ten is also prime,   where   **p1,   p2  <  100**."}, {"role": "assistant", "content": "Inefficient, but for a limit of 100, who cares?\n\n```\nmy @p = ^1e2 .grep: *.is-prime;\n\nsay display ( @p X~ @p ).grep( *.is-prime ).unique.sort( +* ); \n\nsub display ($list, :$cols = 10, :$fmt = '%6d', :$title = \"{+$list} matching:\\n\") {\n    cache $list;\n    $title ~ $list.batch($cols)».fmt($fmt).join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\n128 matching:\n    23     37     53     73    113    137    173    193    197    211\n   223    229    233    241    271    283    293    311    313    317\n   331    337    347    353    359    367    373    379    383    389\n   397    433    523    541    547    571    593    613    617    673\n   677    719    733    743    761    773    797    977   1117   1123\n  1129   1153   1171   1319   1361   1367   1373   1723   1741   1747\n  1753   1759   1783   1789   1913   1931   1973   1979   1997   2311\n  2341   2347   2371   2383   2389   2917   2953   2971   3119   3137\n  3167   3719   3761   3767   3779   3797   4111   4129   4153   4159\n  4337   4373   4397   4723   4729   4759   4783   4789   5323   5347\n  5923   5953   6113   6131   6143   6173   6197   6719   6737   6761\n  6779   7129   7159   7331   7919   7937   8311   8317   8329   8353\n  8389   8923   8929   8941   8971   9719   9743   9767\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nUsing either native language concurrency syntax or freely available libraries, write a program to display the strings \"Enjoy\" \"Rosetta\" \"Code\", one string per line, in random order.\n\nConcurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.9\n\n```\nmy @words = <Enjoy Rosetta Code>;\n@words.race(:batch(1)).map: { sleep rand; say $_ };\n\n```\n\nOutput:\n\n```\nCode\nRosetta\nEnjoy\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nList the *conditional structures* offered by a programming language. See Wikipedia: conditionals for descriptions.\n\nCommon conditional structures include **if-then-else** and **switch**.\n\nLess common are **arithmetic if**, **ternary operator** and **Hash-based conditionals**.\n\n***Arithmetic if** allows tight control over computed gotos, which optimizers have a hard time to figure out.*"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### if/else\n\nif, else, elsif, unless, and given work much as they do in Perl 5, with the following differences:\n\n* All the parentheses are now optional.\n* unless no longer permits elsif or else blocks.\n* If the block of an if, elsif, or unless has a nonzero arity, the value of the conditional expression is used as an argument to the block:\n\n  ```\n  if won() -> $prize {\n      say \"You won $prize.\";\n  }\n  ```\n\n  If an else block has a nonzero arity, it receives the value of the condition tested by the last if or elsif.\n\n### given/when\n\nSwitch structures are done by topicalization and by smartmatching in Raku. They are somewhat orthogonal, you can use a given block without when, and vice versa. But the typical use is:\n\n```\ngiven lc prompt(\"Done? \") {\n    when 'yes' { return }\n    when 'no'  { next }\n    default    { say \"Please answer either yes or no.\" }\n}\n```\n\nwhen blocks are allowed in any block that topicalizes $\\_, including a\nfor loop (assuming one of its loop variables is bound to $\\_)\nor the body of a method (if you have declared the invocant as $\\_).\" See more at: https://docs.raku.org/language/control#index-entry-switch\\_(given)\n\nThere are also statement modifier forms of all of the above.\n\n### Ternary operator\n\nThe ternary operator looks like this:\n\n```\n$expression ?? do_something !! do_fallback\n```\n\n### Other short-circuiting operators\n\nand, or, &&, || and // work as in Perl 5."}]}
{"messages": [{"role": "user", "content": "Task\n:   Create a program that can take a Latin verb and conjugate it, displaying in the following order:\n\n```\n1st person singular\n2nd person singular\n3rd person singular\n1st person plural\n2nd person plural\n3rd person plural\n\n```\n\n* Each should be on its own line.\n* Have at least one example from each of the 4 conjugations.\n* Irregular verbs are not required.\n* Translation into English is optional.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet\n\nSee also\n\n* Wikipedia: Latin conjugation."}, {"role": "assistant", "content": "**Translation of**: Julia\n\n```\nfor <amāre dare> -> $infinitive {\n    say \"\\nPresent active indicative conjugation of infinitive $infinitive.\";\n    my $verb = ($infinitive ~~ /^ (\\w+) ['a'|'ā'] 're' $/)[0];\n    say $verb ?? (conjugate $verb) !! \"Sorry, don't know how to conjugate $infinitive\"\n}\n\nsub conjugate ($verb) { ($verb X~ <ō ās at āmus ātis ant>).join: \"\\n\" }\n\n```\n\nOutput:\n\n```\nPresent active indicative conjugation of infinitive amāre.\namō\namās\namat\namāmus\namātis\namant\n\nPresent active indicative conjugation of infinitive dare.\ndō\ndās\ndat\ndāmus\ndātis\ndant\n```"}]}
{"messages": [{"role": "user", "content": "Suppose that a matrix \n\nM\n{\\displaystyle {\\displaystyle M}}\n contains complex numbers. Then the conjugate transpose of \n\nM\n{\\displaystyle {\\displaystyle M}}\n is a matrix \n\nM\n\nH\n{\\displaystyle {\\displaystyle M^{H}}}\n containing the complex conjugates of the matrix transposition of \n\nM\n{\\displaystyle {\\displaystyle M}}\n.\n\n:   :   :   (\n\n            M\n\n            H\n\n            )\n\n            j\n            i\n            =\n\n            M\n\n            i\n            j\n            ¯\n            {\\displaystyle {\\displaystyle (M^{H})\\_{ji}={\\overline {M\\_{ij}}}}}\n\nThis means that row \n\nj\n{\\displaystyle {\\displaystyle j}}\n, column \n\ni\n{\\displaystyle {\\displaystyle i}}\n of the conjugate transpose equals the\n  \ncomplex conjugate of row \n\ni\n{\\displaystyle {\\displaystyle i}}\n, column \n\nj\n{\\displaystyle {\\displaystyle j}}\n of the original matrix.\n\nIn the next list, \n\nM\n{\\displaystyle {\\displaystyle M}}\n must also be a square matrix.\n\n* A Hermitian matrix equals its own conjugate transpose: \n\n  M\n\n  H\n  =\n  M\n  {\\displaystyle {\\displaystyle M^{H}=M}}\n  .\n* A normal matrix is commutative in multiplication with its conjugate transpose: \n\n  M\n\n  H\n  M\n  =\n  M\n\n  M\n\n  H\n  {\\displaystyle {\\displaystyle M^{H}M=MM^{H}}}\n  .\n* A unitary matrix has its inverse equal to its conjugate transpose: \n\n  M\n\n  H\n  =\n\n  M\n\n  −\n  1\n  {\\displaystyle {\\displaystyle M^{H}=M^{-1}}}\n  .   \n   This is true iff \n\n  M\n\n  H\n  M\n  =\n\n  I\n\n  n\n  {\\displaystyle {\\displaystyle M^{H}M=I\\_{n}}}\n   and iff \n\n  M\n\n  M\n\n  H\n  =\n\n  I\n\n  n\n  {\\displaystyle {\\displaystyle MM^{H}=I\\_{n}}}\n  , where \n\n  I\n\n  n\n  {\\displaystyle {\\displaystyle I\\_{n}}}\n   is the identity matrix.\n\nTask\n\nGiven some matrix of complex numbers, find its conjugate transpose.\n\nAlso determine if the matrix is a:\n\n:   :   * Hermitian matrix,\n        * normal matrix, or\n        * unitary matrix.\n\nSee also\n\n* MathWorld entry: conjugate transpose\n* MathWorld entry: Hermitian matrix\n* MathWorld entry: normal matrix\n* MathWorld entry: unitary matrix"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015-12-13\n\n```\nfor [ # Test Matrices\n       [   1, 1+i, 2i],\n       [ 1-i,   5, -3],\n       [0-2i,  -3,  0]\n    ],\n    [\n       [1, 1, 0],\n       [0, 1, 1],\n       [1, 0, 1]\n    ],\n    [\n       [0.707 ,    0.707,  0],\n       [0.707i, 0-0.707i,  0],\n       [0     ,        0,  i]\n    ]\n    -> @m {\n        say \"\\nMatrix:\";\n        @m.&say-it;\n        my @t = @m».conj.&mat-trans;\n        say \"\\nTranspose:\";\n        @t.&say-it;\n        say \"Is Hermitian?\\t{is-Hermitian(@m, @t)}\";\n        say \"Is Normal?\\t{is-Normal(@m, @t)}\";\n        say \"Is Unitary?\\t{is-Unitary(@m, @t)}\";\n    }\n\nsub is-Hermitian (@m, @t, --> Bool) {\n    so @m».Complex eqv @t».Complex\n }\n\nsub is-Normal (@m, @t, --> Bool) {\n    so mat-mult(@m, @t)».Complex eqv mat-mult(@t, @m)».Complex\n}\n\nsub is-Unitary (@m, @t, --> Bool) {\n    so mat-mult(@m, @t, 1e-3)».Complex eqv mat-ident(+@m)».Complex;\n}\n\nsub mat-trans (@m) { map { [ @m[*;$_] ] }, ^@m[0] }\n\nsub mat-ident ($n) { [ map { [ flat 0 xx $_, 1, 0 xx $n - 1 - $_ ] }, ^$n ] }\n\nsub mat-mult (@a, @b, \\ε = 1e-15) {\n    my @p;\n    for ^@a X ^@b[0] -> ($r, $c) {\n        @p[$r][$c] += @a[$r][$_] * @b[$_][$c] for ^@b;\n        @p[$r][$c].=round(ε); # avoid floating point math errors\n    }\n    @p\n}\n\nsub say-it (@array) { $_».fmt(\"%9s\").say for @array }\n\n```\n\nOutput:\n\n```\nMatrix:\n[        1      1+1i      0+2i]\n[     1-1i         5        -3]\n[     0-2i        -3         0]\n\nTranspose:\n[        1      1+1i      0+2i]\n[     1-1i         5        -3]\n[     0-2i        -3         0]\nIs Hermitian?\tTrue\nIs Normal?\tTrue\nIs Unitary?\tFalse\n\nMatrix:\n[        1         1         0]\n[        0         1         1]\n[        1         0         1]\n\nTranspose:\n[        1         0         1]\n[        1         1         0]\n[        0         1         1]\nIs Hermitian?\tFalse\nIs Normal?\tTrue\nIs Unitary?\tFalse\n\nMatrix:\n[    0.707     0.707         0]\n[ 0+0.707i  0-0.707i         0]\n[        0         0      0+1i]\n\nTranspose:\n[    0.707  0-0.707i         0]\n[    0.707  0+0.707i         0]\n[        0         0      0-1i]\nIs Hermitian?\tFalse\nIs Normal?\tTrue\nIs Unitary?\tTrue\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and display here on this page, the longest sequence of consecutive prime numbers where the differences between the primes are strictly ascending.  \n  \nDo the same for sequences of primes where the differences are strictly descending.\n  \n  \nIn both cases, show the sequence for primes   <   1,000,000.\n  \n  \nIf there are multiple sequences of the same length, only the first need be shown."}, {"role": "assistant", "content": "```\nuse Math::Primesieve;\nuse Lingua::EN::Numbers;\n\nmy $sieve = Math::Primesieve.new;\n\nmy $limit = 1000000;\n\nmy @primes = $sieve.primes($limit);\n\nsub runs (&op) {\n    my $diff = 1;\n    my $run = 1;\n\n    my @diff = flat 1, (1..^@primes).map: {\n        my $next = @primes[$_] - @primes[$_ - 1];\n        if &op($next, $diff) { ++$run } else { $run = 1 }\n        $diff = $next;\n        $run;\n    }\n\n    my $max = max @diff;\n    my @runs = @diff.grep: * == $max, :k;\n\n    @runs.map( {\n        my @run = (0..$max).reverse.map: -> $r { @primes[$_ - $r] }\n        flat roundrobin(@run».&comma, @run.rotor(2 => -1).map({[R-] $_})».fmt('(%d)'));\n    } ).join: \"\\n\"\n}\n\nsay \"Longest run(s) of ascending prime gaps up to {comma $limit}:\\n\" ~ runs(&infix:«>»);\n\nsay \"\\nLongest run(s) of descending prime gaps up to {comma $limit}:\\n\" ~ runs(&infix:«<»);\n\n```\n\nOutput:\n\n```\nLongest run(s) of ascending prime gaps up to 1,000,000:\n128,981 (2) 128,983 (4) 128,987 (6) 128,993 (8) 129,001 (10) 129,011 (12) 129,023 (14) 129,037\n402,581 (2) 402,583 (4) 402,587 (6) 402,593 (8) 402,601 (12) 402,613 (18) 402,631 (60) 402,691\n665,111 (2) 665,113 (4) 665,117 (6) 665,123 (8) 665,131 (10) 665,141 (12) 665,153 (24) 665,177\n\nLongest run(s) of descending prime gaps up to 1,000,000:\n322,171 (22) 322,193 (20) 322,213 (16) 322,229 (8) 322,237 (6) 322,243 (4) 322,247 (2) 322,249\n752,207 (44) 752,251 (12) 752,263 (10) 752,273 (8) 752,281 (6) 752,287 (4) 752,291 (2) 752,293\n```"}]}
{"messages": [{"role": "user", "content": "The Consistent Overhead Byte Stuffing (COBS) algorithm is used to demarcate a byte stream into frames. Examples can be found in its Wikipedia article.\n\nTask\n\nTo encode, instances of the byte `0x00` in the unencoded stream are substituted with the number of bytes until the next instance of `0x00` (we'll call this a milestone).\nIf `0x00` does not appear within the next 254 bytes after a milestone the algorithm must emit an extra milestone at the 255th byte.\nOf the encoded output, the first byte is the first milestone, and the final milestone will be the number of bytes until the final byte - `0x00`.\n\nBonus tasks\n\n* Decode an encoded packet\n  + Report an error if the final milestone exceeds the length of the end of the packet\n* Support encoding with a non-zero marker"}, {"role": "assistant", "content": "**Translation of**: Wren\n\n```\n# 20231102 Raku programming solution\n\nsub encode($data where $data.Bool, $delim = 0x00) {\n   my ($ins,$code,$addLastCode,@enc) = 0,1,True,-1;\n   for $data.list -> $byte {\n      if $byte != 0 { @enc.push($byte) andthen $code++ }\n      $addLastCode = True;\n      if $byte == 0 || $code == 255 {\n         $addLastCode = False if $code == 255;\n         @enc[$ins] = $code;\n         $code = 1;\n         $ins = @enc.elems;\n         @enc.push(-1);\n      }\n   } \n   if $addLastCode {\n      @enc[$ins] = $code;\n      if $delim != 0 { @enc >>^=>> $delim } \n      @enc.push($delim)\n   } else {\n      if $delim != 0 { @enc >>^=>> $delim }\n      @enc[$ins] = $delim\n   }\n   return @enc;\n}\n\nsub decode($data where $data.Bool, $delim = 0x00) {\n   my $length = ( my @enc2 = $data.list[0..*-2] ).elems;\n   if $delim != 0 { @enc2 >>^=>> $delim }\n   my ($block,$code,@dec) = 0,255;\n   for @enc2.kv -> $i,$byte {\n      if $block != 0 {\n         @dec.push($byte)\n      } else {\n         die \"marker pointing beyond the end of the packet.\" if $i + $byte > $length;\n         @dec.push(0) if $code != 255;\n         $block = $code = $byte;\n         last if $code == 0\n      }\n      $block--;\n   }\n   return @dec;\n}\n\nfor ( [0x00], [0x00,0x00], [0x00,0x11,0x00], [0x11,0x22,0x00,0x33],\n      [0x11,0x22,0x33,0x44], [0x11,0x00,0x00,0x00], # 0x01..0xfe, 0x00..0xfe, \n#      [0x02..0xff].append(0x00), [0x03..0xff].append(0x00, 0x01),\n) { # https://crccalc.com/bytestuffing.php \n#   say encode( $_ )>>.&{.fmt(\"0x%x\")}; \n   say decode(encode( $_ ))>>.&{.fmt(\"0x%x\")}\n}\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "**Constrained genericity** or **bounded quantification** means\nthat a parametrized type or function (see parametric polymorphism)\ncan only be instantiated on types fulfilling some conditions,\neven if those conditions are not used in that function.\n\nSay a type is called \"eatable\" if you can call the function eat on it.\nWrite a generic type FoodBox which contains a collection of objects of\na type given as parameter, but can only be instantiated on eatable types.\nThe FoodBox shall not use the function eat in any way (i.e. without the explicit restriction, it could be instantiated on any type).\nThe specification of a type being eatable should be as generic as possible\nin your language (i.e. the restrictions on the implementation of eatable types\nshould be as minimal as possible).\nAlso explain the restrictions, if any, on the implementation of eatable types,\nand show at least one example of an eatable type."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsubset Eatable of Any where { .^can('eat') };\n\nclass Cake { method eat() {...} }\n\nrole FoodBox[Eatable] {\n    has %.foodbox;\n}\n\nclass Yummy does FoodBox[Cake] { }      # composes correctly\n# class Yucky does FoodBox[Int] { }     # fails to compose\n\nmy Yummy $foodbox .= new;\nsay $foodbox;\n\n```\n\nOutput:\n\n```\nYummy.new(foodbox => {})\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGenerate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that   \n\n10\n≤\n\nx\n\n2\n+\n\ny\n\n2\n≤\n15\n{\\displaystyle {\\displaystyle 10\\leq {\\sqrt {x^{2}+y^{2}}}\\leq 15}}\n.   \nThen display/plot them. The outcome should be a \"fuzzy\" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once.\n\nThere are several possible approaches to accomplish this. Here are two possible algorithms.\n\n1) Generate random pairs of integers and filter out those that don't satisfy this condition:\n\n:   10\n    ≤\n\n    x\n\n    2\n    +\n\n    y\n\n    2\n    ≤\n    15\n    {\\displaystyle {\\displaystyle 10\\leq {\\sqrt {x^{2}+y^{2}}}\\leq 15}}\n    .\n\n2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015.09\n\n```\nmy @range = -15..16;\n\nmy @points = gather for @range X @range -> ($x, $y) {\n    take [$x,$y] if 10 <= sqrt($x*$x+$y*$y) <= 15\n}\nmy @samples = @points.roll(100); # or .pick(100) to get distinct points\n\n# format and print\nmy %matrix;\nfor @range X @range -> ($x, $y) { %matrix{$y}{$x} = ' ' }\n%matrix{.[1]}{.[0]} = '*' for @samples;\n%matrix{$_}{@range}.join(' ').say for @range;\n\n```\n\nOutput:\n\n```\n                                  *\n                    *                 *\n              *     *   *         *         *\n            * *         *               *\n                      *           *       *   *     *\n              *   *\n            *     *                                   *\n      *     *                                 *       *\n                                              *\n            *                                   * *   *\n      *   *                                         *\n      * *                                         *     *\n      *\n  *     *\n                                                      * * *\n  * *   * *\n      *                                             *   *\n    *\n    *     *\n  *     *\n            * *                                       *\n      *                                           *   *\n                                          *         *\n          *                                   *       *\n              *         *       *         * * *     *\n          *   *     *                   *     * *\n                              *     *   *   *\n                  *                 *\n                                *     * *\n```\n\nTurning that program completely inside-out and reducing to a single statement with a single non-parameter variable, we get another version that also works.\n\nThis uses, among other things, a 0-based matrix rather than a hash, a given on the first line that allows us to print the final value of the matrix straight from its initial declaration, a for statement feeding a for statement modifier, a lambda that unpacks a single x-y argument into two variables, the functional form of pick rather than the method form, a quasi-list comprehension in the middle loop that filters each given with a when, precalculated squared limits so we don't have to take the square root, use of X- and X\\*\\* to subtract and exponentiate both $x and $y in parallel.\n\nAfter the given do has loaded up @matrix with our circle, the map on the first line substitutes a space for any undefined matrix element, and the extra space between elements is supplied by the stringification of the list value, performed by the prefix ~ operator, the unary equivalent of concatenation in Raku.\n\nAt this point you would be justified in concluding that we are completely mad. :-)\n\n```\n(say ~.map: { $_ // ' ' } for my @matrix) given do\n    -> [$x, $y] { @matrix[$x][$y] = '*' } for pick 100, do\n        for ^32 X ^32 -> ($x, $y) {\n            [$x,$y] when 100..225 given [+] ($x,$y X- 15) X** 2;\n        }\n\n```\n\nOutput:\n\n```\n                       *   *     *\n                        * *     *\n                          *       * * *   *     *\n                    *   * * *         *         *\n        *     *             *         *     *     *\n          *     *                             *\n      *                                   * * *   *\n          * *                                 *     *\n      * *\n                                                    *   *\n                                                    *\n  *                                               *     *\n\n    *                                               *\n* *                                                 * * *   *\n      *   *\n\n        *                                         * *   *\n          *                                         * *\n      * *   *                                         *\n                                                  *   *\n    *   *\n        * *                                     *\n      * *   *                           * *           *\n              *               *         *         *\n              * *       *   *           *     *\n              * * *                         *\n                  * *   *       * *\n                    *       * *\n```"}]}
{"messages": [{"role": "user", "content": "A number may be represented as a continued fraction (see Mathworld for more information) as follows:\n\n:   a\n\n    0\n    +\n\n    b\n\n    1\n\n    a\n\n    1\n    +\n\n    b\n\n    2\n\n    a\n\n    2\n    +\n\n    b\n\n    3\n\n    a\n\n    3\n    +\n    ⋱\n    {\\displaystyle {\\displaystyle a\\_{0}+{\\cfrac {b\\_{1}}{a\\_{1}+{\\cfrac {b\\_{2}}{a\\_{2}+{\\cfrac {b\\_{3}}{a\\_{3}+\\ddots }}}}}}}}\n\nThe task is to write a program which generates such a number and prints a real representation of it. The code should be tested by calculating and printing the square root of 2, Napier's Constant, and Pi, using the following coefficients:\n\nFor the square root of 2, use \n\na\n\n0\n=\n1\n{\\displaystyle {\\displaystyle a\\_{0}=1}}\n then \n\na\n\nN\n=\n2\n{\\displaystyle {\\displaystyle a\\_{N}=2}}\n. \n\nb\n\nN\n{\\displaystyle {\\displaystyle b\\_{N}}}\n is always \n\n1\n{\\displaystyle {\\displaystyle 1}}\n.\n\n:   2\n    =\n    1\n    +\n\n    1\n\n    2\n    +\n\n    1\n\n    2\n    +\n\n    1\n\n    2\n    +\n    ⋱\n    {\\displaystyle {\\displaystyle {\\sqrt {2}}=1+{\\cfrac {1}{2+{\\cfrac {1}{2+{\\cfrac {1}{2+\\ddots }}}}}}}}\n\nFor Napier's Constant, use \n\na\n\n0\n=\n2\n{\\displaystyle {\\displaystyle a\\_{0}=2}}\n, then \n\na\n\nN\n=\nN\n{\\displaystyle {\\displaystyle a\\_{N}=N}}\n. \n\nb\n\n1\n=\n1\n{\\displaystyle {\\displaystyle b\\_{1}=1}}\n then \n\nb\n\nN\n=\nN\n−\n1\n{\\displaystyle {\\displaystyle b\\_{N}=N-1}}\n.\n\n:   e\n    =\n    2\n    +\n\n    1\n\n    1\n    +\n\n    1\n\n    2\n    +\n\n    2\n\n    3\n    +\n\n    3\n\n    4\n    +\n    ⋱\n    {\\displaystyle {\\displaystyle e=2+{\\cfrac {1}{1+{\\cfrac {1}{2+{\\cfrac {2}{3+{\\cfrac {3}{4+\\ddots }}}}}}}}}}\n\nFor Pi, use \n\na\n\n0\n=\n3\n{\\displaystyle {\\displaystyle a\\_{0}=3}}\n then \n\na\n\nN\n=\n6\n{\\displaystyle {\\displaystyle a\\_{N}=6}}\n. \n\nb\n\nN\n=\n(\n2\nN\n−\n1\n\n)\n\n2\n{\\displaystyle {\\displaystyle b\\_{N}=(2N-1)^{2}}}\n.\n\n:   π\n    =\n    3\n    +\n\n    1\n\n    6\n    +\n\n    9\n\n    6\n    +\n\n    25\n\n    6\n    +\n    ⋱\n    {\\displaystyle {\\displaystyle \\pi =3+{\\cfrac {1}{6+{\\cfrac {9}{6+{\\cfrac {25}{6+\\ddots }}}}}}}}\n\nSee also\n:   * Continued fraction/Arithmetic for tasks that do arithmetic over continued fractions."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-10-31\n\n```\nsub continued-fraction(:@a, :@b, Int :$n = 100)\n{\n    my $x = @a[$n - 1];\n    $x = @a[$_ - 1] + @b[$_] / $x for reverse 1 ..^ $n;\n    $x;\n}\n\nprintf \"√2 ≈%.9f\\n\", continued-fraction(:a(1, |(2 xx *)), :b(Nil, |(1 xx *)));\nprintf \"e  ≈%.9f\\n\", continued-fraction(:a(2, |(1 .. *)), :b(Nil, 1, |(1 .. *)));\nprintf \"π  ≈%.9f\\n\", continued-fraction(:a(3, |(6 xx *)), :b(Nil, |((1, 3, 5 ... *) X** 2)));\n\n```\n\nOutput:\n\n```\n√2 ≈ 1.414213562\ne  ≈ 2.718281828\nπ  ≈ 3.141592654\n```\n\nA more original and a bit more abstract method would consist in viewing a continued fraction on rank n as a function of a variable x:\n\n:   C\n    F\n\n    3\n    (\n    x\n    )\n    =\n\n    a\n\n    0\n    +\n\n    b\n\n    1\n\n    a\n\n    1\n    +\n\n    b\n\n    2\n\n    a\n\n    2\n    +\n\n    b\n\n    3\n\n    a\n\n    3\n    +\n    x\n    {\\displaystyle {\\displaystyle \\mathrm {CF} \\_{3}(x)=a\\_{0}+{\\cfrac {b\\_{1}}{a\\_{1}+{\\cfrac {b\\_{2}}{a\\_{2}+{\\cfrac {b\\_{3}}{a\\_{3}+x}}}}}}}}\n\nOr, more consistently:\n\n:   C\n    F\n\n    3\n    (\n    x\n    )\n    =\n\n    a\n\n    0\n    +\n\n    b\n\n    0\n\n    a\n\n    1\n    +\n\n    b\n\n    1\n\n    a\n\n    2\n    +\n\n    b\n\n    2\n\n    a\n\n    3\n    +\n\n    b\n\n    3\n\n    x\n    {\\displaystyle {\\displaystyle \\mathrm {CF} \\_{3}(x)=a\\_{0}+{\\cfrac {b\\_{0}}{a\\_{1}+{\\cfrac {b\\_{1}}{a\\_{2}+{\\cfrac {b\\_{2}}{a\\_{3}+{\\cfrac {b\\_{3}}{x}}}}}}}}}}\n\nViewed as such, \n\nC\nF\n\nn\n(\nx\n)\n{\\displaystyle {\\displaystyle \\mathrm {CF} \\_{n}(x)}}\n could be written recursively:\n\n:   C\n    F\n\n    n\n    (\n    x\n    )\n    =\n\n\n    C\n    F\n\n    n\n    −\n    1\n    (\n\n    a\n\n    n\n    +\n\n    b\n\n    n\n    x\n    )\n    {\\displaystyle {\\displaystyle \\mathrm {CF} \\_{n}(x)=\\mathrm {CF} \\_{n-1}(a\\_{n}+{\\frac {b\\_{n}}{x}})}}\n\nOr in other words:\n\n:   C\n    F\n\n    n\n    =\n\n\n    C\n    F\n\n    n\n    −\n    1\n    ∘\n\n    f\n\n    n\n    =\n\n\n    C\n    F\n\n    n\n    −\n    2\n    ∘\n\n    f\n\n    n\n    −\n    1\n    ∘\n\n    f\n\n    n\n    =\n    …\n    =\n\n    f\n\n    0\n    ∘\n\n    f\n\n    1\n    …\n    ∘\n\n    f\n\n    n\n    {\\displaystyle {\\displaystyle \\mathrm {CF} \\_{n}=\\mathrm {CF} \\_{n-1}\\circ f\\_{n}=\\mathrm {CF} \\_{n-2}\\circ f\\_{n-1}\\circ f\\_{n}=\\ldots =f\\_{0}\\circ f\\_{1}\\ldots \\circ f\\_{n}}}\n\nwhere \n\nf\n\nn\n(\nx\n)\n=\n\na\n\nn\n+\n\nb\n\nn\nx\n{\\displaystyle {\\displaystyle f\\_{n}(x)=a\\_{n}+{\\frac {b\\_{n}}{x}}}}\n\nRaku has a builtin composition operator. We can use it with the triangular reduction metaoperator, and evaluate each resulting function at infinity (any value would do actually, but infinite makes it consistent with this particular task).\n\n```\nsub continued-fraction(@a, @b) {\n    map { .(Inf) }, [\\o] map { @a[$_] + @b[$_] / * }, ^Inf\n}\n \nprintf \"√2 ≈ %.9f\\n\", continued-fraction((1, |(2 xx *)), (1 xx *))[10];\nprintf \"e  ≈ %.9f\\n\", continued-fraction((2, |(1 .. *)), (1, |(1 .. *)))[10];\nprintf \"π  ≈ %.9f\\n\", continued-fraction((3, |(6 xx *)), ((1, 3, 5 ... *) X** 2))[100];\n\n```\n\nOutput:\n\n```\n√2 ≈ 1.414213552\ne  ≈ 2.718281827\nπ  ≈ 3.141592411\n```"}]}
{"messages": [{"role": "user", "content": "Given a positive real number, if we truncate its continued fraction representation at a certain depth, we obtain a rational approximation to the real number. The sequence of successively better such approximations is its convergent sequence.\n\nProblem:\n\n* Given a positive rational number \n\n  m\n  n\n  {\\displaystyle {\\displaystyle {\\frac {m}{n}}}}\n  , specified by two positive integers \n\n  m\n  ,\n  n\n  {\\displaystyle {\\displaystyle m,n}}\n  , output its entire sequence of convergents.\n* Given a quadratic real number \n\n  b\n\n\n  a\n  +\n  m\n  n\n  >\n  0\n  {\\displaystyle {\\displaystyle {\\frac {b{\\sqrt {a}}+m}{n}}>0}}\n  , specified by integers \n\n  a\n  ,\n  b\n  ,\n  m\n  ,\n  n\n  {\\displaystyle {\\displaystyle a,b,m,n}}\n  , where \n\n  a\n  {\\displaystyle {\\displaystyle a}}\n   is not a perfect square, output the first \n\n  k\n  {\\displaystyle {\\displaystyle k}}\n   convergents when given a positive number \n\n  k\n  {\\displaystyle {\\displaystyle k}}\n  .\n\nThe output format can be whatever is necessary to represent rational numbers, but it probably should be a 2-tuple of integers.\n\nFor example, given \n\na\n=\n2\n,\nb\n=\n1\n,\nm\n=\n0\n,\nn\n=\n1\n{\\displaystyle {\\displaystyle a=2,b=1,m=0,n=1}}\n, since\n\n2\n=\n1\n+\n\n1\n\n2\n+\n\n1\n\n2\n+\n\n1\n\n2\n+\n⋱\n{\\displaystyle {\\sqrt {2}}=1+{\\cfrac {1}{2+{\\cfrac {1}{2+{\\cfrac {1}{2+\\ddots }}}}}}}\nthe program should output \n\n(\n1\n,\n1\n)\n,\n(\n3\n,\n2\n)\n,\n(\n7\n,\n5\n)\n,\n(\n17\n\n/\n12\n)\n,\n(\n41\n\n/\n29\n)\n,\n…\n{\\displaystyle {\\displaystyle (1,1),(3,2),(7,5),(17/12),(41/29),\\dots }}\n.\n\nA simple check is to do this for the golden ratio **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle \\frac{\\sqrt{5}+1}{2}}**\n, that is, **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle a=5, b=1, m = 1, n = 2 }**\n, which should output \n\n(\n1\n,\n1\n)\n,\n(\n2\n,\n1\n)\n,\n(\n3\n,\n2\n)\n,\n(\n5\n,\n3\n)\n,\n(\n8\n,\n5\n)\n,\n…\n{\\displaystyle {\\displaystyle (1,1),(2,1),(3,2),(5,3),(8,5),\\dots }}\n.\n\nPrint the results for 415/93, 649/200, \n\n2\n{\\displaystyle {\\displaystyle {\\sqrt {2}}}}\n, **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle \\sqrt{5}}**\n, and the golden ratio.\n\nReferences and related tasks\n\n* Wikipedia: Continued fraction\n* Continued fraction\n* Continued fraction/Arithmetic\n* Continued fraction/Arithmetic/Construct from rational number\n* Calkin-Wilf sequence"}, {"role": "assistant", "content": "**Translation of**: Julia\n\n```\n# 20240210 Raku programming solution\n\nsub convergents(Real $x is copy, Int $maxcount) {\n   my @components = gather for ^$maxcount {\n      my $fpart = $x - take $x.Int;\n      $fpart == 0 ?? ( last ) !! ( $x = 1 / $fpart )\n   }\n   my ($numa, $denoma, $numb, $denomb) = 1, 0, @components[0], 1;\n   return [ Rat.new($numb, $denomb) ].append: gather for @components[1..*] -> $comp {\n      ( $numa, $denoma, $numb                , $denomb                  ) \n      = $numb, $denomb, $numa + $comp * $numb, $denoma + $comp * $denomb;\n      take Rat.new($numb, $denomb);\n   }\n}\n\nmy @tests = [ \"415/93\", 415/93, \"649/200\", 649/200, \"sqrt(2)\", sqrt(2),\n              \"sqrt(5)\", sqrt(5), \"golden ratio\", (sqrt(5) + 1) / 2     ];\n\nsay \"The continued fraction convergents for the following (maximum 8 terms) are:\";\nfor @tests -> $s, $x {\n   say $s.fmt('%15s') ~ \" = { convergents($x, 8).map: *.nude.join('/') } \";\n}\n\n```\n\nOutput:\n\n```\nThe continued fraction convergents for the following (maximum 8 terms) are:\n         415/93 = 4/1 9/2 58/13 415/93 \n        649/200 = 3/1 13/4 159/49 649/200 \n        sqrt(2) = 1/1 3/2 7/5 17/12 41/29 99/70 239/169 577/408 \n        sqrt(5) = 2/1 9/4 38/17 161/72 682/305 2889/1292 12238/5473 51841/23184 \n   golden ratio = 1/1 2/1 3/2 5/3 8/5 13/8 21/13 34/21 \n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "To understand this task in context please see Continued fraction arithmetic\n\nThe purpose of this task is to write a function \n\nr\n2\nc\nf\n(\n\ni\nn\nt\n{\\displaystyle {\\displaystyle {\\mathit {r2cf}}(\\mathrm {int} }}\n \n\nN\n\n1\n,\n\ni\nn\nt\n{\\displaystyle {\\displaystyle N\\_{1},\\mathrm {int} }}\n \n\nN\n\n2\n)\n{\\displaystyle {\\displaystyle N\\_{2})}}\n, or \n\nr\n2\nc\nf\n(\n\nF\nr\na\nc\nt\ni\no\nn\n{\\displaystyle {\\displaystyle {\\mathit {r2cf}}(\\mathrm {Fraction} }}\n \n\nN\n)\n{\\displaystyle {\\displaystyle N)}}\n, which will output a continued fraction assuming:\n\n:   N\n\n    1\n    {\\displaystyle {\\displaystyle N\\_{1}}}\n     is the numerator\n:   N\n\n    2\n    {\\displaystyle {\\displaystyle N\\_{2}}}\n     is the denominator\n\nThe function should output its results one digit at a time each time it is called, in a manner sometimes described as lazy evaluation.\n\nTo achieve this it must determine: the integer part; and remainder part, of \n\nN\n\n1\n{\\displaystyle {\\displaystyle N\\_{1}}}\n divided by \n\nN\n\n2\n{\\displaystyle {\\displaystyle N\\_{2}}}\n. It then sets \n\nN\n\n1\n{\\displaystyle {\\displaystyle N\\_{1}}}\n to \n\nN\n\n2\n{\\displaystyle {\\displaystyle N\\_{2}}}\n and \n\nN\n\n2\n{\\displaystyle {\\displaystyle N\\_{2}}}\n to the determined remainder part. It then outputs the determined integer part. It does this until \n\na\nb\ns\n(\n\nN\n\n2\n)\n{\\displaystyle {\\displaystyle \\mathrm {abs} (N\\_{2})}}\n is zero.\n\nDemonstrate the function by outputing the continued fraction for:\n\n:   1/2\n:   3\n:   23/8\n:   13/11\n:   22/7\n:   -151/77\n\n2\n{\\displaystyle {\\displaystyle {\\sqrt {2}}}}\n should approach \n\n[\n1\n;\n2\n,\n2\n,\n2\n,\n2\n,\n…\n]\n{\\displaystyle {\\displaystyle [1;2,2,2,2,\\ldots ]}}\n try ever closer rational approximations until boredom gets the better of you:\n\n:   14142,10000\n:   141421,100000\n:   1414214,1000000\n:   14142136,10000000\n\nTry :\n\n:   31,10\n:   314,100\n:   3142,1000\n:   31428,10000\n:   314285,100000\n:   3142857,1000000\n:   31428571,10000000\n:   314285714,100000000\n\nObserve how this rational number behaves differently to \n\n2\n{\\displaystyle {\\displaystyle {\\sqrt {2}}}}\n and convince yourself that, in the same way as \n\n3.7\n{\\displaystyle {\\displaystyle 3.7}}\n may be represented as \n\n3.70\n{\\displaystyle {\\displaystyle 3.70}}\n when an extra decimal place is required, \n\n[\n3\n;\n7\n]\n{\\displaystyle {\\displaystyle [3;7]}}\n may be represented as \n\n[\n3\n;\n7\n,\n∞\n]\n{\\displaystyle {\\displaystyle [3;7,\\infty ]}}\n when an extra term is required."}, {"role": "assistant", "content": "(formerly Perl 6)\nStraightforward implementation:\n\n```\nsub r2cf(Rat $x is copy) {\n    gather loop {\n\t$x -= take $x.floor;\n\tlast unless $x > 0;\n\t$x = 1 / $x;\n    }\n}\n\nsay r2cf(.Rat) for <1/2 3 23/8 13/11 22/7 1.41 1.4142136>;\n\n```\n\nOutput:\n\n```\n(0 2)\n(3)\n(2 1 7)\n(1 5 2)\n(3 7)\n(1 2 2 3 1 1 2)\n(1 2 2 2 2 2 2 2 2 2 6 1 2 4 1 1 2)\n```\n\nAs a silly one-liner:\n\n```\nsub r2cf(Rat $x is copy) { gather $x [R/]= 1 while ($x -= take $x.floor) > 0 }\n\n```"}]}
{"messages": [{"role": "user", "content": "This task investigates mathmatical operations that can be performed on a single continued fraction. This requires only a baby version of NG:\n\n:   [\n\n    a\n\n    1\n\n    a\n\n    b\n\n    1\n\n    b\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{1}&a\\\\b\\_{1}&b\\end{bmatrix}}}}\n\nI may perform perform the following operations:\n\n:   Input the next term of N1\n:   Output a term of the continued fraction resulting from the operation.\n\nI output a term if the integer parts of \n\na\nb\n{\\displaystyle {\\displaystyle {\\frac {a}{b}}}}\n and \n\na\n\n1\n\nb\n\n1\n{\\displaystyle {\\displaystyle {\\frac {a\\_{1}}{b\\_{1}}}}}\n are equal. Otherwise I input a term from N. If I need a term from N but N has no more terms I inject \n\n∞\n{\\displaystyle {\\displaystyle \\infty }}\n.\n\nWhen I input a term t my internal state: \n\n[\n\na\n\n1\n\na\n\nb\n\n1\n\nb\n]\n{\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{1}&a\\\\b\\_{1}&b\\end{bmatrix}}}}\n is transposed thus \n\n[\n\na\n+\n\na\n\n1\n∗\nt\n\n\na\n\n1\n\n\nb\n+\n\nb\n\n1\n∗\nt\n\n\nb\n\n1\n]\n{\\displaystyle {\\displaystyle {\\begin{bmatrix}a+a\\_{1}\\*t&a\\_{1}\\\\b+b\\_{1}\\*t&b\\_{1}\\end{bmatrix}}}}\n\nWhen I output a term t my internal state: \n\n[\n\na\n\n1\n\na\n\nb\n\n1\n\nb\n]\n{\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{1}&a\\\\b\\_{1}&b\\end{bmatrix}}}}\n is transposed thus \n\n[\n\nb\n\n1\n\nb\n\na\n\n1\n−\n\nb\n\n1\n∗\nt\n\na\n−\nb\n∗\nt\n]\n{\\displaystyle {\\displaystyle {\\begin{bmatrix}b\\_{1}&b\\\\a\\_{1}-b\\_{1}\\*t&a-b\\*t\\end{bmatrix}}}}\n\nWhen I need a term t but there are no more my internal state: \n\n[\n\na\n\n1\n\na\n\nb\n\n1\n\nb\n]\n{\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{1}&a\\\\b\\_{1}&b\\end{bmatrix}}}}\n is transposed thus \n\n[\n\na\n\n1\n\n\na\n\n1\n\nb\n\n1\n\n\nb\n\n1\n]\n{\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{1}&a\\_{1}\\\\b\\_{1}&b\\_{1}\\end{bmatrix}}}}\n\nI am done when b1 and b are zero.\n\nDemonstrate your solution by calculating:\n\n:   [1;5,2] + 1/2\n:   [3;7] + 1/2\n:   [3;7] divided by 4\n\nUsing a generator for \n\n2\n{\\displaystyle {\\displaystyle {\\sqrt {2}}}}\n (e.g., from Continued fraction) calculate \n\n1\n\n2\n{\\displaystyle {\\displaystyle {\\frac {1}{\\sqrt {2}}}}}\n. You are now at the starting line for using Continued Fractions to implement Arithmetic-geometric mean without ulps and epsilons.\n\nThe first step in implementing Arithmetic-geometric mean is to calculate \n\n1\n+\n\n\n1\n\n2\n2\n{\\displaystyle {\\displaystyle {\\frac {1+{\\frac {1}{\\sqrt {2}}}}{2}}}}\n do this now to cross the starting line and begin the race."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\nAll the important stuff takes place in the NG object. Everything else is helper subs for testing and display. The NG object is capable of working with infinitely long continued fractions, but displaying them can be problematic. You can pass in a limit to the apply method to get a fixed maximum number of terms though. See the last example: 100 terms from the infinite cf (1+√2)/2 and its Rational representation.\n\n```\nclass NG {\n    has ( $!a1, $!a, $!b1, $!b );\n    submethod BUILD ( :$!a1, :$!a, :$!b1, :$!b ) { }\n\n    # Public methods\n    method new( $a1, $a, $b1, $b ) { self.bless( :$a1, :$a, :$b1, :$b ) }\n    method apply(@cf, :$limit = Inf) {\n        (gather {\n            map { take self!extract unless self!needterm; self!inject($_) }, @cf;\n            take self!drain until self!done;\n        })[ ^ $limit ]\n    }\n\n    # Private methods\n    method !inject ($n) {\n        sub xform($n, $x, $y) { $x, $n * $x + $y }\n        ( $!a, $!a1 ) = xform( $n, $!a1, $!a );\n        ( $!b, $!b1 ) = xform( $n, $!b1, $!b );\n    }\n    method !extract {\n        sub xform($n, $x, $y) { $y, $x - $y * $n }\n        my $n = $!a div $!b;\n        ($!a,  $!b ) = xform( $n, $!a,  $!b  );\n        ($!a1, $!b1) = xform( $n, $!a1, $!b1 );\n        $n\n    }\n    method !drain { $!a = $!a1, $!b = $!b1 if self!needterm; self!extract }\n    method !needterm { so [||] !$!b, !$!b1, $!a/$!b != $!a1/$!b1 }\n    method !done { not [||] $!b, $!b1 }\n}\n\nsub r2cf(Rat $x is copy) { # Rational to continued fraction\n    gather loop {\n\t$x -= take $x.floor;\n\tlast if !$x;\n\t$x = 1 / $x;\n    }\n}\n\nsub cf2r(@a) { # continued fraction to Rational\n    my $x = @a[* - 1]; # Use FatRats for arbitrary precision\n    $x = ( @a[$_- 1] + 1 / $x ).FatRat for reverse 1 ..^ @a;\n    $x\n}\n\nsub ppcf(@cf) { # format continued fraction for pretty printing \n    \"[{ @cf.join(',').subst(',',';') }]\"\n}\n\nsub pprat($a) { # format Rational for pretty printing\n   # Use FatRats for arbitrary precision\n   $a.FatRat.denominator == 1 ?? $a !! $a.FatRat.nude.join('/')\n}\n\nsub test_NG ($rat, @ng, $op) { \n    my @cf = $rat.Rat(1e-18).&r2cf;\n    my @op = NG.new( |@ng ).apply( @cf );\n    say $rat.raku, ' as a cf: ', @cf.&ppcf, \" $op = \",\n        @op.&ppcf, \"\\tor \", @op.&cf2r.&pprat, \"\\n\";\n}\n\n# Testing\ntest_NG(|$_) for (\n    [ 13/11, [<2 1 0 2>], '+ 1/2 '    ],\n    [ 22/7,  [<2 1 0 2>], '+ 1/2    ' ],\n    [ 22/7,  [<1 0 0 4>], '/ 4      ' ],\n    [ 22/7,  [<7 0 0 22>], '* 7/22   ' ],\n    [ 2**.5, [<1 1 0 2>], \"\\n(1+√2)/2 (approximately)\" ]\n);\n\nsay '100 terms of (1+√2)/2 as a continued fraction and as a rational value:';\n\nmy @continued-fraction = NG.new( 1,1,0,2 ).apply( (lazy flat 1, 2 xx * ), limit => 100 );\nsay @continued-fraction.&ppcf.comb(/ . ** 1..80/).join(\"\\n\");\nsay @continued-fraction.&cf2r.&pprat;\n\n```\n\nOutput:\n\n```\n<13/11> as a cf: [1;5,2] + 1/2  = [1;1,2,7]\tor 37/22\n\n<22/7> as a cf: [3;7] + 1/2     = [3;1,1,1,4]\tor 51/14\n\n<22/7> as a cf: [3;7] / 4       = [0;1,3,1,2]\tor 11/14\n\n<22/7> as a cf: [3;7] * 7/22    = [1]\tor 1\n\n1.4142135623731e0 as a cf: [1;2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] \n(1+√2)/2 (approximately) = [1;4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4]\tor 225058681/186444716\n\n100 terms of (1+√2)/2 and its rational value\n[1;4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4\n,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4\n,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4]\n161733217200188571081311986634082331709/133984184101103275326877813426364627544\n\n```"}]}
{"messages": [{"role": "user", "content": "This task performs the basic mathematical functions on 2 continued fractions. This requires the full version of matrix NG:\n\n:   [\n\n    a\n\n    12\n\n\n    a\n\n    1\n\n\n    a\n\n    2\n\n    a\n\n    b\n\n    12\n\n\n    b\n\n    1\n\n\n    b\n\n    2\n\n    b\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{12}&a\\_{1}&a\\_{2}&a\\\\b\\_{12}&b\\_{1}&b\\_{2}&b\\end{bmatrix}}}}\n\nI may perform perform the following operations:\n\n:   Input the next term of continued fraction N1\n:   Input the next term of continued fraction N2\n:   Output a term of the continued fraction resulting from the operation.\n\nI output a term if the integer parts of \n\na\nb\n{\\displaystyle {\\displaystyle {\\frac {a}{b}}}}\n and \n\na\n\n1\n\nb\n\n1\n{\\displaystyle {\\displaystyle {\\frac {a\\_{1}}{b\\_{1}}}}}\n and \n\na\n\n2\n\nb\n\n2\n{\\displaystyle {\\displaystyle {\\frac {a\\_{2}}{b\\_{2}}}}}\n and \n\na\n\n12\n\nb\n\n12\n{\\displaystyle {\\displaystyle {\\frac {a\\_{12}}{b\\_{12}}}}}\n are equal. Otherwise I input a term from continued fraction N1 or continued fraction N2. If I need a term from N but N has no more terms I inject \n\n∞\n{\\displaystyle {\\displaystyle \\infty }}\n.\n\nWhen I input a term t from continued fraction N1 I change my internal state:\n\n:   [\n\n    a\n\n    12\n\n\n    a\n\n    1\n\n\n    a\n\n    2\n\n    a\n\n    b\n\n    12\n\n\n    b\n\n    1\n\n\n    b\n\n    2\n\n    b\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{12}&a\\_{1}&a\\_{2}&a\\\\b\\_{12}&b\\_{1}&b\\_{2}&b\\end{bmatrix}}}}\n     is transposed thus \n\n    [\n\n    a\n\n    2\n    +\n\n    a\n\n    12\n    ∗\n    t\n\n    a\n    +\n\n    a\n\n    1\n    ∗\n    t\n\n\n    a\n\n    12\n\n\n    a\n\n    1\n\n    b\n\n    2\n    +\n\n    b\n\n    12\n    ∗\n    t\n\n    b\n    +\n\n    b\n\n    1\n    ∗\n    t\n\n\n    b\n\n    12\n\n\n    b\n\n    1\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{2}+a\\_{12}\\*t&a+a\\_{1}\\*t&a\\_{12}&a\\_{1}\\\\b\\_{2}+b\\_{12}\\*t&b+b\\_{1}\\*t&b\\_{12}&b\\_{1}\\end{bmatrix}}}}\n\nWhen I need a term from exhausted continued fraction N1 I change my internal state:\n\n:   [\n\n    a\n\n    12\n\n\n    a\n\n    1\n\n\n    a\n\n    2\n\n    a\n\n    b\n\n    12\n\n\n    b\n\n    1\n\n\n    b\n\n    2\n\n    b\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{12}&a\\_{1}&a\\_{2}&a\\\\b\\_{12}&b\\_{1}&b\\_{2}&b\\end{bmatrix}}}}\n     is transposed thus \n\n    [\n\n    a\n\n    12\n\n\n    a\n\n    1\n\n\n    a\n\n    12\n\n\n    a\n\n    1\n\n    b\n\n    12\n\n\n    b\n\n    1\n\n\n    b\n\n    12\n\n\n    b\n\n    1\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{12}&a\\_{1}&a\\_{12}&a\\_{1}\\\\b\\_{12}&b\\_{1}&b\\_{12}&b\\_{1}\\end{bmatrix}}}}\n\nWhen I input a term t from continued fraction N2 I change my internal state:\n\n:   [\n\n    a\n\n    12\n\n\n    a\n\n    1\n\n\n    a\n\n    2\n\n    a\n\n    b\n\n    12\n\n\n    b\n\n    1\n\n\n    b\n\n    2\n\n    b\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{12}&a\\_{1}&a\\_{2}&a\\\\b\\_{12}&b\\_{1}&b\\_{2}&b\\end{bmatrix}}}}\n     is transposed thus \n\n    [\n\n    a\n\n    1\n    +\n\n    a\n\n    12\n    ∗\n    t\n\n\n    a\n\n    12\n\n    a\n    +\n\n    a\n\n    2\n    ∗\n    t\n\n\n    a\n\n    2\n\n    b\n\n    1\n    +\n\n    b\n\n    12\n    ∗\n    t\n\n\n    b\n\n    12\n\n    b\n    +\n\n    b\n\n    2\n    ∗\n    t\n\n\n    b\n\n    2\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{1}+a\\_{12}\\*t&a\\_{12}&a+a\\_{2}\\*t&a\\_{2}\\\\b\\_{1}+b\\_{12}\\*t&b\\_{12}&b+b\\_{2}\\*t&b\\_{2}\\end{bmatrix}}}}\n\nWhen I need a term from exhausted continued fraction N2 I change my internal state:\n\n:   [\n\n    a\n\n    12\n\n\n    a\n\n    1\n\n\n    a\n\n    2\n\n    a\n\n    b\n\n    12\n\n\n    b\n\n    1\n\n\n    b\n\n    2\n\n    b\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{12}&a\\_{1}&a\\_{2}&a\\\\b\\_{12}&b\\_{1}&b\\_{2}&b\\end{bmatrix}}}}\n     is transposed thus \n\n    [\n\n    a\n\n    12\n\n\n    a\n\n    12\n\n\n    a\n\n    2\n\n\n    a\n\n    2\n\n    b\n\n    12\n\n\n    b\n\n    12\n\n\n    b\n\n    2\n\n\n    b\n\n    2\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{12}&a\\_{12}&a\\_{2}&a\\_{2}\\\\b\\_{12}&b\\_{12}&b\\_{2}&b\\_{2}\\end{bmatrix}}}}\n\nWhen I output a term t I change my internal state:\n\n:   [\n\n    a\n\n    12\n\n\n    a\n\n    1\n\n\n    a\n\n    2\n\n    a\n\n    b\n\n    12\n\n\n    b\n\n    1\n\n\n    b\n\n    2\n\n    b\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{12}&a\\_{1}&a\\_{2}&a\\\\b\\_{12}&b\\_{1}&b\\_{2}&b\\end{bmatrix}}}}\n     is transposed thus \n\n    [\n\n    b\n\n    12\n\n\n    b\n\n    1\n\n\n    b\n\n    2\n\n    b\n\n    a\n\n    12\n    −\n\n    b\n\n    12\n    ∗\n    t\n\n\n    a\n\n    1\n    −\n\n    b\n\n    1\n    ∗\n    t\n\n\n    a\n\n    2\n    −\n\n    b\n\n    2\n    ∗\n    t\n\n    a\n    −\n    b\n    ∗\n    t\n    ]\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}b\\_{12}&b\\_{1}&b\\_{2}&b\\\\a\\_{12}-b\\_{12}\\*t&a\\_{1}-b\\_{1}\\*t&a\\_{2}-b\\_{2}\\*t&a-b\\*t\\end{bmatrix}}}}\n\nWhen I need to choose to input from N1 or N2 I act:\n\n:   if b and b2 are zero I choose N1\n:   if b is zero I choose N2\n:   if b2 is zero I choose N2\n:   if abs(\n\n    a\n\n    1\n\n    b\n\n    1\n    −\n\n\n    a\n    b\n    )\n    {\\displaystyle {\\displaystyle {\\frac {a\\_{1}}{b\\_{1}}}-{\\frac {a}{b}})}}\n     is greater than abs(\n\n    a\n\n    2\n\n    b\n\n    2\n    −\n\n\n    a\n    b\n    )\n    {\\displaystyle {\\displaystyle {\\frac {a\\_{2}}{b\\_{2}}}-{\\frac {a}{b}})}}\n     I choose N1\n:   otherwise I choose N2\n\nWhen performing arithmetic operation on two potentially infinite continued fractions it is possible to generate a rational number. eg \n\n2\n{\\displaystyle {\\displaystyle {\\sqrt {2}}}}\n \\* \n\n2\n{\\displaystyle {\\displaystyle {\\sqrt {2}}}}\n should produce 2. This will require either that I determine that my internal state is approaching infinity, or limiting the number of terms I am willing to input without producing any output."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.01\n\nThe NG2 object can work with infinitely long continued fractions, it does lazy evaluation. By default, it is limited to returning the first 30 terms. Pass in a limit value if you want something other than default.\n\n```\nclass NG2 {\n    has ( $!a12, $!a1, $!a2, $!a, $!b12, $!b1, $!b2, $!b );\n\n    # Public methods\n    method operator($!a12, $!a1, $!a2, $!a, $!b12, $!b1, $!b2, $!b ) { self }\n\n    method apply(@cf1, @cf2, :$limit = 30) {\n        my @cfs = [@cf1], [@cf2];\n        gather {\n            while @cfs[0] or @cfs[1] {\n                my $term;\n                (take $term if $term = self!extract) unless self!needterm;\n                my $from = self!from;\n                $from = @cfs[$from] ?? $from !! $from +^ 1;\n                self!inject($from, @cfs[$from].shift);\n            }\n            take self!drain while $!b;\n        }[ ^$limit ].grep: *.defined;\n    }\n\n    # Private methods\n    method !inject ($n, $t) {\n        multi sub xform(0, $t, $x12, $x1, $x2, $x) { $x2 + $x12 * $t, $x + $x1 * $t, $x12, $x1 }\n        multi sub xform(1, $t, $x12, $x1, $x2, $x) { $x1 + $x12 * $t, $x12, $x + $x2 * $t, $x2 }\n        ( $!a12, $!a1, $!a2, $!a ) = xform($n, $t, $!a12, $!a1, $!a2, $!a );\n        ( $!b12, $!b1, $!b2, $!b ) = xform($n, $t, $!b12, $!b1, $!b2, $!b );\n    }\n    method !extract {\n        my $t = $!a div $!b;\n        ( $!a12, $!a1, $!a2, $!a, $!b12, $!b1, $!b2, $!b ) =\n          $!b12, $!b1, $!b2, $!b,\n                                  $!a12 - $!b12 * $t,\n                                         $!a1 - $!b1 * $t,\n                                               $!a2 - $!b2 * $t,\n                                                     $!a - $!b * $t;\n        $t;\n    }\n    method !from {\n        return $!b == $!b2 == 0 ?? 0 !!\n           $!b == 0 || $!b2 == 0 ?? 1 !!\n           abs($!a1*$!b*$!b2 - $!a*$!b1*$!b2) > abs($!a2*$!b*$!b1 - $!a*$!b1*$!b2) ?? 0 !! 1;\n    }\n    method !needterm {\n        so !([&&] $!b12, $!b1, $!b2, $!b) or $!a/$!b != $!a1/$!b1 != $!a2/$!b2 != $!a12/$!b1;\n    }\n    method !noterms($which) {\n        $which ?? (($!a1, $!a, $!b1, $!b ) = $!a12, $!a2, $!b12, $!b2)\n               !! (($!a2, $!a, $!b2, $!b ) = $!a12, $!a1, $!b12, $!b1);\n    }\n    method !drain {\n    self!noterms(self!from) if self!needterm;\n    self!extract;\n    }\n}\n\nsub r2cf(Rat $x is copy) { # Rational to continued fraction\n    gather loop {\n    $x -= take $x.floor;\n    last unless $x;\n    $x = 1 / $x;\n    }\n}\n\nsub cf2r(@a) { # continued fraction to Rational\n    my $x = @a[* - 1].FatRat; # Use FatRats for arbitrary precision\n    $x = @a[$_- 1] + 1 / $x for reverse 1 ..^ @a;\n    $x\n}\n\n# format continued fraction for pretty printing\nsub ppcf(@cf) { \"[{ @cf.join(',').subst(',',';') }]\" }\n\n# format Rational for pretty printing. Use FatRats for arbitrary precision\nsub pprat($a) { $a.FatRat.denominator == 1 ?? $a !! $a.FatRat.nude.join('/') }\n\nmy %ops = ( # convenience hash of NG matrix operators\n    '+' => (0,1,1,0,0,0,0,1),\n    '-' => (0,1,-1,0,0,0,0,1),\n    '*' => (1,0,0,0,0,0,0,1),\n    '/' => (0,1,0,0,0,0,1,0)\n);\n\nsub test_NG2 ($rat1, $op, $rat2) {\n    my @cf1 = $rat1.&r2cf;\n    my @cf2 = $rat2.&r2cf;\n    my @result = NG2.new.operator(|%ops{$op}).apply( @cf1, @cf2 );\n    say \"{$rat1.&pprat} $op {$rat2.&pprat} => {@cf1.&ppcf} $op \",\n        \"{@cf2.&ppcf} = {@result.&ppcf} => {@result.&cf2r.&pprat}\\n\";\n}\n\n# Testing\ntest_NG2(|$_) for\n   [   22/7, '+',  1/2 ],\n   [  23/11, '*', 22/7 ],\n   [  13/11, '-', 22/7 ],\n   [ 484/49, '/', 22/7 ];\n\n\n# Sometimes you may want to limit the terms in the continued fraction to something other than default.\n# Here a lazy infinite continued fraction for  √2, then multiply it by itself. We'll limit the result\n# to 6 terms for brevity’s' sake. We'll then convert that continued fraction back to an arbitrary precision\n# FatRat Rational number. (Raku stores FatRats internally as a ratio of two arbitrarily long integers.\n# We need to exercise a little caution because they can eat up all of your memory if allowed to grow unchecked,\n# hence the limit of 6 terms in continued fraction.) We'll then convert that number to a normal precision\n# Rat, which is accurate to the nearest 1 / 2^64, \n\nsay \"√2 expressed as a continued fraction, then squared: \";\nmy @root2 = lazy flat 1, 2 xx *;\nmy @result = NG2.new.operator(|%ops{'*'}).apply( @root2, @root2, limit => 6 );\nsay @root2.&ppcf, \"² = \\n\";\nsay @result.&ppcf;\nsay \"\\nConverted back to an arbitrary (ludicrous) precision Rational: \";\nsay @result.&cf2r.nude.join(\" /\\n\");\nsay \"\\nCoerced to a standard precision Rational: \", @result.&cf2r.Num.Rat;\n\n```\n\nOutput:\n\n```\n22/7 + 1/2 => [3;7] + [0;2] = [3;1,1,1,4] => 51/14\n\n23/11 * 22/7 => [2;11] * [3;7] = [6;1,1,3] => 46/7\n\n13/11 - 22/7 => [1;5,2] - [3;7] = [-2;25,1,2] => -151/77\n\n484/49 / 22/7 => [9;1,7,6] / [3;7] = [3;7] => 22/7\n\n√2 expressed as a continued fraction, then squared: \n[1;2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,...]² = \n\n[1;1,-58451683124983302025,-1927184886226364356176,-65467555105469489418600,-2223969688699736275876224]\n\nConverted back to an arbitrary (ludicrous) precision Rational: \n32802382178012409621354320392819425499699206367450594986122623570838188983519955166754002 /\n16401191089006204810536863200564985394427741343927508600629139291039556821665755787817601\n\nCoerced to a standard precision Rational: 2\n```"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nThe task is to write a program to transform a decimal number into a fraction in lowest terms.\n\nIt is not always possible to do this exactly. For instance, while rational numbers can be converted to decimal representation, some of them need an infinite number of digits to be represented exactly in decimal form. Namely, repeating decimals such as 1/3 = 0.333...\n\nBecause of this, the following fractions cannot be obtained (reliably) unless the language has some way of representing repeating decimals:\n\n* 67 / 74 = 0.9(054) = 0.9054054...\n* 14 / 27 = 0.(518) = 0.518518...\n\nAcceptable output:\n\n* 0.9054054 → 4527027 / 5000000\n* 0.518518 → 259259 / 500000\n\nFinite decimals are of course no problem:\n\n* 0.75 → 3 / 4"}, {"role": "assistant", "content": "(formerly Perl 6)\nDecimals are natively represented as rationals in Raku, so if the task does not need to handle repeating decimals, it is trivially handled by the .nude method, which returns the numerator and denominator:\n\n```\nsay .nude.join('/') for 0.9054054, 0.518518, 0.75;\n\n```\n\nOutput:\n\n```\n4527027/5000000\n259259/500000\n3/4\n```\n\nHowever, if we want to take repeating decimals into account, then we can get a bit fancier.\n\n```\nsub decimal_to_fraction ( Str $n, Int $rep_digits = 0 ) returns Str {\n    my ( $int, $dec ) = ( $n ~~ /^ (\\d+) \\. (\\d+) $/ )».Str or die;\n\n    my ( $numer, $denom ) = ( $dec, 10 ** $dec.chars );\n    if $rep_digits {\n        my $to_move = $dec.chars - $rep_digits;\n        $numer -= $dec.substr(0, $to_move);\n        $denom -= 10 ** $to_move;\n    }\n\n    my $rat = Rat.new( $numer.Int, $denom.Int ).nude.join('/');\n    return $int > 0 ?? \"$int $rat\" !! $rat;\n}\n\nmy @a = ['0.9054', 3], ['0.518', 3], ['0.75', 0], | (^4).map({['12.34567', $_]});\nfor @a -> [ $n, $d ] {\n    say \"$n with $d repeating digits = \", decimal_to_fraction( $n, $d );\n}\n\n```\n\nOutput:\n\n```\n0.9054 with 3 repeating digits = 67/74\n0.518 with 3 repeating digits = 14/27\n0.75 with 0 repeating digits = 3/4\n12.34567 with 0 repeating digits = 12 34567/100000\n12.34567 with 1 repeating digits = 12 31111/90000\n12.34567 with 2 repeating digits = 12 17111/49500\n12.34567 with 3 repeating digits = 12 1279/3700\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function or program which:\n\n* takes a positive integer representing a duration in seconds as input (e.g., `100`), and\n* returns a string which shows the same duration decomposed into:\n\n:   :   :   * weeks,\n            * days,\n            * hours,\n            * minutes,   and\n            * seconds.\n\nThis is detailed below (e.g., \"`2 hr, 59 sec`\").\n\nDemonstrate that it passes the following three test-cases:\n\n***Test Cases***\n\n:   :   :   :   :   | input number | output string |\n                    | --- | --- |\n                    | 7259 | `2 hr, 59 sec` |\n                    | 86400 | `1 d` |\n                    | 6000000 | `9 wk, 6 d, 10 hr, 40 min` |\n\n***Details***\n\nThe following five units should be used:\n\n:   :   :   :   :   | unit | suffix used in output | conversion |\n                    | --- | --- | --- |\n                    | week | `wk` | 1 week = 7 days |\n                    | day | `d` | 1 day = 24 hours |\n                    | hour | `hr` | 1 hour = 60 minutes |\n                    | minute | `min` | 1 minute = 60 seconds |\n                    | second | `sec` |  |\n\nHowever, **only** include quantities with non-zero values in the output (e.g., return \"`1 d`\" and not \"`0 wk, 1 d, 0 hr, 0 min, 0 sec`\").\n\nGive larger units precedence over smaller ones as much as possible (e.g., return `2 min, 10 sec` and not `1 min, 70 sec` or `130 sec`)\n\nMimic the formatting shown in the test-cases (quantities sorted from largest unit to smallest and separated by comma+space; value and unit of each quantity separated by space).\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe built-in `polymod` method (which is a generalization of the `divmod` function known from other languages), is a perfect match for a task like this:\n\n```\nsub compound-duration ($seconds) {\n    ($seconds.polymod(60, 60, 24, 7) Z <sec min hr d wk>)\n    .grep(*[0]).reverse.join(\", \")\n}\n\n# Demonstration:\n\nfor 7259, 86400, 6000000 {\n    say \"{.fmt: '%7d'} sec  =  {compound-duration $_}\";\n}\n\n```\n\nOutput:\n\n```\n   7259 sec  =  2 hr, 59 sec\n  86400 sec  =  1 d\n6000000 sec  =  9 wk, 6 d, 10 hr, 40 min\n\n```"}]}
{"messages": [{"role": "user", "content": "Find the points which form a convex hull from a set of arbitrary two dimensional points.\n\nFor example, given the points (16,3), (12,17), (0,6), (-4,-6), (16,6), (16,-7), (16,-3), (17,-4), (5,19), (19,-8), (3,16), (12,13), (3,-4), (17,5), (-3,15), (-3,-9), (0,11), (-9,-3), (-4,-2) and (12,10) the convex hull would be (-9,-3), (-3,-9), (19,-8), (17,5), (12,17), (5,19) and (-3,15).\n\nSee also\n\n* Convex Hull (youtube)\n* http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.05\n\n**Translation of**: zkl\n\nModified the angle sort method as the original could fail if there were multiple points on the same y coordinate as the starting point. Sorts on tangent rather than triangle area. Inexpensive since it still doesn't do any trigonometric math, just calculates the ratio of opposite over adjacent.\n\n```\nclass Point {\n    has Real $.x is rw;\n    has Real $.y is rw;\n    method gist { [~] '(', self.x,', ', self.y, ')' };\n}\n\nsub ccw (Point $a, Point $b, Point $c) {\n    ($b.x - $a.x)*($c.y - $a.y) - ($b.y - $a.y)*($c.x - $a.x);\n}\n\nsub tangent (Point $a, Point $b) {\n    my $opp = $b.x - $a.x;\n    my $adj = $b.y - $a.y;\n    $adj != 0 ?? $opp / $adj !! Inf\n}\n\nsub graham-scan (**@coords) {\n    # sort points by y, secondary sort on x\n    my @sp = @coords.map( { Point.new( :x($_[0]), :y($_[1]) ) } )\n                    .sort: {.y, .x};\n\n    # need at least 3 points to make a hull\n    return @sp if +@sp < 3;\n\n    # first point on hull is minimum y point\n    my @h  = @sp.shift;\n\n    # re-sort the points by angle, secondary on x\n    @sp    = @sp.map( { $++ => [tangent(@h[0], $_), $_.x] } )\n                .sort( {-$_.value[0], $_.value[1] } )\n                .map: { @sp[$_.key] };\n\n    # first point of re-sorted list is guaranteed to be on hull\n    @h.push:  @sp.shift;\n\n    # check through the remaining list making sure that\n    # there is always a positive angle\n    for @sp -> $point {\n        if ccw( |@h.tail(2), $point ) > 0 {\n            @h.push: $point;\n        } else {\n            @h.pop;\n            @h.push: $point and next if +@h < 2;\n            redo;\n        }\n    }\n    @h\n}\n\nmy @hull = graham-scan(\n    (16, 3), (12,17), ( 0, 6), (-4,-6), (16, 6), (16,-7), (16,-3),\n    (17,-4), ( 5,19), (19,-8), ( 3,16), (12,13), ( 3,-4), (17, 5),\n    (-3,15), (-3,-9), ( 0,11), (-9,-3), (-4,-2), (12,10)\n  );\n\nsay \"Convex Hull ({+@hull} points): \", @hull;\n\n@hull = graham-scan(\n    (16, 3), (12,17), ( 0, 6), (-4,-6), (16, 6), (16,-7), (16,-3),\n    (17,-4), ( 5,19), (19,-8), ( 3,16), (12,13), ( 3,-4), (17, 5),\n    (-3,15), (-3,-9), ( 0,11), (-9,-3), (-4,-2), (12,10), (20,-9), (1,-9)\n  );\n\nsay \"Convex Hull ({+@hull} points): \", @hull;\n\n```\n\nOutput:\n\n```\nConvex Hull (7 points): [(-3, -9) (19, -8) (17, 5) (12, 17) (5, 19) (-3, 15) (-9, -3)]\nConvex Hull (7 points): [(-3, -9) (20, -9) (17, 5) (12, 17) (5, 19) (-3, 15) (-9, -3)]\n```"}]}
{"messages": [{"role": "user", "content": "The **Game of Life** is a   cellular automaton   devised by the British mathematician   John Horton Conway   in 1970.   It is the best-known example of a cellular automaton.\n\nConway's game of life is described   here:\n\nA cell   **C**   is represented by a   **1**   when alive,   or   **0**   when dead,   in an   m-by-m   (or m×m)   square array of cells.\n\nWe calculate   **N**   - the sum of live cells in C's   eight-location neighbourhood,   then cell   C   is alive or dead in the next generation based on the following table:\n\n```\n   C   N                 new C\n   1   0,1             ->  0  # Lonely\n   1   4,5,6,7,8       ->  0  # Overcrowded\n   1   2,3             ->  1  # Lives\n   0   3               ->  1  # It takes three to give birth!\n   0   0,1,2,4,5,6,7,8 ->  0  # Barren\n\n```\n\nAssume cells beyond the boundary are always dead.\n\nThe \"game\" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players.   One interacts with the Game of Life by creating an initial configuration and observing how it evolves.\n\nTask\n\nAlthough you should test your implementation on more complex examples such as the   glider   in a larger universe,   show the action of the blinker   (three adjoining cells in a row all alive),   over three generations, in a 3 by 3 grid.\n\nReferences\n\n* Its creator John Conway, explains   the game of life.   Video from numberphile on youtube.\n* John Conway   Inventing Game of Life   - Numberphile video.\n\nRelated task\n\n* Langton's ant   - another well known cellular automaton."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nclass Automaton {\n    subset World of Str where {\n        .lines>>.chars.unique == 1 and m/^^<[.#\\n]>+$$/\n    }\n    has Int ($.width, $.height);\n    has @.a;\n\n    multi method new (World $s) {\n        self.new:\n            :width(.pick.chars), :height(.elems),\n            :a( .map: { [ .comb ] } )\n                given $s.lines.cache;\n    }\n\n    method gist { join \"\\n\", map { .join }, @!a }\n\n    method C (Int $r, Int $c --> Bool) {\n        @!a[$r % $!height][$c % $!width] eq '#';\n    }\n    method N (Int $r, Int $c --> Int) {\n        +grep ?*, map { self.C: |@$_ },\n            [ $r - 1, $c - 1], [ $r - 1, $c ], [ $r - 1, $c + 1],\n            [ $r    , $c - 1],                 [ $r    , $c + 1],\n            [ $r + 1, $c - 1], [ $r + 1, $c ], [ $r + 1, $c + 1];\n    }\n\n    method succ {\n        self.new: :$!width, :$!height,\n            :a(\n                gather for ^$.height -> $r {\n                    take [\n                        gather for ^$.width -> $c {\n                            take\n                            (self.C($r, $c) == 1 && self.N($r, $c) == 2|3)\n                                || (self.C($r, $c) == 0 && self.N($r, $c) == 3)\n                            ?? '#' !! '.'\n                        }\n                    ]\n                }\n            )\n    }\n}\n\nmy Automaton $glider .= new: q:to/EOF/;\n    ............\n    ............\n    ............\n    .......###..\n    .###...#....\n    ........#...\n    ............\n    EOF\n\n\nfor ^10 {\n    say $glider++;\n    say '--';\n}\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nStarting from the sequence a(1)=1 and a(2)=2 find the next smallest number which is coprime to the last two predecessors and has not yet appeared yet in the sequence.\n  \np and q are coprimes if they have no common factors other than 1.\n  \n Let **p, q < 50**"}, {"role": "assistant", "content": "```\nmy @coprime-triplets = 1, 2, {\n   state %seen = 1, True, 2, True;\n   state $min = 3;\n   my $g = $^a * $^b;\n   my $n = ($min .. *).first: { !%seen{$_} && ($_ gcd $g == 1) }\n   %seen{$n} = True;\n   if %seen.elems %% 100 { $min = ($min .. *).first: { !%seen{$_} } }\n   $n\n} … *;\n\nput \"Coprime triplets before first > 50:\\n\",\n@coprime-triplets[^(@coprime-triplets.first: * > 50, :k)].batch(10)».fmt(\"%4d\").join: \"\\n\";\n\nput \"\\nOr maybe, minimum Coprime triplets that encompass 1 through 50:\\n\",\n@coprime-triplets[0..(@coprime-triplets.first: * == 42, :k)].batch(10)».fmt(\"%4d\").join: \"\\n\";\n\nput \"\\nAnd for the heck of it: 1001st through 1050th Coprime triplet:\\n\",\n@coprime-triplets[1000..1049].batch(10)».fmt(\"%4d\").join: \"\\n\";\n\n```\n\nOutput:\n\n```\nCoprime triplets before first > 50:\n   1    2    3    5    4    7    9    8   11   13\n   6   17   19   10   21   23   16   15   29   14\n  25   27   22   31   35   12   37   41   18   43\n  47   20   33   49   26   45\n\nOr maybe, minimum Coprime triplets that encompass 1 through 50:\n   1    2    3    5    4    7    9    8   11   13\n   6   17   19   10   21   23   16   15   29   14\n  25   27   22   31   35   12   37   41   18   43\n  47   20   33   49   26   45   53   28   39   55\n  32   51   59   38   61   63   34   65   57   44\n  67   69   40   71   73   24   77   79   30   83\n  89   36   85   91   46   75   97   52   81   95\n  56   87  101   50   93  103   58   99  107   62\n 105  109   64  111  113   68  115  117   74  119\n 121   48  125  127   42\n\nAnd for the heck of it: 1001st through 1050th Coprime triplet:\n 682 1293 1361  680 1287 1363  686 1299 1367  688\n1305 1369  692 1311 1373  694 1317 1375  698 1323\n1381  704 1329 1379  706 1335 1387  716 1341 1385\n 712 1347 1391  700 1353 1399  710 1359 1393  718\n1371 1397  722 1365 1403  724 1377 1405  728 1383\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n**p**   and   **q**   are   coprimes   if they have no common factors other than   **1**.\n\nGiven the input pairs:   [21,15],[17,23],[36,12],[18,29],[60,15] display whether they are coprimes."}, {"role": "assistant", "content": "How do you determine if numbers are co-prime? Check to see if the Greatest common divisor is equal to one. Since we're duplicating tasks willy-nilly, lift code from that task, (or in this case, just use the builtin).\n\n```\nsay .raku, ( [gcd] |$_ ) == 1 ?? ' Coprime' !! '' for [21,15],[17,23],[36,12],[18,29],[60,15],[21,22,25,31,143]\n\n```\n\n```\n[21, 15]\n[17, 23] Coprime\n[36, 12]\n[18, 29] Coprime\n[60, 15]\n[21, 22, 25, 31, 143] Coprime\n```"}]}
{"messages": [{"role": "user", "content": "This task is about copying a string.\n\nTask\n\nWhere it is relevant, distinguish between copying the contents of a string\nversus making an additional reference to an existing string.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThere is no special handling needed to copy a string; just assign it to a new variable:\n\n```\nmy $original = 'Hello.';\nmy $copy = $original;\nsay $copy;            # prints \"Hello.\"\n$copy = 'Goodbye.';\nsay $copy;            # prints \"Goodbye.\"\nsay $original;        # prints \"Hello.\"\n```\n\nYou can also bind a new variable to an existing one so that each refers to, and can modify the same string.\n\n```\nmy $original = 'Hello.';\nmy $bound := $original;\nsay $bound;           # prints \"Hello.\"\n$bound = 'Goodbye.';\nsay $bound;           # prints \"Goodbye.\"\nsay $original;        # prints \"Goodbye.\"\n```"}]}
{"messages": [{"role": "user", "content": "Create an executable file that copies stdin to stdout, or else a script that does so through the invocation of an interpreter at the command line."}, {"role": "assistant", "content": "(formerly Perl 6)\nWhen invoked at a command line: Slightly less magical than Perl / sed. The p flag means automatically print each line of output to STDOUT. The e flag means execute what follows inside quotes. \".lines\" reads lines from the assigned pipe (file handle), STDIN by default.\n\n```\nraku -pe'.lines'\n\n```\n\nWhen invoked from a file: Lines are auto-chomped, so need to re-add newlines (hence .say rather than .print)\n\n```\n.say for lines\n\n```"}]}
{"messages": [{"role": "user", "content": "Introduction\n\nCORDIC is the name of an algorithm for calculating trigonometric, logarithmic and hyperbolic functions, named after its first application on an airborne computer (COordinate Rotation DIgital Computer) in 1959.\nUnlike a Taylor expansion or polynomial approximation, it converges rapidly on machines with low computing and memory capacities: to calculate a tangent with 10 significant digits, it requires only 6 floating-point constants, and only additions, subtractions and digit shifts in its iterative part.\n\nIt is valid for angle values between 0 and π/2 only, but whatever the value of an angle, the calculation of its tangent can always be reduced to that of an angle between 0 and π/2, using trigonometric identities. Similarly, once you know the tangent, you can easily calculate the sine or cosine.\n\nPseudo code\n\n```\nconstant θ[n] = arctan 10^(-n) // or simply 10^(-n) depending on floating point precision \nconstant epsilon = 10^-12\n\nfunction tan(alpha)            // 0 < alpha <= π/2 \n  x = 1 ; y = 0 ; k = 0\n  while epsilon < alpha\n    while alpha < θ[k] \n       k++\n    end loop\n    alpha -= θ[k]\n    x2 = x - 10^(-k)*y\n    y2 = y + 10^(-k)*x\n    x = x2 ; y = y2\n  end loop\n  return (y/x)\nend function\n\n```\n\nTask\n\n* Implement the CORDIC algorithm, using only the 4 arithmetic operations and right shifts in the main loop if possible.\n* Use your implementation to calculate the cosine of the following angles, expressed in radians: -9, 0, 1.5 and 6\n\nSee also\n\nCORDIC on Wikipedia"}, {"role": "assistant", "content": "**Translation of**: XPL0\n\n```\n# 2023082 Raku programming solution\n\nsub CORDIC ($A is copy) {\n\n   my (\\Ten, $K, $X, $Y) = ( 1, * * 1/10 ... * )[^6], 0, 1, 0;\n\n   my \\Tbl = < 7.853981633974480e-1 9.966865249116200e-2 9.999666686665240e-3 \n               9.999996666668670e-4 9.999999966666670e-5 9.999999999666670e-6 0.0>;\n\n   while $A > 1e-5 { \n      $K++ while $A < Tbl[$K];\n      $A -= Tbl[$K];\n      ($X,$Y) = $X - Ten[$K]*$Y, $Y + Ten[$K]*$X;\n   }\n   return $X, sqrt($X*$X + $Y*$Y)\n}\n\nsay \"Angle    CORDIC       Cosine       Error\";\nfor <-9 0 1.5 6> { \n   my \\result = [/] CORDIC .abs;\n   printf \"% 2.1f  \"~\"% 2.8f  \" x 3~\"\\n\", $_, result, .cos, .cos - result\n}\n\n```\n\nOutput:\n\nSame as XPL0 or you may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task\n:   Count how many vowels and consonants occur in a string\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "Note that the task **does not** ask for the **total count** of vowels and consonants, but for **how many** occur.\n\n```\nmy @vowels     = <a e i o u>;\nmy @consonants = <b c d f g h j k l m n p q r s t v w x y z>;\n\nsub letter-check ($string) {\n    my $letters = $string.lc.comb.Set;\n    \"{sum $letters{@vowels}} vowels and {sum $letters{@consonants}} consonants occur in the string \\\"$string\\\"\";\n}\n\nsay letter-check \"Forever Ring Programming Language\";\n\n```\n\nOutput:\n\n```\n5 vowels and 8 consonants occur in the string \"Forever Ring Programming Language\"\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program which counts up from   **1**,   displaying each number as the multiplication of its prime factors.\n\nFor the purpose of this task,   **1**   (unity)   may be shown as itself.\n\nExample\n\n**2**   is prime,   so it would be shown as itself.\n  \n      **6**   is not prime;   it would be shown as   **2\n×\n3\n{\\displaystyle {\\displaystyle 2\\times 3}}\n.**\n  \n**2144**   is not prime;   it would be shown as   **2\n×\n2\n×\n2\n×\n2\n×\n2\n×\n67\n{\\displaystyle {\\displaystyle 2\\times 2\\times 2\\times 2\\times 2\\times 67}}\n.**\n\nRelated tasks\n\n* prime decomposition\n* factors of an integer\n* Sieve of Eratosthenes\n* primality by trial division\n* factors of a Mersenne number\n* trial factoring of a Mersenne number\n* partition an integer X into N primes"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-10-01\n\n```\nconstant @primes = 2, |(3, 5, 7 ... *).grep: *.is-prime;\n\nmulti factors(1) { 1 }\nmulti factors(Int $remainder is copy) {\n  gather for @primes -> $factor {\n\n    # if remainder < factor², we're done\n    if $factor * $factor > $remainder {\n      take $remainder if $remainder > 1;\n      last;\n    }\n\n    # How many times can we divide by this prime?\n    while $remainder %% $factor {\n        take $factor;\n        last if ($remainder div= $factor) === 1;\n    }\n  }\n}\n\nsay \"$_: \", factors($_).join(\" × \") for 1..*;\n\n```\n\nThe first twenty numbers:\n\n```\n1: 1\n2: 2\n3: 3\n4: 2 × 2\n5: 5\n6: 2 × 3\n7: 7\n8: 2 × 2 × 2\n9: 3 × 3\n10: 2 × 5\n11: 11\n12: 2 × 2 × 3\n13: 13\n14: 2 × 7\n15: 3 × 5\n16: 2 × 2 × 2 × 2\n17: 17\n18: 2 × 3 × 3\n19: 19\n20: 2 × 2 × 5\n```\n\nHere we use a multi declaration with a constant parameter to match the degenerate case. We use copy parameters when we wish to reuse the formal parameter as a mutable variable within the function. (Parameters default to readonly in Raku.) Note the use of gather/take as the final statement in the function, which is a common Raku idiom to set up a coroutine within a function to return a lazy list on demand.\n\nNote also the '×' above is not ASCII 'x', but U+00D7 MULTIPLICATION SIGN. Raku does Unicode natively.\n\nHere is a solution inspired from Almost\\_prime#C. It doesn't use &is-prime.\n\n```\nsub factor($n is copy) {\n    $n == 1 ?? 1 !!\n    gather {\n\t$n /= take 2 while $n %% 2;\n\t$n /= take 3 while $n %% 3;\n\tloop (my $p = 5; $p*$p <= $n; $p+=2) {\n\t    $n /= take $p while $n %% $p;\n\t}\n\ttake $n unless $n == 1;\n    }\n}\n\nsay \"$_ == \", join \" \\x00d7 \", factor $_ for 1 .. 20;\n\n```\n\nSame output as above.\n\nAlternately, use a module:\n\n```\nuse Prime::Factor;\n\nsay \"$_ = {(.&prime-factors || 1).join: ' x ' }\" for flat 1 .. 10, 10**20 .. 10**20 + 10;\n\n```\n\nOutput:\n\n```\n1 = 1\n2 = 2\n3 = 3\n4 = 2 x 2\n5 = 5\n6 = 2 x 3\n7 = 7\n8 = 2 x 2 x 2\n9 = 3 x 3\n10 = 2 x 5\n100000000000000000000 = 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5\n100000000000000000001 = 73 x 137 x 1676321 x 5964848081\n100000000000000000002 = 2 x 3 x 155977777 x 106852828571\n100000000000000000003 = 373 x 155773 x 1721071782307\n100000000000000000004 = 2 x 2 x 13 x 1597 x 240841 x 4999900001\n100000000000000000005 = 3 x 5 x 7 x 7 x 83 x 1663 x 985694468327\n100000000000000000006 = 2 x 31 x 6079 x 265323774602147\n100000000000000000007 = 67 x 166909 x 8942221889969\n100000000000000000008 = 2 x 2 x 2 x 3 x 3 x 3 x 233 x 1986965506278811\n100000000000000000009 = 557 x 72937 x 2461483384901\n100000000000000000010 = 2 x 5 x 11 x 909090909090909091\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nProduce a sequential count in octal,   starting at zero,   and using an increment of a one for each consecutive number.\n\nEach number should appear on a single line,   and the program should count until terminated,   or until the maximum value of the numeric type in use is reached.\n\nRelated task\n\n* Integer sequence   is a similar task without the use of octal numbers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsay .base(8) for ^Inf;\n\n```\n\nOutput:\n\n```\n0\n```\n\nHere we arbitrarily show as many lines of output as there are lines in the program. :-)"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a function,   or show a built-in function,   to count the number of non-overlapping occurrences of a substring inside a string.\n\nThe function should take two arguments:\n\n:   :   :   * the first argument being the string to search,   and\n            * the second a substring to be searched for.\n\nIt should return an integer count.\n\n```\nprint countSubstring(\"the three truths\",\"th\")\n3\n\n// do not count substrings that overlap with previously-counted substrings:\nprint countSubstring(\"ababababab\",\"abab\")\n2\n```\n\nThe matching should yield the highest number of non-overlapping matches.\n\nIn general, this essentially means matching from left-to-right or right-to-left   (see proof on talk page).\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub count-substring($big, $little) { +$big.comb: / :r $little / }\n \nsay count-substring(\"the three truths\", \"th\"); # 3\nsay count-substring(\"ababababab\", \"abab\");     # 2\n \nsay count-substring(123123123, 12);            # 3\n```\n\nThe :r adverb makes the regex \"ratchet forward\" and skip any overlapping matches. .comb - when given a Regex as an argument - returns instances of that substring. Also, prefix + forces numeric context in Raku (it's a no-op in Perl 5). For the built in listy types that is the same as calling .elems method. One other style point: we now tend to prefer hyphenated names over camelCase."}]}
{"messages": [{"role": "user", "content": "There are four types of common coins in   US   currency:\n\n:   :   :   1. quarters   (25 cents)\n            2. dimes   (10 cents)\n            3. nickels   (5 cents),   and\n            4. pennies   (1 cent)\n\nThere are six ways to make change for 15 cents:\n\n:   :   :   1. A dime and a nickel\n            2. A dime and 5 pennies\n            3. 3 nickels\n            4. 2 nickels and 5 pennies\n            5. A nickel and 10 pennies\n            6. 15 pennies\n\nTask\n\nHow many ways are there to make change for a dollar using these common coins?     (1 dollar = 100 cents).\n\nOptional\n\nLess common are dollar coins (100 cents);   and very rare are half dollars (50 cents).   With the addition of these two coins, how many ways are there to make change for $1000?\n\n(Note:   the answer is larger than   232).\n\nReferences\n\n* an algorithm from the book *Structure and Interpretation of Computer Programs*.\n* an article in the algorithmist.\n* Change-making problem on Wikipedia."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.10\n\n**Translation of**: Ruby\n\n```\n# Recursive (cached)\nsub change-r($amount, @coins) {\n    my @cache = [1 xx @coins], |([] xx $amount);\n\n    multi ways($n where $n >= 0, @now [$coin,*@later]) {\n        @cache[$n;+@later] //= ways($n - $coin, @now) + ways($n, @later);\n    }\n    multi ways($,@) { 0 }\n\n    # more efficient to start with coins sorted in descending order\n    ways($amount, @coins.sort(-*).list);\n}\n\n# Iterative\nsub change-i(\\n, @coins) {\n    my @table = [1 xx @coins], [0 xx @coins] xx n;\n    (1..n).map: -> \\i {\n        for ^@coins -> \\j {\n        my \\c = @coins[j];\n        @table[i;j] = [+]\n            @table[i - c;j] // 0,\n            @table[i;j - 1] // 0;\n        }\n    }\n    @table[*-1][*-1];\n}\n\nsay \"Iterative:\";\nsay change-i    1_00, [1,5,10,25];\nsay change-i 1000_00, [1,5,10,25,50,100];\n\nsay \"\\nRecursive:\";\nsay change-r    1_00, [1,5,10,25];\nsay change-r 1000_00, [1,5,10,25,50,100];\n\n```\n\nOutput:\n\n```\nIterative:\n242\n13398445413854501\n\nRecursive:\n242\n13398445413854501\n```"}]}
{"messages": [{"role": "user", "content": "Let say you have some coins in your wallet and you want to have a given sum.\n\nYou can use each coin zero or one time.\n\nHow many ways can you do it ?\n\nThe result should be a number.\n\nFor instance the answer is 10 when coins = [1, 2, 3, 4, 5] and sum = 6.\n\nTask\n\nShow the result for the following examples:\n\n* coins = [1, 2, 3, 4, 5] and sum = 6\n\n* coins = [1, 1, 2, 3, 3, 4, 5] and sum = 6\n\n* coins = [1, 2, 3, 4, 5, 5, 5, 5, 15, 15, 10, 10, 10, 10, 25, 100] and sum = 40\n\nExtra\n\n* Show the result of the same examples when the order you take the coins doesn't matter. For instance the answer is 3 when coins = [1, 2, 3, 4, 5] and sum = 6.\n\n* Show an example of coins you used to reach the given sum and their indices. See Raku for this case."}, {"role": "assistant", "content": "First part is combinations filtered on a certain property. Second part (extra credit) is permutations of those combinations.\n\nThis is pretty much duplicating other tasks, in process if not wording. Even though I am adding a solution, my vote would be for deletion as it doesn't really add anything to the other tasks; Combinations, Permutations, Subset sum problem and to a large extent 4-rings or 4-squares puzzle.\n\n```\nfor <1 2 3 4 5>, 6\n   ,<1 1 2 3 3 4 5>, 6\n   ,<1 2 3 4 5 5 5 5 15 15 10 10 10 10 25 100>, 40\n  -> @items, $sum {\n\n    put \"\\n\\nHow many combinations of [{ @items.join: ', ' }] sum to $sum?\";\n\n    given ^@items .combinations.grep: { @items[$_].sum == $sum } {\n        .&display;\n        display .race.map( { Slip(.permutations) } ), '';\n    }\n}\n\nsub display ($list, $un = 'un') {\n    put \"\\nOrder {$un}important:\\nCount: { +$list }\\nIndices\" ~ ( +$list > 10 ?? ' (10 random examples):' !! ':' );\n    put $list.pick(10).sort».join(', ').join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\nHow many combinations of [1, 2, 3, 4, 5] sum to 6?\n\nOrder unimportant:\nCount: 3\nIndices:\n0, 1, 2\n0, 4\n1, 3\n\nOrder important:\nCount: 10\nIndices:\n0, 1, 2\n0, 2, 1\n0, 4\n1, 0, 2\n1, 2, 0\n1, 3\n2, 0, 1\n2, 1, 0\n3, 1\n4, 0\n\n\nHow many combinations of [1, 1, 2, 3, 3, 4, 5] sum to 6?\n\nOrder unimportant:\nCount: 9\nIndices:\n0, 1, 5\n0, 2, 3\n0, 2, 4\n0, 6\n1, 2, 3\n1, 2, 4\n1, 6\n2, 5\n3, 4\n\nOrder important:\nCount: 38\nIndices (10 random examples):\n0, 4, 2\n1, 2, 3\n1, 2, 4\n1, 5, 0\n1, 6\n2, 1, 3\n2, 1, 4\n2, 4, 0\n3, 2, 0\n6, 0\n\n\nHow many combinations of [1, 2, 3, 4, 5, 5, 5, 5, 15, 15, 10, 10, 10, 10, 25, 100] sum to 40?\n\nOrder unimportant:\nCount: 464\nIndices (10 random examples):\n0, 1, 2, 3, 5, 7, 10, 11\n0, 1, 2, 3, 5, 8, 12\n0, 1, 2, 3, 6, 7, 11, 13\n0, 3, 5, 7, 9, 13\n0, 3, 9, 10, 11\n1, 2, 5, 7, 9, 13\n4, 5, 10, 12, 13\n5, 6, 7, 9, 10\n5, 6, 10, 11, 12\n5, 8, 10, 12\n\nOrder important:\nCount: 3782932\nIndices (10 random examples):\n0, 11, 3, 4, 7, 5, 6, 1, 2\n1, 10, 5, 4, 6, 2, 0, 3, 7\n2, 7, 13, 4, 1, 3, 5, 6, 0\n2, 12, 4, 13, 10, 1\n3, 0, 5, 4, 7, 13, 6, 2, 1\n5, 7, 9, 4, 0, 1, 2, 3\n6, 2, 7, 11, 0, 3, 5, 1, 4\n10, 0, 12, 6, 5, 3, 4\n13, 0, 1, 5, 7, 3, 2, 12\n13, 6, 10, 1, 4, 3, 2, 0\n```"}]}
{"messages": [{"role": "user", "content": "It is conjectured that each decimal digit will occur with the same frequency in the mathematical constant e, see: the Wikipedia page on e.  \nThis task is to count and display (here on this page) how many times each digit occurs, up to some \"large\" number of fractional digits.\n\nNotes\n\nA B program to calculate the first 4000 fractional digits is on the Wikipedia here: B (programming language)  \nThe algorithm shown is from Ken Thompson's *Users' Reference to B* manual and does not require big-integers.\n\nThis Redit article draws a graph of the first 100 digits."}, {"role": "assistant", "content": "```\nconstant 𝑒 = [\\+] flat 1, [\\/] 1.FatRat..*;\n\nsub e-count ($n) {\n    my @digits = 𝑒[$n / 2.7].substr(0,$n+1).comb.classify(*).sort.skip(1).map: {.key => .value.elems};\n   .say for @digits;\n   say 'Total digits: ', @digits».value.sum;\n   say '';\n}\n\n.&e-count for 4000, 6000;\n\n```\n\nOutput:\n\n```\n0 => 396\n1 => 395\n2 => 390\n3 => 403\n4 => 387\n5 => 390\n6 => 422\n7 => 408\n8 => 397\n9 => 412\nTotal digits: 4000\n\n0 => 602\n1 => 592\n2 => 604\n3 => 625\n4 => 559\n5 => 586\n6 => 644\n7 => 600\n8 => 597\n9 => 591\nTotal digits: 6000\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven six numbers randomly selected from the list [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 25, 50, 75, 100], calculate using only positive integers and four operations [+, -, \\*, /] a random number between 101 and 999.\n\nExample:\n\nUsing: [3, 6, 25, 50, 75, 100]  \nTarget: 952\n\nSolution:\n\n* 100 + 6 = 106\n* 75 \\* 3 = 225\n* 106 \\* 225 = 23850\n* 23850 - 50 = 23800\n* 23800 / 25 = 952\n\nOrigins\n\nThis is originally a 1972 French television game show. The game consists of randomly selecting six of the twenty-four numbers, from a list of: twenty \"small numbers\" (two each from 1 to 10), and four \"large numbers\" of 25, 50, 75 and 100. A random target number between 101 and 999 is generated. The players have 30 seconds to work out a sequence of calculations with the numbers whose final result is as close as possible to the target number. Only the four basic operations: addition, subtraction, multiplication and division can be used to create new numbers and not all six numbers are required. A number can only be used once. Division can only be done if the result has no remainder (fractions are not allowed) and only positive integers can be obtained at any stage of the calculation. (More info on the original game).\n\nExtra challenge\n\nThe brute force algorithm is quite obvious. What is more interesting is to find some optimisation heuristics to reduce the number of calculations. For example, a rather interesting computational challenge is to calculate, as fast as possible, all existing solutions (that means 2'764'800 operations) for all possible games (with all the 13'243 combinations of six numbers out of twenty-four for all 898 possible targets between 101 and 999)."}, {"role": "assistant", "content": "**Translation of**: Wren\n\n```\n# 20221021 Raku programming solution\n\nsub countdown ($target, @numbers) {\n   return False if @numbers.elems == 1;\n   for @numbers.kv -> \\n0k,\\n0v {\n      (my @nums1 = @numbers).splice(n0k,1);\n      for @nums1.kv -> \\n1k,\\n1v {\n         (my @nums2 = @nums1).splice(n1k,1);\n         if n1v >= n0v {\n            (my @numsNew = @nums2).append: my $res = n1v + n0v; \n            if ($res == $target or countdown($target, @numsNew)) {\n               say \"$res = \",n1v,' + ',n0v andthen return True\n            }\n\t        if n0v != 1 {\n               (my @numsNew = @nums2).append: my $res = n1v * n0v;\t\n\t           if ($res == $target or countdown($target, @numsNew)) {\n                  say \"$res = \",n1v,' * ',n0v andthen return True\n\t           }\n            }\n            if n1v != n0v {\n\t           (my @numsNew = @nums2).append: my $res = n1v - n0v;\n\t           if ($res == $target or countdown($target, @numsNew)) {\n                  say \"$res = \",n1v,' - ',n0v andthen return True\n               }\n            }\n            if n0v != 1 and n1v %% n0v {\n               (my @numsNew = @nums2).append: my $res = n1v div n0v;\n               if ($res == $target or countdown($target, @numsNew)) {\n                  say \"$res = \",n1v,' / ',n0v andthen return True\n               }\n            }\n         }\n      }\n   }\n   return False\n}\n\nmy @allNumbers  = < 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 25 50 75 100 >;\nmy @numbersList = <3 6 25 50 75 100>  ,   <100 75 50 25 6 3>, \n                  <8 4 4 6 8 9>       ,   @allNumbers.pick(6);\nmy @targetList  = 952, 952, 594, (101..1000).pick;\n\nfor (0..^+@numbersList) -> \\i {\n   say \"Using : \", my @numbers = |@numbersList[i];\n   say \"Target: \", my $target  = @targetList[i];\n   say \"No exact solution found\" unless countdown $target, @numbers;\n   say() \n}\n\n```\n\nOutput:\n\n```\nUsing : [3 6 25 50 75 100]\nTarget: 952\n952 = 23800 / 25\n23800 = 23850 - 50\n23850 = 225 * 106\n106 = 100 + 6\n225 = 75 * 3\n\nUsing : [100 75 50 25 6 3]\nTarget: 952\n952 = 23800 / 25\n23800 = 23850 - 50\n23850 = 7950 * 3\n7950 = 106 * 75\n106 = 100 + 6\n\nUsing : [8 4 4 6 8 9]\nTarget: 594\n594 = 66 * 9\n66 = 64 + 2\n64 = 16 * 4\n2 = 6 - 4\n16 = 8 + 8\n\nUsing : [100 9 50 2 9 8]\nTarget: 599\n599 = 590 + 9\n590 = 59 * 10\n10 = 8 + 2\n59 = 109 - 50\n109 = 100 + 9\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nIn mathematics, **cousin primes** are prime numbers that differ by four.\n\nFor the purposes of this task a **cousin prime pair** is a pair of non-negative integers of the form [n, n + 4] whose elements are both primes.\n\nTask\n\nWrite a program to determine (and show here) all **cousin prime pairs** whose elements are both less than **1,000**.\n\nOptionally, show the **number** of such pairs.\n\nAlso see\n:   * the Wikipedia entry:   cousin prime.\n    * the OEIS entry:   A094343.\n    * the MathWorld entry:   cousin primes."}, {"role": "assistant", "content": "### Filter\n\nFavoring brevity over efficiency due to the small range of n, the most concise solution is:\n\n```\nsay grep *.all.is-prime, map { $_, $_+4 }, 2..999;\n\n```\n\nOutput:\n\n```\n((3 7) (7 11) (13 17) (19 23) (37 41) (43 47) (67 71) (79 83) (97 101) (103 107) (109 113) (127 131) (163 167) (193 197) (223 227) (229 233) (277 281) (307 311) (313 317) (349 353) (379 383) (397 401) (439 443) (457 461) (463 467) (487 491) (499 503) (613 617) (643 647) (673 677) (739 743) (757 761) (769 773) (823 827) (853 857) (859 863) (877 881) (883 887) (907 911) (937 941) (967 971))\n\n```\n\n### Infinite List\n\nA more efficient and versatile approach is to generate an infinite list of cousin primes, using this info from https://oeis.org/A023200 :\n\n:   Apart from the first term, all terms are of the form 6n + 1.\n\n```\nconstant @cousins = (3, 7, *+6 … *).map: -> \\n { (n, n+4) if (n & n+4).is-prime };\n\nmy $count = @cousins.first: :k, *.[0] > 1000;\n\n.say for @cousins.head($count).batch(9);\n\n```\n\nOutput:\n\n```\n((3 7) (7 11) (13 17) (19 23) (37 41) (43 47) (67 71) (79 83) (97 101))\n((103 107) (109 113) (127 131) (163 167) (193 197) (223 227) (229 233) (277 281) (307 311))\n((313 317) (349 353) (379 383) (397 401) (439 443) (457 461) (463 467) (487 491) (499 503))\n((613 617) (643 647) (673 677) (739 743) (757 761) (769 773) (823 827) (853 857) (859 863))\n((877 881) (883 887) (907 911) (937 941) (967 971))\n```"}]}
{"messages": [{"role": "user", "content": "In linear algebra, Cramer's rule is an explicit formula for the solution of a system of linear equations with as many equations as unknowns, valid whenever the system has a unique solution. It expresses the solution in terms of the determinants of the (square) coefficient matrix and of matrices obtained from it by replacing one column by the vector of right hand sides of the equations.\n\nGiven\n\n:   {\n\n    a\n\n    1\n    x\n    +\n\n    b\n\n    1\n    y\n    +\n\n    c\n\n    1\n    z\n\n    =\n\n    d\n\n    1\n\n    a\n\n    2\n    x\n    +\n\n    b\n\n    2\n    y\n    +\n\n    c\n\n    2\n    z\n\n    =\n\n    d\n\n    2\n\n    a\n\n    3\n    x\n    +\n\n    b\n\n    3\n    y\n    +\n\n    c\n\n    3\n    z\n\n    =\n\n    d\n\n    3\n\n    {\\displaystyle {\\displaystyle \\left\\{{\\begin{matrix}a\\_{1}x+b\\_{1}y+c\\_{1}z&={\\color {red}d\\_{1}}\\\\a\\_{2}x+b\\_{2}y+c\\_{2}z&={\\color {red}d\\_{2}}\\\\a\\_{3}x+b\\_{3}y+c\\_{3}z&={\\color {red}d\\_{3}}\\end{matrix}}\\right.}}\n\nwhich in matrix format is\n\n:   [\n\n    a\n\n    1\n\n\n    b\n\n    1\n\n\n    c\n\n    1\n\n    a\n\n    2\n\n\n    b\n\n    2\n\n\n    c\n\n    2\n\n    a\n\n    3\n\n\n    b\n\n    3\n\n\n    c\n\n    3\n    ]\n\n\n    [\n\n    x\n\n\n    y\n\n\n    z\n    ]\n    =\n\n\n    [\n\n    d\n\n    1\n\n    d\n\n    2\n\n    d\n\n    3\n    ]\n    .\n    {\\displaystyle {\\displaystyle {\\begin{bmatrix}a\\_{1}&b\\_{1}&c\\_{1}\\\\a\\_{2}&b\\_{2}&c\\_{2}\\\\a\\_{3}&b\\_{3}&c\\_{3}\\end{bmatrix}}{\\begin{bmatrix}x\\\\y\\\\z\\end{bmatrix}}={\\begin{bmatrix}{\\color {red}d\\_{1}}\\\\{\\color {red}d\\_{2}}\\\\{\\color {red}d\\_{3}}\\end{bmatrix}}.}}\n\nThen the values of \n\nx\n,\ny\n{\\displaystyle {\\displaystyle x,y}}\n and \n\nz\n{\\displaystyle {\\displaystyle z}}\n can be found as follows:\n\n:   x\n    =\n\n    |\n\n    d\n\n    1\n\n\n    b\n\n    1\n\n\n    c\n\n    1\n\n    d\n\n    2\n\n\n    b\n\n    2\n\n\n    c\n\n    2\n\n    d\n\n    3\n\n\n    b\n\n    3\n\n\n    c\n\n    3\n    |\n\n    |\n\n    a\n\n    1\n\n\n    b\n\n    1\n\n\n    c\n\n    1\n\n    a\n\n    2\n\n\n    b\n\n    2\n\n\n    c\n\n    2\n\n    a\n\n    3\n\n\n    b\n\n    3\n\n\n    c\n\n    3\n    |\n    ,\n\n    y\n    =\n\n    |\n\n    a\n\n    1\n\n    d\n\n    1\n\n\n    c\n\n    1\n\n    a\n\n    2\n\n    d\n\n    2\n\n\n    c\n\n    2\n\n    a\n\n    3\n\n    d\n\n    3\n\n\n    c\n\n    3\n    |\n\n    |\n\n    a\n\n    1\n\n\n    b\n\n    1\n\n\n    c\n\n    1\n\n    a\n\n    2\n\n\n    b\n\n    2\n\n\n    c\n\n    2\n\n    a\n\n    3\n\n\n    b\n\n    3\n\n\n    c\n\n    3\n    |\n    ,\n\n     and \n    z\n    =\n\n    |\n\n    a\n\n    1\n\n\n    b\n\n    1\n\n    d\n\n    1\n\n    a\n\n    2\n\n\n    b\n\n    2\n\n    d\n\n    2\n\n    a\n\n    3\n\n\n    b\n\n    3\n\n    d\n\n    3\n    |\n\n    |\n\n    a\n\n    1\n\n\n    b\n\n    1\n\n\n    c\n\n    1\n\n    a\n\n    2\n\n\n    b\n\n    2\n\n\n    c\n\n    2\n\n    a\n\n    3\n\n\n    b\n\n    3\n\n\n    c\n\n    3\n    |\n    .\n    {\\displaystyle {\\displaystyle x={\\frac {\\begin{vmatrix}{\\color {red}d\\_{1}}&b\\_{1}&c\\_{1}\\\\{\\color {red}d\\_{2}}&b\\_{2}&c\\_{2}\\\\{\\color {red}d\\_{3}}&b\\_{3}&c\\_{3}\\end{vmatrix}}{\\begin{vmatrix}a\\_{1}&b\\_{1}&c\\_{1}\\\\a\\_{2}&b\\_{2}&c\\_{2}\\\\a\\_{3}&b\\_{3}&c\\_{3}\\end{vmatrix}}},\\quad y={\\frac {\\begin{vmatrix}a\\_{1}&{\\color {red}d\\_{1}}&c\\_{1}\\\\a\\_{2}&{\\color {red}d\\_{2}}&c\\_{2}\\\\a\\_{3}&{\\color {red}d\\_{3}}&c\\_{3}\\end{vmatrix}}{\\begin{vmatrix}a\\_{1}&b\\_{1}&c\\_{1}\\\\a\\_{2}&b\\_{2}&c\\_{2}\\\\a\\_{3}&b\\_{3}&c\\_{3}\\end{vmatrix}}},{\\text{ and }}z={\\frac {\\begin{vmatrix}a\\_{1}&b\\_{1}&{\\color {red}d\\_{1}}\\\\a\\_{2}&b\\_{2}&{\\color {red}d\\_{2}}\\\\a\\_{3}&b\\_{3}&{\\color {red}d\\_{3}}\\end{vmatrix}}{\\begin{vmatrix}a\\_{1}&b\\_{1}&c\\_{1}\\\\a\\_{2}&b\\_{2}&c\\_{2}\\\\a\\_{3}&b\\_{3}&c\\_{3}\\end{vmatrix}}}.}}\n\nTask\n\nGiven the following system of equations:\n\n:   {\n\n    2\n    w\n    −\n    x\n    +\n    5\n    y\n    +\n    z\n    =\n    −\n    3\n\n\n    3\n    w\n    +\n    2\n    x\n    +\n    2\n    y\n    −\n    6\n    z\n    =\n    −\n    32\n\n\n    w\n    +\n    3\n    x\n    +\n    3\n    y\n    −\n    z\n    =\n    −\n    47\n\n\n    5\n    w\n    −\n    2\n    x\n    −\n    3\n    y\n    +\n    3\n    z\n    =\n    49\n\n    {\\displaystyle {\\displaystyle {\\begin{cases}2w-x+5y+z=-3\\\\3w+2x+2y-6z=-32\\\\w+3x+3y-z=-47\\\\5w-2x-3y+3z=49\\\\\\end{cases}}}}\n\nsolve for \n\nw\n{\\displaystyle {\\displaystyle w}}\n, \n\nx\n{\\displaystyle {\\displaystyle x}}\n, \n\ny\n{\\displaystyle {\\displaystyle y}}\n and \n\nz\n{\\displaystyle {\\displaystyle z}}\n, using Cramer's rule."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub det(@matrix) {\n    my @a     = @matrix.map: { [|$_] };\n    my $sign  = 1;\n    my $pivot = 1;\n    for ^@a -> \\k {\n      my @r = (k+1 ..^ @a);\n      my $previous-pivot = $pivot;\n      if 0 == ($pivot = @a[k;k]) {\n        (my \\s = @r.first: { @a[$_;k] != 0 }) // return 0;\n        (@a[s], @a[k]) = (@a[k], @a[s]);\n        my $pivot = @a[k;k];\n        $sign = -$sign;\n      }\n      for @r X @r -> (\\i,\\j) {\n        ((@a[i;j] ×= $pivot) -= @a[i;k]×@a[k;j]) /= $previous-pivot;\n      }\n    }\n    $sign × $pivot\n}\n\nsub cramers_rule(@A, @terms) {\n    gather for ^@A -> \\i {\n        my @Ai = @A.map: { [|$_] };\n        for ^@terms -> \\j {\n            @Ai[j;i] = @terms[j];\n        }\n        take det(@Ai);\n    } »/» det(@A);\n}\n\nmy @matrix = (\n    [2, -1,  5,  1],\n    [3,  2,  2, -6],\n    [1,  3,  3, -1],\n    [5, -2, -3,  3],\n);\n\nmy @free_terms = <-3 -32 -47 49>;\nmy ($w, $x, $y, $z) = cramers_rule(@matrix, @free_terms);\n(\"w = $w\", \"x = $x\", \"y = $y\", \"z = $z\").join(\"\\n\").say;\n\n```\n\nOutput:\n\n```\nw = 2\nx = -12\ny = -4\nz = 1\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate a method of deriving the Cyclic Redundancy Check from within the language.\n\nThe result should be in accordance with ISO 3309, ITU-T V.42, Gzip and PNG.\n\nAlgorithms are described on Computation of CRC in Wikipedia.\nThis variant of CRC-32 uses LSB-first order, sets the initial CRC to FFFFFFFF16, and complements the final CRC.\n\nFor the purpose of this task, generate a CRC-32 checksum for the ASCII encoded string:\n\n:   :   `The quick brown fox jumps over the lazy dog`"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Call to native function crc32 in zlib\n\n```\nuse NativeCall;\n \nsub crc32(int32 $crc, Buf $buf, int32 $len --> int32) is native('z') { * }\n \nmy $buf = 'The quick brown fox jumps over the lazy dog'.encode;\nsay crc32(0, $buf, $buf.bytes).fmt('%08x');\n\n```\n\nThe libary name \"z\" resolves to /usr/lib/libz.so on a typical Linux system and /usr/lib/libz.dylib on Mac OS X, but may need to be changed for other platforms. Types may be platform-dependent as well. As written, the solution has been tested on Mac OS X 10.5.8 and Arch Linux 2016.08.01 x86\\_64.\n\nOutput:\n\n```\n414fa339\n```\n\n### Pure Raku\n\nA fairly generic implementation with no regard to execution speed:\n\n```\nsub crc(\n    Blob $buf,\n             # polynomial including leading term, default: ISO 3309/PNG/gzip\n    :@poly = (1,0,0,0,0,0,1,0,0,1,1,0,0,0,0,0,1,0,0,0,1,1,1,0,1,1,0,1,1,0,1,1,1),\n    :$n = @poly.end,      # degree of polynomial\n    :@init = 1 xx $n,     # initial XOR bits\n    :@fini = 1 xx $n,     # final XOR bits\n    :@bitorder = 0..7,    # default: eat bytes LSB-first\n    :@crcorder = 0..$n-1, # default: MSB of checksum is coefficient of x⁰\n) {\n    my @bit = flat ($buf.list X+& (1 X+< @bitorder))».so».Int, 0 xx $n;\n\n    @bit[0   .. $n-1] «+^=» @init;\n    @bit[$_  ..$_+$n] «+^=» @poly if @bit[$_] for 0..@bit.end-$n;\n    @bit[*-$n..  *-1] «+^=» @fini;\n\n    :2[@bit[@bit.end X- @crcorder]];\n}\n\nsay crc('The quick brown fox jumps over the lazy dog'.encode('ascii')).base(16);\n\n```\n\nOutput:\n\n```\n414FA339\n```"}]}
{"messages": [{"role": "user", "content": "In this task, the job is to create a new empty file called \"output.txt\" of size 0 bytes\nand an empty directory called \"docs\". This should be done twice: once \"here\", i.e. in the current working directory and once in the filesystem root."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nfor '.', '' -> $prefix {\n    mkdir \"$prefix/docs\";\n    open \"$prefix/output.txt\", :w;\n}\n```"}]}
{"messages": [{"role": "user", "content": "The task is to create a new file called \"TAPE.FILE\" of any size on Magnetic Tape."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $tape = open \"/dev/tape\", :w or die \"Can't open tape: $!\";\n$tape.say: \"I am a tape file now, or hope to be soon.\";\n$tape.close;\n\n```"}]}
{"messages": [{"role": "user", "content": "Get two integers from the user, then create a two-dimensional array where the two dimensions have the sizes given by those numbers, and which can be accessed in the most natural way possible. Write some element of that array, and then output that element. Finally destroy the array if not done by the language itself."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-11-28\n\nLine 1: The input parse doesn't care how you separate the dimensions as long as there are two distinct numbers.\n\nLine 2: The list replication operator xx will automatically thunkify its left side so this produces new subarrays for each replication.\n\nLine 3: Subscripting with a closure automatically passes the size of the dimension to the closure, so we pick an appropriate random index on each level.\n\nLine 4: Print each line of the array.\n\n```\nmy ($major,$minor) = prompt(\"Dimensions? \").comb(/\\d+/);\nmy @array = [ '@' xx $minor ] xx $major;\n@array[ *.rand ][ *.rand ] = ' ';\n.say for @array;\n\n```\n\nTypical run:\n\n```\nDimensions? 5x35\n[@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @]\n[@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @]\n[@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @]\n[@ @ @ @ @ @ @ @ @ @   @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @]\n[@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @]\n\n```\n\nThe most recent versions of Rakudo have preliminary support for 'shaped arrays'. Natively shaped arrays are a flexible feature for declaring typed, potentially multi-dimensional arrays, potentially with pre-defined\ndimensions. They will make memory-efficient matrix storage and matrix operations possible.\n\n```\nmy ($major,$minor) = +«prompt(\"Dimensions? \").comb(/\\d+/);\nmy Int @array[$major;$minor] = (7 xx $minor ) xx $major;\n@array[$major div 2;$minor div 2] = 42;\nsay @array;\n```\n\nTypical run:\n\n```\nDimensions? 3 x 10\n[[7 7 7 7 7 7 7 7 7 7] [7 7 7 7 7 42 7 7 7 7] [7 7 7 7 7 7 7 7 7 7]]\n```"}]}
{"messages": [{"role": "user", "content": "Create an HTML table.\n\n* The table body should have at least three rows of three columns.\n* Each of these three columns should be labelled \"X\", \"Y\", and \"Z\".\n* An extra column should be added at either the extreme left or the extreme right of the table that has no heading, but is filled with sequential row numbers.\n* The rows of the \"X\", \"Y\", and \"Z\" columns should be filled with random or sequential integers having 4 digits or less.\n* The numbers should be aligned in the same fashion for all columns."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe below example is kind of boring, and laughably simple. For more interesting/complicated examples see:\n\nShow\\_Ascii\\_table#Raku - *(simple)*  \nMayan\\_numerals#Raku - *(heavy styling)*  \nRosetta\\_Code/Count\\_examples/Full\\_list - *(multi-column sortable)*  \nRosetta\\_Code/List\\_authors\\_of\\_task\\_descriptions/Full\\_list - *(complex nested tables)*\n\n*Note: the above examples are outputting wikitable formatting, not HTML directly. It's pretty much a one-for-one shorthand notation though and the principles and process are the same.*\n\nThis is certainly not the only or best way to generate HTML tables using Raku; just an example of one possible method.\n\n```\nmy @header =  <&nbsp; X Y Z>;\nmy $rows = 5;\n\nsub tag ($tag, $string, $param?) { return \"<$tag\" ~ ($param ?? \" $param\" !! '') ~ \">$string\" ~ \"</$tag>\" };\n\nmy $table = tag('tr', ( tag('th', $_) for @header));\n\nfor 1 .. $rows -> $row { \n    $table ~=  tag('tr', ( tag('td', $row, 'align=\"right\"')\n    ~ (tag('td', (^10000).pick, 'align=\"right\"') for 1..^@header)));  \n}\n\nsay tag('table', $table, 'cellspacing=4 style=\"text-align:right; border: 1px solid;\"');\n\n```\n\nOutput:\n\n|  | X | Y | Z |\n| --- | --- | --- | --- |\n| 1 | 2179 | 4778 | 2717 |\n| 2 | 2160 | 1592 | 4348 |\n| 3 | 4511 | 540 | 7187 |\n| 4 | 3484 | 5882 | 1273 |\n| 5 | 1310 | 4017 | 410 |"}]}
{"messages": [{"role": "user", "content": "In systems programing it is sometimes required to place language objects at specific memory locations, like I/O registers, hardware interrupt vectors etc.\n\nTask\n\nShow how language objects can be allocated at a specific machine addresses.\n\nSince most OSes prohibit access to the physical memory if it is not mapped by the application, as an example, rather than a physical address, take the address of some existing object (using suitable address operations if necessary).\n\nFor example:\n\n:   :   * create an integer object\n        * print the machine address of the object\n        * take the address of the object and create another integer object at this address\n        * print the value of this object to verify that it is same as one of the origin\n        * change the value of the origin and verify it again"}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku has fairly comprehensive facilities for accessing allocating and accessing memory and also declaring C-style structs, via the NativeCall interface, as this example demonstrates.\n\n```\nuse NativeCall;\nuse NativeCall::Types;\n\n# bind to basic libc memory management\nsub malloc(size_t) returns Pointer[uint8] is native {*};\nsub memset(Pointer, uint32, size_t) is native {*};\nsub free(Pointer[uint8]) is native {*};\n\nmy Pointer[uint8] $base-p = malloc(100);\nmemset($base-p, 0, 100);\n\n# define object as a C struct that contains a short and an int\nclass SampleObject is repr('CStruct') {\n    has uint16 $.foo is rw;\n    has uint8  $.bar is rw;\n}\n\n# for arguments sake our object is at byte offset 64 in the\n# allocated memory\n\nmy $offset-p =  $base-p.clone.add(64);\nmy $object-p := nativecast(Pointer[SampleObject], $offset-p);\nnote \"creating object at address {+$object-p}\";\n\nmy $struct := $object-p.deref;\n\n$struct.foo = 41;\n$struct.bar = 99;\n\n# check we can update\n$struct.foo++; # 42\n\n# Check that we're actually updating the memory\nuse Test;\n\n# look at the bytes directly to verify we've written to memory. Don't be too exact, as\n# the positions may vary on different platforms depending on endianess and field alignment.\n\nmy $rec-size = nativesizeof(SampleObject);\nmy uint8 @bytes-written = (0 ..^ $rec-size).map(-> $i {$base-p[64 + $i]}).grep: * > 0;\n\n# first field 'foo' (amount is small enough to fit in one byte)\nis @bytes-written[0], 42, 'object first field';\n\n# second field 'bar'\nis @bytes-written[1], 99, 'object second field';\n\n# verify that changing the origin changes the object values\nmemset($base-p, 1, 100); # set every byte to 1\n\nis $struct.foo, 256 + 1, 'short updated at origin';\nis $struct.bar, 1, 'byte updated at origin';\n\n# tidy up\nfree($base-p);\ndone-testing;\n\n```\n\nOutput:\n\n```\ncreating object at address 94299589110352\nok 1 - object first field\nok 2 - object second field\nok 3 - short updated at origin\nok 4 - byte updated at origin\n1..4\n\n```"}]}
{"messages": [{"role": "user", "content": "Create a Hash/Associative Array/Dictionary-like object that can be initialized with key/value pairs. The object should behave like a native Hash/Associative Array/Dictionary of the language, but with the following differences:\n\n* No new keys can be added;\n* Keys cannot be removed;\n* Attempting to delete a key should set that keys value back to that used during initialisation.\n\n(The value assigned to keys may be changed by normal assignment however).\n\nIf the language supports **Magic Methods**, then show how these work."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.08\n\nHere we use delegation to handle all the normal hash methods that we don't need to override to define our new class.\n\n```\nclass FixedHash {\n        has $.hash handles *;\n        method new(*@args) { self.bless: hash => Hash.new: @args }\n        method AT-KEY(FixedHash:D: $key is copy) is rw {\n                $!hash.EXISTS-KEY($key) ?? $!hash.AT-KEY($key) !! Failure.new(q{can't store value for unknown key});\n        }\n        method DELETE-KEY($key) { $!hash.{$key} = Nil }\n}\n\n# Testing\nmy $fh = FixedHash.new: \"a\" => 1, \"b\" => 2;\nsay $fh<a b>;   # 1 2\n$fh<b>:delete;\nsay $fh<a b>;   # 1 Nil\n$fh<b> = 42;\nsay $fh<a b>;   # 1 42\nsay $fh<c>;     # Nil\n$fh<c> = 43;    # error\n\n```\n\nOutput:\n\n```\n(1 2)\n(1 (Any))\n(1 42)\ncan't store value for unknown key\n  in block <unit> at native-demonstration.p6:17\n\nActually thrown at:\n  in block <unit> at native-demonstration.p6:17\n```\n\nBy defining FALLBACK any class can handle undefined method calls. Since any class inherits plenty of methods from Any our magic object will be more of a novice conjurer then a master wizard proper.\n\n```\nclass Magic {\n        has %.hash;\n        multi method FALLBACK($name, |c) is rw { # this will eat any extra parameters\n                %.hash{$name}\n        }\n\n        multi method FALLBACK($name) is rw {\n                %.hash{$name}\n        }\n}\n\nmy $magic = Magic.new;\n$magic.foo = 10;\nsay $magic.foo;\n$magic.defined = False; # error\n\n```\n\nOutput:\n\n```\n10\nCannot modify an immutable Bool\n  in block <unit> at native-demonstration.p6:15\n```"}]}
{"messages": [{"role": "user", "content": "A control code is a text character or sequence of characters with a special meaning that, rather than print a text character to the terminal or screen, instructs the computer to do something text-related. Examples include:\n\n* `NUL` (ASCII 0) = The null terminator. Most programming languages silently place this at the end of a string so that the print function knows when to stop.\n* `\\n` (New Line) = This tells the print function to start a new line. Older computers don't have this, rather they use an ASCII 13 (carriage return) followed by an ASCII 10 (line feed).\n* `\\` (Escape Character) = Any control code placed directly after the escape character loses is special meaning and is printed as-is.\n* `%d` = Insert a base 10 numeral into the string. The value is loaded from a variable specified after the string, separated by commas.\n\nThe C code below shows the `%d` control code in action:\n\n```\nint foo = 1;\nint bar = 2;\nint baz = foo + bar;\nprintf(\"%d plus %d is: %d\",foo,bar,baz); //outputs \"1 plus 2 is: 3\"\n\n```\n\nTask\n\nAdd a new control code to your language's standard print function, which does some sort of text related task that is not already built into the language. Have the standard print function print a string that uses that code, and display the output. What the control code actually does is up to you, but some examples include:\n\n* Changing the color of the text\n* Starting a new line at a custom location, without padding the string with blank spaces\n\nIf the language allows, try to make something entirely new that isn't just a macro of existing control codes combined to produce a trivial result (e.g. `\\n\\n\\n\\n` for four new lines would be trivial)\n\nIf your language doesn't allow you to modify the standard print function, note it.\n(This is a draft task for now because I don't know if anything other than assembly can do this.)"}, {"role": "assistant", "content": "This, in general would be a bad idea. It isn't smart to add a lot of overhead to core functions, especially for so little gain. That being said, something being a bad idea never stopped us before.\n\nprintf already has so many directives, most of the good mnemonics are already taken. Add a \"commas\" directive as %y and an \"invert\" directive as %z.\n\nSome languages already have a commas directive as that one is actually useful. I doubt if any language has an \"invert\" directive.\n\nThis is *really* basic and sketchy. It only modifies printf, not sprintf, so probably isn't terribly useful as is... but it satisfies the task requirements. It actually *does* add new, non-standard directives to the core printf function, not just implement a separate formatting function to pre-format a string which is then passed to the printing function.\n\n```\nuse Lingua::EN::Numbers;\nuse Acme::Text::UpsideDown;\n\nsub printf (Str $format is copy, *@vars is copy) {\n    my @directives = $format.comb(/ <?after <-[%]>|^> '%' <[ +0#-]>* <alpha>/);\n    for ^@directives {\n        if @directives[$_] eq '%y' {\n            $format.=subst('%y', '%s');\n            @vars[$_].=&comma;\n        } elsif @directives[$_] eq '%z' {\n            $format.=subst('%z', '%s');\n            @vars[$_].=&upsidedown;\n        }\n    }\n    &CORE::printf($format, @vars)\n}\n\nprintf \"Integer %d with commas: %y\\nSpelled out: %s\\nInverted: %z\\n\",\n       12345, 12345, 12345.&cardinal, 12345.&cardinal;\n\n```\n\nOutput:\n\n```\nInteger 12345 with commas: 12,345\nSpelled out: twelve thousand, three hundred forty-five\nInverted: ǝʌᴉɟ-ʎʇɹoɟ pǝɹpunɥ ǝǝɹɥʇ ‘puɐsnoɥʇ ǝʌꞁǝʍʇ\n```"}]}
{"messages": [{"role": "user", "content": "CSV spreadsheet files are suitable for storing tabular data in a relatively portable way.\n\nThe CSV format is flexible but somewhat ill-defined.\n\nFor present purposes, authors may assume that the data fields contain no commas, backslashes, or quotation marks.\n\nTask\n\nRead a CSV file, change some values and save the changes back to a file.\n\nFor this task we will use the following CSV file:\n\n```\nC1,C2,C3,C4,C5\n1,5,9,13,17\n2,6,10,14,18\n3,7,11,15,19\n4,8,12,16,20\n\n```\n\n*Suggestions*\n\nShow how to add a column, headed 'SUM', of the sums of the rows.\nIf possible, illustrate the use of built-in or standard functions, methods, or libraries, that handle generic CSV files.\n\nRelated tasks\n\n* Convert\\_CSV\\_records\\_to\\_TSV"}, {"role": "assistant", "content": "(formerly Perl 6)\nOn the face of it this task is pretty simple. Especially given the sample CSV file and the total lack of specification of *what* changes to make to the file. Something like this would suffice.\n\n```\nmy $csvfile = './whatever.csv';\nmy $fh = open($csvfile, :r);\nmy @header = $fh.get.split(',');\nmy @csv = map {[.split(',')]>>.Num}, $fh.lines;\nclose $fh;\n\nmy $out = open($csvfile, :w);\n$out.say((@header,'SUM').join(','));\n$out.say((@$_, [+] @$_).join(',')) for @csv;\nclose $out;\n\n```\n\nBut if your CSV file is at all complex you are better off using a CSV parsing module. (Complex meaning fields that contain commas, quotes, newlines, etc.)\n\n```\nuse Text::CSV;\nmy $csvfile = './whatever.csv';\nmy @csv = Text::CSV.parse-file($csvfile);\n# modify(@csv); # do whatever;\ncsv-write-file( @csv, :file($csvfile) );\n\n```"}]}
{"messages": [{"role": "user", "content": "Consider a simplified CSV format where all rows are separated by a newline\nand all columns are separated by commas.\n\nNo commas are allowed as field data, but the data may contain\nother characters and character sequences that would\nnormally be   *escaped*   when converted to HTML\n\nTask\n\nCreate a function that takes a string representation of the CSV data\nand returns a text string of an HTML table representing the CSV data.\n\nUse the following data as the CSV text to convert, and show your output.\n\n:   Character,Speech\n:   The multitude,The messiah! Show us the messiah!\n:   Brians mother,<angry>Now you listen here! He's not the messiah; he's a very naughty boy! Now go away!</angry>\n:   The multitude,Who are you?\n:   Brians mother,I'm his mother; that's who!\n:   The multitude,Behold his mother! Behold his mother!\n\nExtra credit\n\n*Optionally* allow special formatting for the first row of the table as if it is the tables header row\n(via <thead> preferably; CSS if you must)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015.09\n\nA very lispy solution:\n\n```\nmy $str = \"Character,Speech\nThe multitude,The messiah! Show us the messiah!\nBrians mother,<angry>Now you listen here! He's not the messiah; he's a very naughty boy! Now go away!</angry>\nThe multitude,Who are you?\nBrians mother,I'm his mother; that's who!\nThe multitude,Behold his mother! Behold his mother!\";\n\n# comment the next line out, if you want to read from standard input instead of the hard-coded $str above\n# my $str = $*IN.slurp;\n\nmy &escape = *.trans(« & < > » => « &amp; &lt; &gt; »); # a function with one argument that escapes the entities\nmy &tag    = {\"<$^tag>\"~$^what~\"</$^tag>\"};\n\nprintf\n'<!DOCTYPE html>\n<html>\n<head><title>Some Text</title></head>\n<body><table>\n%s\n</table></body></html>\n', [~]                                # concatenation reduction ('a', 'b', 'c') → 'abc'\n(escape($str).split(/\\n/)             # escape the string and split at newline\n  ==> map -> $line {tag 'tr',         # feed that into a map, that map function will tag as 'tr, and has an argument called $line\n    ([~] $line.split(/','/)\\          # split $line at ',', \n                                      # that / at the end is just an unspace, you can omit it, but then you have to delete\n                                      # all whitespace  and comments between split(…) and .map\n      .map({tag 'td', $^cell}))})\\    # map those cells as td\n\t\t       .join(\"\\n\");   # append a newline for nicer output\n```\n\nOutput:\n\n```\n<!DOCTYPE html>\n<html>\n<head><title>Some Text</title></head>\n<body><table>\n<tr><td>Character</td><td>Speech</td></tr>\n<tr><td>The multitude</td><td>The messiah! Show us the messiah!</td></tr>\n<tr><td>Brians mother</td><td>&lt;angry&gt;Now you listen here! He's not the messiah; he's a very naughty boy! Now go away!&lt;/angry&gt;</td></tr>\n<tr><td>The multitude</td><td>Who are you?</td></tr>\n<tr><td>Brians mother</td><td>I'm his mother; that's who!</td></tr>\n<tr><td>The multitude</td><td>Behold his mother! Behold his mother!</td></tr>\n</table></body></html>\n```"}]}
{"messages": [{"role": "user", "content": "The name   **cuban**   has nothing to do with   Cuba  (the country),   but has to do with the\nfact that cubes   (3rd powers)   play a role in its definition.\n\nSome definitions of cuban primes\n:   :   * primes which are the difference of two consecutive cubes.\n        * primes of the form:   (n+1)3 - n3.\n        * primes of the form:   n3 - (n-1)3.\n        * primes   *p*   such that   n2(*p*+n)   is a cube for some   n>0.\n        * primes   *p*   such that   4*p* = 1 + 3n2.\n\nCuban primes were named in 1923 by Allan Joseph Champneys Cunningham.\n\nTask requirements\n:   :   * show the first   200   cuban primes   (in a multi─line horizontal format).\n        * show the   100,000th   cuban prime.\n        * show all cuban primes with commas   (if appropriate).\n        * show all output here.\n\nNote that   **cuban prime**   isn't capitalized   (as it doesn't refer to the nation of Cuba).\n\nAlso see\n:   * Wikipedia entry:     cuban prime.\n    * MathWorld entry:   cuban prime.\n    * The OEIS entry:     A002407.     The   100,000th   cuban prime can be verified in the   2nd   *example*   on this OEIS web page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Library:** ntheory\n\n### The task (k == 1)\n\nNot the most efficient, but concise, and good enough for this task. Use the ntheory library for prime testing; gets it down to around 20 seconds.\n\n```\nuse Lingua::EN::Numbers;\nuse ntheory:from<Perl5> <:all>;\n\nmy @cubans = lazy (1..Inf).map({ ($_+1)³ - .³ }).grep: *.&is_prime;\n\nput @cubans[^200]».&comma».fmt(\"%9s\").rotor(10).join: \"\\n\";\n\nput '';\n\nput @cubans[99_999].&comma; # zero indexed\n\n```\n\nOutput:\n\n```\n        7        19        37        61       127       271       331       397       547       631\n      919     1,657     1,801     1,951     2,269     2,437     2,791     3,169     3,571     4,219\n    4,447     5,167     5,419     6,211     7,057     7,351     8,269     9,241    10,267    11,719\n   12,097    13,267    13,669    16,651    19,441    19,927    22,447    23,497    24,571    25,117\n   26,227    27,361    33,391    35,317    42,841    45,757    47,251    49,537    50,311    55,897\n   59,221    60,919    65,269    70,687    73,477    74,419    75,367    81,181    82,171    87,211\n   88,237    89,269    92,401    96,661   102,121   103,231   104,347   110,017   112,327   114,661\n  115,837   126,691   129,169   131,671   135,469   140,617   144,541   145,861   151,201   155,269\n  163,567   169,219   170,647   176,419   180,811   189,757   200,467   202,021   213,067   231,019\n  234,361   241,117   246,247   251,431   260,191   263,737   267,307   276,337   279,991   283,669\n  285,517   292,969   296,731   298,621   310,087   329,677   333,667   337,681   347,821   351,919\n  360,187   368,551   372,769   374,887   377,011   383,419   387,721   398,581   407,377   423,001\n  436,627   452,797   459,817   476,407   478,801   493,291   522,919   527,941   553,411   574,219\n  584,767   590,077   592,741   595,411   603,457   608,851   611,557   619,711   627,919   650,071\n  658,477   666,937   689,761   692,641   698,419   707,131   733,591   742,519   760,537   769,627\n  772,669   784,897   791,047   812,761   825,301   837,937   847,477   863,497   879,667   886,177\n  895,987   909,151   915,769   925,741   929,077   932,419   939,121   952,597   972,991   976,411\n  986,707   990,151   997,057 1,021,417 1,024,921 1,035,469 1,074,607 1,085,407 1,110,817 1,114,471\n1,125,469 1,155,061 1,177,507 1,181,269 1,215,397 1,253,887 1,281,187 1,285,111 1,324,681 1,328,671\n1,372,957 1,409,731 1,422,097 1,426,231 1,442,827 1,451,161 1,480,519 1,484,737 1,527,247 1,570,357\n\n1,792,617,147,127\n```\n\n### k == 2 through 10\n\nAfter reading up a bit, the general equation for cuban primes is prime numbers of the form ((x+k)3 - x3)/k  where k mod 3 is not equal 0.\n\nThe cubans where k == 1 (the focus of this task) is one of many possible groups. In general, it seems like the cubans where k == 1 and k == 2 are the two primary cases, but it is possible to have cubans with a k of any integer that is not a multiple of 3.\n\nHere are the first 20 for each valid k up to 10:\n\n```\nsub comma { $^i.flip.comb(3).join(',').flip }\n\nfor 2..10 -> \\k {\n    next if k %% 3;\n    my @cubans = lazy (1..Inf).map({ (($_+k)³ - .³)/k }).grep: *.is-prime;\n    put \"First 20 cuban primes where k = {k}:\";\n    put @cubans[^20]».&comma».fmt(\"%7s\").rotor(10).join: \"\\n\";\n    put '';\n}\n\n```\n\nOutput:\n\n```\nFirst 20 cuban primes where k = 2:\n     13     109     193     433     769   1,201   1,453   2,029   3,469   3,889\n  4,801  10,093  12,289  13,873  18,253  20,173  21,169  22,189  28,813  37,633\n\nFirst 20 cuban primes where k = 4:\n     31      79     151     367   1,087   1,327   1,879   2,887   3,271   4,111\n  4,567   6,079   7,207   8,431  15,991  16,879  17,791  19,687  23,767  24,847\n\nFirst 20 cuban primes where k = 5:\n     43      67      97     223     277     337     727     823   1,033   1,663\n  2,113   2,617   2,797   3,373   4,003   5,683   6,217   7,963  10,273  10,627\n\nFirst 20 cuban primes where k = 7:\n     73     103     139     181     229     283     409     643     733     829\n  1,039   1,153   1,399   1,531   1,669   2,281   2,803   3,181   3,583   3,793\n\nFirst 20 cuban primes where k = 8:\n    163     379     523     691     883   2,203   2,539   3,691   5,059   5,563\n  6,091   7,219   8,443   9,091  10,459  11,923  15,139  19,699  24,859  27,091\n\nFirst 20 cuban primes where k = 10:\n    457     613     997   1,753   2,053   2,377   4,357   6,373   9,433  13,093\n 16,453  21,193  27,673  28,837  31,237  37,657  46,153  47,653  49,177  62,233\n```\n\n### k == 2^128\n\nNote that Raku has native support for arbitrarily large integers and does not need to generate primes to test for primality. Using k of 2^128; finishes in *well* under a second.\n\n```\nsub comma { $^i.flip.comb(3).join(',').flip }\n\nmy \\k = 2**128;\nput \"First 10 cuban primes where k = {k}:\";\n.&comma.put for (lazy (0..Inf).map({ (($_+k)³ - .³)/k }).grep: *.is-prime)[^10];\n\n```\n\n```\nFirst 10 cuban primes where k = 340282366920938463463374607431768211456:\n115,792,089,237,316,195,423,570,985,008,687,908,160,544,961,995,247,996,546,884,854,518,799,824,856,507\n115,792,089,237,316,195,423,570,985,008,687,908,174,836,821,405,927,412,012,346,588,030,934,089,763,531\n115,792,089,237,316,195,423,570,985,008,687,908,219,754,093,839,491,289,189,512,036,211,927,493,764,691\n115,792,089,237,316,195,423,570,985,008,687,908,383,089,629,961,541,751,651,931,847,779,176,235,685,011\n115,792,089,237,316,195,423,570,985,008,687,908,491,299,422,642,400,183,033,284,972,942,478,527,291,811\n115,792,089,237,316,195,423,570,985,008,687,908,771,011,528,251,411,600,000,178,900,251,391,998,361,371\n115,792,089,237,316,195,423,570,985,008,687,908,875,137,932,529,218,769,819,971,530,125,513,071,648,307\n115,792,089,237,316,195,423,570,985,008,687,908,956,805,700,590,244,001,051,181,435,909,137,442,897,427\n115,792,089,237,316,195,423,570,985,008,687,909,028,264,997,643,641,078,378,490,103,469,808,767,771,907\n115,792,089,237,316,195,423,570,985,008,687,909,158,933,426,541,281,448,348,425,952,723,607,761,904,131\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n**n**   is smallest prime such that the difference of successive terms are the smallest cubics of positive integers,\nwhere     **n**   <   **15000**."}, {"role": "assistant", "content": "A two character difference from the Quadrat Special Primes entry. (And it could have been one.)\n\n```\nmy @sqp = 2, -> $previous {\n    my $next;\n    for (1..∞).map: *³ {\n        $next = $previous + $_;\n        last if $next.is-prime;\n    }\n    $next\n} … *;\n\nsay \"{+$_} matching numbers:\\n\", $_».fmt('%5d').batch(7).join: \"\\n\" given\n    @sqp[^(@sqp.first: * > 15000, :k)];\n\n```\n\nOutput:\n\n```\n23 matching numbers:\n    2     3    11    19    83  1811  2027\n 2243  2251  2467  2531  2539  3539  3547\n 4547  5059 10891 12619 13619 13627 13691\n13907 14419\n```"}]}
{"messages": [{"role": "user", "content": "A Cullen number is a number of the form **n × 2n + 1** where **n** is a natural number.\n\nA Woodall number is very similar. It is a number of the form **n × 2n - 1** where **n** is a natural number.\n\nSo for each **n** the associated Cullen number and Woodall number differ by 2.\n\n*Woodall numbers are sometimes referred to as Riesel numbers or Cullen numbers of the second kind.*\n\n**Cullen primes** are Cullen numbers that are prime. Similarly, **Woodall primes** are Woodall numbers that are prime.\n\nIt is common to list the Cullen and Woodall primes by the value of **n** rather than the full evaluated expression. They tend to get very large very quickly. For example, the third Cullen prime, **n** == 4713, has 1423 digits when evaluated.\n\nTask\n\n* Write procedures to find Cullen numbers and Woodall numbers.\n\n* Use those procedures to find and show here, on this page the first 20 of each.\n\nStretch\n\n* Find and show the first **5** **Cullen primes** in terms of **n**.\n\n* Find and show the first **12** **Woodall primes** in terms of **n**.\n\nSee also\n\n* OEIS:A002064 - Cullen numbers: a(n) = n\\*2^n + 1\n\n* OEIS:A003261 - Woodall (or Riesel) numbers: n\\*2^n - 1\n\n* OEIS:A005849 - Indices of prime Cullen numbers: numbers k such that k\\*2^k + 1 is prime\n\n* OEIS:A002234 - Numbers k such that the Woodall number k\\*2^k - 1 is prime"}, {"role": "assistant", "content": "```\nmy @cullen  = ^∞ .map: { $_ × 1 +< $_ + 1 };\nmy @woodall = ^∞ .map: { $_ × 1 +< $_ - 1 };\n\nput \"First 20 Cullen numbers: ( n × 2**n + 1)\\n\",     @cullen[1..20]; # A002064\nput \"\\nFirst 20 Woodall numbers: ( n × 2**n - 1)\\n\", @woodall[1..20]; # A003261\nput \"\\nFirst 5 Cullen primes: (in terms of n)\\n\",     @cullen.grep( &is-prime, :k )[^5];  # A005849\nput \"\\nFirst 12 Woodall primes:  (in terms of n)\\n\", @woodall.grep( &is-prime, :k )[^12]; # A002234\n\n```\n\nOutput:\n\n```\nFirst 20 Cullen numbers: ( n × 2**n + 1)\n3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521\n\nFirst 20 Woodall numbers: ( n × 2**n - 1)\n1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519\n\nFirst 5 Cullen primes: (in terms of n)\n1 141 4713 5795 6611\n\nFirst 12 Woodall primes:  (in terms of n)\n2 3 6 30 75 81 115 123 249 362 384 462\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a stateful function, class, generator or co-routine that takes a series of floating point numbers, *one at a time*, and returns the running standard deviation of the series.\n\nThe task implementation should use the most natural programming style of those listed for the function in the implementation language; the task *must* state which is being used.\n\nDo not apply Bessel's correction; the returned standard deviation should always be computed as if the sample seen so far is the entire population.\n\nTest case\n\nUse this to compute the standard deviation of this demonstration set, \n\n{\n2\n,\n4\n,\n4\n,\n4\n,\n5\n,\n5\n,\n7\n,\n9\n}\n{\\displaystyle {\\displaystyle \\{2,4,4,4,5,5,7,9\\}}}\n, which is \n\n2\n{\\displaystyle {\\displaystyle 2}}\n.\n\nRelated tasks\n\n* Random numbers\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| | Tasks for calculating statistical measures | | | --- | --- | |  | | |  |  |  |  |  | | --- | --- | --- | --- | --- | |  | | in one go | moving *(sliding window)* | moving *(cumulative)* | | Mean | Arithmetic | Statistics/Basic  Averages/Arithmetic mean  Averages/Pythagorean means | Averages/Simple moving average |  | | Geometric | Averages/Pythagorean means |  |  | | Harmonic | Averages/Pythagorean means |  |  | | Quadratic | Averages/Root mean square |  |  | | Circular | Averages/Mean angle  Averages/Mean time of day |  |  | | Median | | Averages/Median |  |  | | Mode | | Averages/Mode |  |  | | Standard deviation | | Statistics/Basic |  | Cumulative standard deviation | | | |\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUsing a closure:\n\n```\nsub sd (@a) {\n    my $mean = @a R/ [+] @a;\n    sqrt @a R/ [+] map (* - $mean)², @a;\n}\n \nsub sdaccum {\n    my @a;\n    return { push @a, $^x; sd @a; };\n}\n \nmy &f = sdaccum;\nsay f $_ for 2, 4, 4, 4, 5, 5, 7, 9;\n\n```\n\nUsing a state variable (remember that <(x-<x>)²> = <x²> - <x>²):\n\n```\nsub stddev($x) {\n    sqrt\n        ( .[2] += $x²) / ++.[0]\n      - ((.[1] += $x ) /   .[0])²\n    given state @;\n}\n\nsay .&stddev for <2 4 4 4 5 5 7 9>;\n\n```\n\nOutput:\n\n```\n0\n1\n0.942809041582063\n0.866025403784439\n0.979795897113271\n1\n1.39970842444753\n2\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow how to represent currency in a simple example, using a data type that represent exact values of dollars and cents.\n\nNote\n\nThe **IEEE 754** binary floating point representations of numbers like   **2.86**   and   **.0765**   are not exact.\n\nFor this example, data will be two items with prices in dollars and cents, a quantity for each, and a tax rate.\n\nUse the values:\n\n:   :   * 4000000000000000 hamburgers at $5.50 each       (four quadrillion burgers)\n        * 2 milkshakes at $2.86 each, and\n        * a tax rate of 7.65%.\n\n(That number of hamburgers is a 4 with 15 zeros after it.   The number is contrived to exclude naïve task solutions using 64 bit floating point types.)\n\nCompute and output (show results on this page):\n\n:   :   * the total price before tax\n        * the tax\n        * the total with tax\n\nThe tax value must be computed by rounding to the nearest whole cent and this exact value must be added to the total price before tax.\n\nThe output must show dollars and cents with a decimal point.\n\nThe three results displayed should be:\n\n:   :   * 22000000000000005.72\n        * 1683000000000000.44\n        * 23683000000000006.16\n\nDollar signs and thousands separators are optional."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.01\n\nNo need for a special type in Raku, since the Rat type is used for normal fractions.\n(In order to achieve imprecision, you have to explicitly use scientific notation,\nor use the Num type, or calculate a result that requires a denominator in excess of 2 \\*\\* 64. (There's no limit on the numerator.))\n\n```\nmy @check = q:to/END/.lines.map: { [.split(/\\s+/)] };\n    Hamburger   5.50    4000000000000000\n    Milkshake   2.86    2\n    END\n\nmy $tax-rate = 0.0765;\n\nmy $fmt = \"%-10s %8s %18s %22s\\n\";\n\nprintf $fmt, <Item Price Quantity Extension>;\n\nmy $subtotal = [+] @check.map: -> [$item,$price,$quant] {\n    my $extension = $price * $quant;\n    printf $fmt, $item, $price, $quant, fix2($extension);\n    $extension;\n}\n\nprintf $fmt, '', '', '', '-----------------';\nprintf $fmt, '', '', 'Subtotal ', $subtotal;\n\nmy $tax = ($subtotal * $tax-rate).round(0.01);\nprintf $fmt, '', '', 'Tax ', $tax;\n\nmy $total = $subtotal + $tax;\nprintf $fmt, '', '', 'Total ', $total;\n\n# make up for lack of a Rat fixed-point printf format\nsub fix2($x) { ($x + 0.001).subst(/ <?after \\.\\d\\d> .* $ /, '') }\n\n```\n\nOutput:\n\n```\nItem          Price           Quantity              Extension\nHamburger      5.50   4000000000000000   22000000000000000.00\nMilkshake      2.86                  2                   5.72\n                                            -----------------\n                             Subtotal    22000000000000005.72\n                                  Tax     1683000000000000.44\n                                Total    23683000000000006.16\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Currying. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nCreate a simple demonstrative example of Currying in a specific language.\n\nAdd any historic details as to how the feature made its way into the language."}, {"role": "assistant", "content": "(formerly Perl 6)\nAll callable objects have an \"assuming\" method that can do partial application of either positional or named arguments. Here we curry the built-in subtraction operator.\n\n```\nmy &negative = &infix:<->.assuming(0);\nsay negative 1;\n\n```\n\nOutput:\n\n```\n-1\n```"}]}
{"messages": [{"role": "user", "content": "Draw a curve that touches 3 points (1 starting point, 2 medium, 3 final point)\n\n:   :   1. Do not use functions of a library, implement the curve() function yourself\n        2. coordinates:(x,y) starting point (10,10) medium point (100,200) final point (200,10)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nKind of bogus. There are an infinite number of curves that pass through those three points. I'll assume a quadratic curve. Lots of bits and pieces borrowed from other tasks to avoid relying on library functions.\n\nSaved as a png for wide viewing support. Note that png coordinate systems have 0,0 in the upper left corner.\n\n```\nuse Image::PNG::Portable;\n\n# the points of interest\nmy @points = (10,10), (100,200), (200,10);\n\n# Solve for a quadratic line that passes through those points\nmy (\\a, \\b, \\c) = (rref ([.[0]², .[0], 1, .[1]] for @points) )[*;*-1];\n\n# Evaluate quadratic equation\nsub f (\\x) { a×x² + b×x + c }\n\nmy ($w, $h) = 500, 500;  # image size\nmy $scale   = 2;         # scaling factor\n\nmy $png = Image::PNG::Portable.new: :width($w), :height($h);\n\nmy ($lastx, $lasty) = 8, f(8).round;\n(9 .. 202).map: -> $x {\n    my $f = f($x).round;\n    line($lastx, $lasty, $x, $f, $png, [0,255,127]);\n    ($lastx, $lasty) = $x, $f;\n}\n\n# Highlight the defining points\ndot( | $_, $(255,0,0), $png, 2) for @points;\n\n$png.write: 'Curve-3-points-perl6.png';\n\n# Assorted helper routines \nsub rref (@m) {\n    return unless @m;\n    my ($lead, $rows, $cols) = 0, @m, @m[0];\n    for ^$rows -> $r {\n        $lead < $cols or return @m;\n        my $i = $r;\n        until @m[$i;$lead] {\n            ++$i == $rows or next;\n            $i = $r;\n            ++$lead == $cols and return @m;\n        }\n        @m[$i, $r] = @m[$r, $i] if $r != $i;\n        @m[$r] »/=» $ = @m[$r;$lead];\n        for ^$rows -> $n {\n            next if $n == $r;\n            @m[$n] »-=» @m[$r] »×» (@m[$n;$lead] // 0);\n        }\n        ++$lead;\n    }\n    @m\n}\n\nsub line($x0 is copy, $y0 is copy, $x1 is copy, $y1 is copy, $png, @rgb) {\n    my $steep = abs($y1 - $y0) > abs($x1 - $x0);\n    ($x0,$y0,$x1,$y1) »×=» $scale;\n    if $steep {\n        ($x0, $y0) = ($y0, $x0);\n        ($x1, $y1) = ($y1, $x1);\n    }\n    if $x0 > $x1 {\n        ($x0, $x1) = ($x1, $x0);\n        ($y0, $y1) = ($y1, $y0);\n    }\n    my $Δx = $x1 - $x0;\n    my $Δy = abs($y1 - $y0);\n    my $error = 0;\n    my $Δerror = $Δy / $Δx;\n    my $y-step = $y0 < $y1 ?? 1 !! -1;\n    my $y = $y0;\n    next if $y < 0;\n    for $x0 .. $x1 -> $x {\n        next if $x < 0;\n        if $steep {\n            $png.set($y, $x, |@rgb);\n        } else {\n            $png.set($x, $y, |@rgb);\n        }\n        $error += $Δerror;\n        if $error ≥ 0.5 {\n            $y += $y-step;\n            $error -= 1.0;\n        }\n    }\n}\n\nsub dot ($X is copy, $Y is copy, @rgb, $png, $radius = 3) {\n    ($X, $Y) »×=» $scale;\n    for ($X X+ -$radius .. $radius) X ($Y X+ -$radius .. $radius) -> ($x, $y) {\n        $png.set($x, $y, |@rgb) if ( $X - $x + ($Y - $y) × i ).abs <= $radius;\n    }\n}\n\n```\n\nSee Curve-3-points-perl6.png (offsite .png image)"}]}
{"messages": [{"role": "user", "content": "A **Curzon number** is defined to be a positive integer **n** for which **2n + 1** is evenly divisible by **2 × n + 1**.\n\n**Generalized Curzon numbers** are those where the positive integer **n**, using a base integer **k**, satisfy the condition that **kn + 1** is evenly divisible by **k × n + 1**.\n\n*Base here does not imply the radix of the counting system; rather the integer the equation is based on. All calculations should be done in base 10.*\n\nGeneralized Curzon numbers only exist for even base integers.\n\nTask\n\n* Find and show the first **50 Generalized Curzon numbers** for even base integers from **2** through **10**.\n\nStretch\n\n* Find and show the **one thousandth**.\n\nSee also\n\n* Numbers Aplenty - Curzon numbers * OEIS:A224486 - Numbers k such that 2\\*k+1 divides 2^k+1 (Curzon numbers)\n\n*and even though it is not specifically mentioned that they are Curzon numbers:*\n\n* OEIS:A230076 - (A007521(n)-1)/4 (Generalized Curzon numbers with a base 4)"}, {"role": "assistant", "content": "```\nsub curzon ($base) { lazy (1..∞).hyper.map: { $_ if (exp($_, $base) + 1) %% ($base × $_ + 1) } };\n\nfor <2 4 6 8 10> {\n    my $curzon = .&curzon;\n    say \"\\nFirst 50 Curzon numbers using a base of $_:\\n\" ~\n      $curzon[^50].batch(10)».fmt(\"%4s\").join(\"\\n\") ~\n      \"\\nOne thousandth: \" ~ $curzon[999]\n}\n\n```\n\nOutput:\n\n```\nFirst 50 Curzon numbers using a base of 2:\n   1    2    5    6    9   14   18   21   26   29\n  30   33   41   50   53   54   65   69   74   78\n  81   86   89   90   98  105  113  114  125  134\n 138  141  146  153  158  165  173  174  186  189\n 194  198  209  210  221  230  233  245  249  254\nOne thousandth: 8646\n\nFirst 50 Curzon numbers using a base of 4:\n   1    3    7    9   13   15   25   27   37   39\n  43   45   49   57   67   69   73   79   87   93\n  97   99  105  115  127  135  139  153  163  165\n 169  175  177  183  189  193  199  205  207  213\n 219  235  249  253  255  265  267  273  277  279\nOne thousandth: 9375\n\nFirst 50 Curzon numbers using a base of 6:\n   1    6   30   58   70   73   90  101  105  121\n 125  146  153  166  170  181  182  185  210  233\n 241  242  266  282  290  322  373  381  385  390\n 397  441  445  446  450  453  530  557  562  585\n 593  601  602  605  606  621  646  653  670  685\nOne thousandth: 20717\n\nFirst 50 Curzon numbers using a base of 8:\n   1   14   35   44   72   74   77  129  131  137\n 144  149  150  185  200  219  236  266  284  285\n 299  309  336  357  381  386  390  392  402  414\n 420  441  455  459  470  479  500  519  527  536\n 557  582  600  602  617  639  654  674  696  735\nOne thousandth: 22176\n\nFirst 50 Curzon numbers using a base of 10:\n   1    9   10   25  106  145  190  193  238  253\n 306  318  349  385  402  462  486  526  610  649\n 658  678  733  762  810  990  994 1033 1077 1125\n1126 1141 1149 1230 1405 1422 1441 1485 1509 1510\n1513 1606 1614 1630 1665 1681 1690 1702 1785 1837\nOne thousandth: 46845\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at CUSIP. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nA   **CUSIP**   is a nine-character alphanumeric code that identifies a North American financial security for the purposes of facilitating clearing and settlement of trades. The CUSIP was adopted as an American National Standard under Accredited Standards X9.6.\n\nTask\n\nEnsure the last digit   (i.e., the   *check digit*)   of the **CUSIP** code (the 1st column) is correct, against the following:\n\n* 037833100       Apple Incorporated\n* 17275R102       Cisco Systems\n* 38259P508       Google Incorporated\n* 594918104       Microsoft Corporation\n* 68389X106       Oracle Corporation   (*incorrect*)\n* 68389X105       Oracle Corporation\n\nExample pseudo-code below.\n\n```\nalgorithm Cusip-Check-Digit(cusip) is\n   Input: an 8-character CUSIP\n\n   sum := 0\n   for 1 ≤ i ≤ 8 do\n      c := the ith character of cusip\n      if c is a digit then\n         v := numeric value of the digit c\n      else if c is a letter then\n         p := ordinal position of c in the alphabet (A=1, B=2...)\n         v := p + 9\n      else if c = \"*\" then\n         v := 36\n      else if c = \"@\" then\n         v := 37\n      else if' c = \"#\" then\n         v := 38\n      end if\n      if i is even then\n         v := v × 2\n      end if\n\n      sum := sum + int ( v div 10 ) + v mod 10\n   repeat\n   \n   return (10 - (sum mod 10)) mod 10\nend function\n\n```\n\nSee related tasks\n\n* SEDOL\n* ISIN"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.01\n\n```\nsub divmod ($v, $r) { $v div $r, $v mod $r }\nmy %chr = (flat 0..9, 'A'..'Z', <* @ #>) Z=> 0..*;\n\nsub cuisp-check ($cuisp where *.chars == 9) {\n    my ($code, $chk) = $cuisp.comb(8);\n    my $sum = [+] $code.comb.kv.map: { [+] (($^k % 2 + 1) * %chr{$^v}).&divmod(10) };\n    so (10 - $sum mod 10) mod 10 eq $chk;\n}\n\n# TESTING\nsay \"$_: \", $_.&cuisp-check for <\n037833100\n17275R102\n38259P508\n594918104\n68389X106\n68389X105\n>\n\n```\n\nOutput:\n\n```\n037833100: True\n17275R102: True\n38259P508: True\n594918104: True\n68389X106: False\n68389X105: True\n```"}]}
{"messages": [{"role": "user", "content": "A given rectangle is made from *m* × *n* squares. If *m* and *n* are not both odd, then it is possible to cut a path through the rectangle along the square edges such that the rectangle splits into two connected pieces with the same shape (after rotating one of the pieces by 180°). All such paths for 2 × 2 and 4 × 3 rectangles are shown below.\n\nWrite a program that calculates the number of different ways to cut an *m* × *n* rectangle. Optionally, show each of the cuts.\n\nPossibly related task: Maze generation for depth-first search."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: C\n\n```\nsub solve($hh, $ww, $recurse) {\n    my ($h, $w, $t, @grid) = $hh, $ww, 0;\n    state $cnt;\n    $cnt = 0 if $recurse;\n\n    ($t, $w, $h) = ($w, $h, $w) if $h +& 1;\n    return 0  if $h == 1;\n    return 1  if $w == 1;\n    return $h if $w == 2;\n    return $w if $h == 2;\n\n    my ($cy, $cx) = ($h, $w) «div» 2;\n    my $len = ($h + 1) × ($w + 1);\n    @grid[$len--] = 0;\n    my @next = -1, -$w-1, 1, $w+1;\n\n    for $cx+1 ..^ $w -> $x {\n        $t = $cy × ($w + 1) + $x;\n        @grid[$_] = 1 for $t, $len-$t;\n        walk($cy - 1, $x);\n    }\n\n    sub walk($y, $x) {\n        constant @dir = <0 -1 0 1> Z <-1 0 1 0>;\n        $cnt += 2 and return if not $y or $y == $h or not $x or $x == $w;\n        my $t = $y × ($w+1) + $x;\n        @grid[$_]++ for $t, $len-$t;\n        walk($y + @dir[$_;0], $x + @dir[$_;1]) if not @grid[$t + @next[$_]] for 0..3;\n        @grid[$_]-- for $t, $len-$t;\n    }\n\n    $cnt++;\n    if    $h == $w                 { $cnt ×= 2            }\n    elsif $recurse and not $w +& 1 { solve($w, $h, False) }\n    $cnt\n}\n\n((1..9 X 1..9).grep:{ .[0] ≥ .[1] }).flat.map: -> $y, $x {\n   say \"$y × $x: \" ~ solve $y, $x, True unless $x +& 1 and $y +& 1;\n}\n\n```\n\nOutput:\n\n```\n2 × 1: 1\n2 × 2: 2\n3 × 2: 3\n4 × 1: 1\n4 × 2: 4\n4 × 3: 9\n4 × 4: 22\n5 × 2: 5\n5 × 4: 39\n6 × 1: 1\n6 × 2: 6\n6 × 3: 23\n6 × 4: 90\n6 × 5: 263\n6 × 6: 1018\n7 × 2: 7\n7 × 4: 151\n7 × 6: 2947\n8 × 1: 1\n8 × 2: 8\n8 × 3: 53\n8 × 4: 340\n8 × 5: 1675\n8 × 6: 11174\n8 × 7: 55939\n8 × 8: 369050\n9 × 2: 9\n9 × 4: 553\n9 × 6: 31721\n9 × 8: 1812667\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDetect a cycle in an iterated function using Brent's algorithm.\n\nDetecting cycles in iterated function sequences is a sub-problem in many computer algorithms, such as factoring prime numbers. Some such algorithms are highly space efficient, such as Floyd's cycle-finding algorithm, also called the \"tortoise and the hare algorithm\". A more time efficient algorithm than \"tortoise and hare\" is Brent's Cycle algorithm. This task will implement Brent's algorithm.\n\nSee https://en.wikipedia.org/wiki/Cycle\\_detection for a discussion of the theory and discussions of other algorithms that are used to solve the problem.\n\nWhen testing the cycle detecting function, you need two things:\n\n1) An iterated function\n\n2) A starting value\n\nThe iterated function used in this example is: f(x) = (x\\*x + 1) modulo 255.\n\nThe starting value used is 3.\n\nWith these as inputs, a sample program output would be:\n\n**3,10,101,2,5,26,167,95,101,2,5,26,167,95,101,2,5,26,167,95,101,2,5,26,167,95,101,2,5,26,167,95,101,2,5,26,167,95,101,2,5**\n\n**Cycle length = 6**\n\n**Start index = 2**\n\nThe output prints the first several items in the number series produced by the iterated function, then identifies how long the cycle is (6) followed by the zero-based index of the start of the first cycle (2). From this you can see that the cycle is:\n\n101,2,5,26,167,95"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016-01\n\nPretty much a line for line translation of the Python code on the Wikipedia page.\n\n```\nsub cyclical-function (\\x) { (x * x + 1) % 255 };\n\nmy ( $l, $s ) = brent( &cyclical-function, 3 );\n\nput join ', ', (3, -> \\x { cyclical-function(x) } ... *)[^20], '...';\nsay \"Cycle length $l.\";\nsay \"Cycle start index $s.\";\nsay (3, -> \\x { cyclical-function(x) } ... *)[$s .. $s + $l - 1];\n\nsub brent (&f, $x0) {\n    my $power = my $λ = 1;\n    my $tortoise = $x0;\n    my $hare = f($x0);\n    while ($tortoise != $hare) {\n        if $power == $λ {\n            $tortoise = $hare;\n            $power *= 2;\n            $λ = 0;\n        }\n        $hare = f($hare);\n        $λ += 1;\n    }\n\n    my $μ = 0;\n    $tortoise = $hare = $x0;\n    $hare = f($hare) for ^$λ;\n\n    while ($tortoise != $hare) {\n        $tortoise = f($tortoise);\n        $hare = f($hare);\n        $μ += 1;\n    }\n    return $λ, $μ;\n}\n\n```\n\nOutput:\n\n```\n3, 10, 101, 2, 5, 26, 167, 95, 101, 2, 5, 26, 167, 95, 101, 2, 5, 26, 167, 95, ...\nCycle length 6.\nCycle start index 2.\n(101 2 5 26 167 95)\n```"}]}
{"messages": [{"role": "user", "content": "On the event of their marriage, Alf and Betty are gifted a magnificent and weighty set of twenty-six wrought iron letters, from A to Z, by their good friends Anna and Graham.\n\nAlf and Betty have, in their home, a shelf sturdy enough to display their gift, but it is only large enough to hold fifteen of the letters at one time. They decide to select fifteen of the letters and rearrange them every day, as part of their daily workout, and to select a different set of letters from time to time, when they grow bored of the current set.\n\nTo pass the time during their honeymoon, Alf and Betty select their first set of letters and find seven arrangements, one for each day of the week, that they think Anna and Graham would approve of. They are:\n\n```\n              Mon: HANDY COILS ERUPT\n              Tue: SPOIL UNDER YACHT\n              Wed: DRAIN STYLE POUCH\n              Thu: DITCH SYRUP ALONE\n              Fri: SOAPY THIRD UNCLE\n              Sat: SHINE PARTY CLOUD \n              Sun: RADIO LUNCH TYPES\n\n```\n\nThey decide to write down instructions for how to rearrange Monday's arrangement of letters into Tuesday's arrangement, Tuesday's to Wednesday's and so on, ending with Sunday's to Monday's.\n\nHowever, rather than use the letters, they number the positions on the shelf from 1 to 15, and use those position numbers in their instructions. They decide to call these instructions \"permutations\".\n\nSo, for example, to move from the Wednesday arrangement to the Thursday arrangement, i.e.\n\n```\nPosition on shelf:  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15\n              Wed:  D  R  A  I  N  S  T  Y  L  E  P  O  U  C  H\n              Thu:  D  I  T  C  H  S  Y  R  U  P  A  L  O  N  E\n\n```\n\nthey would write the permutation as:\n\n```\n             Wed:  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15\n             Thu:  1  4  7 14 15  6  8  2 13 11  3  9 12  5 10\n\n```\n\n(i.e. The D that is in position 1 on Thursday stayed in position 1, the I that is in position 2 on Thursday came from position 4, the T in position 3 came from position 7, and so on.)\n\nThey decide to call this \"two-line notation\", because it takes two lines to write it down. They notice that the first line is always going to be the same, so it can be omitted, and simplify it to a \"one-line notation\" that would look like this:\n\n```\n             Wed->Thu: 1 4 7 14 15 6 8 2 13 11 3 9 12 5 10\n\n```\n\nAs a subtle nuance, they figure out that when the letters at the right hand end don't move, they can safely leave them off the notation. For example, Mon and Tue both end with T, so for Mon->Tue the one-line notation would be fourteen numbers long rather than fifteen.\n\nThen they notice that the letter at position 9 moves to position 12, the letter at position 12 moves to position 13, and the letter at position 13 moves to position 9, forming the cycle 9->12->13->9->12->13-> etc., which they decide to write as (9 12 13). They call this a 3-cycle, because if they applied the cycle to the letters in those positions three times, they would end up back in their original positions.\n\nThey also notice that the letters in positions 1 and 6 do not move, so they decide to not write down any of the 1-cycles (not just the ones at the end as with the one-line notation.) They also decide that they will always write cycles starting with the smallest number in the cycle, and that when they write down the cycles in a permutation, the will be sorted by the first number in the permutation, smallest first.\n\nThe permutation Wed->Thur has a 10-cycle starting at position 2, a 3-cycle starting at position 9 and two 1-cycles (at positions 1 and 6), so they write down:\n\n```\n             Wed->Thu: (2 8 7 3 11 10 15 5 14 4) (9 12 13) \n\n```\n\nThey decide to call this \"cycle notation\". (By pure coincidence all the names they have chosen are the same as those used by mathematicians working in the field of abstract algebra. The abstract algebra term for converting from one-line notation to cycle notation is \"decomposition\". Alf and Betty probably wouldn't have thought of that. 1-cycles, 2-cycles, 3-cycles et cetera are collectively called k-cycles. 2-cycles are also called transpositions. One more piece of terminology: two or more cycles are disjoint if they have no elements in common. The cycles of a permutation written in cycle notation are disjoint.)\n\nAlf and Betty notice that they can perform the first k-cycle as a series of transpositions, swapping the letters in positions 14 and 4, then the letters in positions 5 and 14, then 15 and 5, then 10 and 15 and so on, ending with swapping the letters in positions 4 and 2.\n\nThen it occurs to them that it would be more efficient if one of them took the letter in position 8 and held it while the other moved the letter in position 7 and moved it to position 8, then moved 3 to 7, 11 to 3 and so on. Finally the one who had been holding the letter from position 8 could put it in position 2.\n\nComputer programmers would call this an \"in-place\" solution. The one and two-line notations lend themselves to a not-in-place solution, i.e., having a second shelf that they could conveniently move they letters to while rearranging them.\n\nIf they accidentally did the Wed->Thu permutation on the wrong day of the week they would end up with a jumble of letters that they would need to undo using a Thu->Wed permutation. Mathematicians would call this the inverse of Wed->Thu.\n\nThey could do this in two-line notation by swapping the top and bottom lines and calculating the one-line notation result.\n\n```\n             Wed->Thu:  1  4  7 14 15  6  8  2 13 11  3  9 12  5 10\n                        1  2  3  4  5  6  7  8  9 10 11 12 13 14 15\n                       --------------------------------------------\n             Thu->Wed:  1  8 11  2 14  6  3  7 12 15 10 13  9  4  5 \n\n```\n\n(To perform the calculation: The 1 in the top line has a 1 below it, so 1 goes in the first position in the result. The 2 in the second line has an 4 above it, so write 2 in the fourth position in the result. Th 3 in the second line has a seven above it, so write 3 in the seventh position in the result and so on.)\n\nOr they could use cycle notation. To invert a cycle, reverse the order of the numbers in it. To maintain the convention that cycles start with the smallest number in the cycle, move the first number in the cycle to the end before reversing. So (9 13 12) -> (13 12 9) -> (9 12 13). Do this for every cycle.\n\n```\n             Wed->Thu: (2 8 7 3 11 10 15 5 14 4) (9 12 13)\n             Thu->Wed: (2 4 14 5 15 10 11 3 7 8) (9 13 12)\n             \n\n```\n\nIf Alf and Betty went to visit Anna and Graham on a Wednesday and came home on a Friday, they'd need to figure out the permutation Wed->Fri from the permutations Wed->Thu and Thu->Fri. Mathematicians call this either composition or multiplication, and if A is the notation for Wed->Thu and B is the notation for Thu->Fri, they would write it as BA or B∙A. It may seem backwards, but that's they way mathematicians roll.\n\nNote that B∙A will NOT give the same result as A∙B – unlike regular multiplication of numbers, this sort of multiplication is generally not commutative. (There is an exception to this rule; when two or more cycles are disjoint they can be performed in any order.)\n\nThe cycle notation for Thu->Fri is\n\n```\n             Thu->Fri: (1 10 4 13 2 8 9 11 3 6) (5 7) (12 14)\n\n```\n\nand the multiplication Thu->Fri∙Wed->Thu gives the result\n\n```\n             Wed->Fri: (1 10 15 7 6 ) (2 9 14 13 11 4 8 5 12)\n\n```\n\nThe order of a permutation is the number of times it needs to be applied for the items being rearranged to return to their starting position, and the signature of a permutation is 1 if an even number of transpositions would be required to do the permutation, and -1 if it required an odd number of permutations.\n\nThe order of a permutation is the least common multiple of its cycles' lengths, and the signature is 1 if a permutation has an even number of cycles with an even number of elements, and -1 otherwise.\n\nFor a summary of the mathematics discussed here, and a demonstration of the manual method for multiplying permutations in cycle notation, I suggest the Socratica YouTube video Cycle Notation of Permutations - Abstract Algebra.\n\n(Other suitable videos are also available, including the first three parts of this YouTube playlist by Dr Angela Berardinelli.)\n\nWolfram Alpha is useful resource for testing code. If you enter one-line notation wrapped in parentheses and scroll down a little way when it has finished computing, you will find, amongst other things, the cycle decomposition and the inverse permutation. If you enter cycle notation preceded by the word \"permutation\" it will give the result of multiplying the cycles in all the notations mentioned above as well as the order and signature of the result.\n\nTask\n\n**Notes:**\n\nAlf and Betty chose to represent one-line notation as space delimited numbers without enclosing parentheses, brackets or braces. This representation is not mandated. If it is more convenient to, for example, use comma delimitation and enclosing braces, then do so. Similar considerations apply to their choice of representations for cycles and the cycles of a permutation. State which representations your solution uses.\n\nTheir choice of orderings for cycle notation (i.e. smallest number first for cycles, cycles sorted in ascending order by first number) is not mandated. If your solution uses a different ordering, describe it.\n\nSimilarly, right-to-left evaluation of cycle multiplication as composition of functions is not mandated. Show how Thu->Fri∙Wed->Thu would be written in your solution.\n\nAlf and Betty's system is one-based. If a zero-based system is more appropriate, then use that, but provide the means (e.g. one or more functions, procedures, subroutines, methods, or words, et cetera) to allow conversion to and from zero-based and one-based representations so that user I/O can be one-based. State if this is the case in your solution.\n\nTheir choice of orderings for cycle notation (i.e. smallest number first for cycles, cycles sorted in ascending order by first number) is not mandated. If your solution uses a different ordering, describe it.\n\nTheir choice of omitting trailing 1-cycles in one-line notation and all 1-cycles in cycle-notation is not mandated. Include 1-cycles in either notation if you prefer.\n\nOther names exist for some of the terms used in this task. For example, the signature is also known as the sign or parity. Use whichever terms you are comfortable with, but make it clear what they mean.\n\nData validation is not required for this task. You can assume that all arguments and user inputs are valid. If you do include sanity checks, they should not be to the detriment of the legibility of your code.\n\nIf the required functionality is available as part of your language or in a library well known to the language's user base, state this and consider writing equivalent code for bonus points.\n\n1. Provide routines (i.e. functions, procedures, subroutines, methods, words or whatever your language uses) that\n   1. given two strings containing the same characters as one another, and without repeated characters within the strings, returns the permutation in either one-line or cycle notation that transforms one of the strings into the other.\n   2. given a permutation, returns the inverse permutation, for both cycle and one-line notation.\n   3. given a permutation and a string of unique characters, returns the string with the characters permuted, for both cycle and one-line notation.\n   4. given two permutations A and B in cycle notation, returns a single permutation in cycle notation equivalent to applying first A and then B. i.e. A.B\n   5. convert permutations in one-line notation to cycle notation and vice versa.\n   6. return the order of a permutation.\n   7. return the signature of a permutation.\n2. Demonstrate how Alf and Betty can use this functionality in the scenario described above. Assume that Alf and Betty are novice programmers that have some famiiarity with your language. (i.e. Keep It Simple.) Provide the output from your demonstation code."}, {"role": "assistant", "content": "```\n# one-line\nsub infix:<➜> ($start, $end) {$start.fc.comb(/\\w/).antipairs.hash{ $end.fc.comb(/\\w/) } »+» 1}\n\n# cycle\nsub infix:<➰> ($start, $end) {\n    my @one-line = flat ($end ➜ $start);\n    my @index = flat 1..+@one-line;\n    my ($index, @cycles) = 0;\n    for @index {\n        my $this = $_ - 1;\n        while @one-line[$this] {\n            my $next = @one-line[$this];\n            @cycles[$index].push: @index[$this];\n            @one-line[$this] = Nil;\n            $this = $next - 1;\n        }\n        ++$index;\n    }\n    @cycles.grep: *.elems > 1\n}\n\n# order of a cycle\nsub order (@cycles) { [lcm] @cycles }\n\n# signature of a cycle\nsub signature (@cycles) {\n    (@cycles.elems %% 2 and all @@cycles».elems %% 2) ?? 1 !! -1\n}\n\n# apply a one-line transform\nsub apply-o ($string, @oneline) { $string.comb[@oneline].join }\n\n# apply a cyclical transform\nsub apply-c ($string, @cycle) {\n    my @string = flat '', $string.comb;\n    @cycle.map: { @string[|$_].=rotate(-1) }\n    @string.join\n}\n\n# Alf & Bettys letter arrangements\nmy %arrangment =\n    :Mon<HANDYCOILSERUPT>,\n    :Tue<SPOILUNDERYACHT>,\n    :Wed<DRAINSTYLEPOUCH>,\n    :Thu<DITCHSYRUPALONE>,\n    :Fri<SOAPYTHIRDUNCLE>,\n    :Sat<SHINEPARTYCLOUD>,\n    :Sun<RADIOLUNCHTYPES>;\n\n# some convenience variables \nmy @days = <Sun Mon Tue Wed Thu Fri Sat Sun>;\nmy @o = @days.rotor(2 => -1).map: { (%arrangment{.[0]} ➜ %arrangment{.[1]}) »-» 1 }\nmy @c = @days.rotor(2 => -1).map: { (%arrangment{.[0]} ➰ %arrangment{.[1]}) }\n\nmy $today;\n\n# The task\nsay qq:to/ALF&BETTY/;\nOn Thursdays Alf and Betty should rearrange\ntheir letters using these cycles:  {gist %arrangment<Wed> ➰ %arrangment<Thu>}\n\nSo that {%arrangment<Wed>} becomes {%arrangment<Wed>.&apply-o: (%arrangment<Wed> ➜ %arrangment<Thu>) »-» 1}\n\nor they could use the one-line notation:  {gist %arrangment<Wed> ➜ %arrangment<Thu>}\n\n\nTo revert to the Wednesday arrangement they\nshould use these cycles:  {gist %arrangment<Thu> ➰ %arrangment<Wed>}\n\nor with the one-line notation:  {gist %arrangment<Thu> ➜ %arrangment<Wed>}\n\nSo that {%arrangment<Thu>} becomes {%arrangment<Thu>.&apply-o: (%arrangment<Thu> ➜ %arrangment<Wed>) »-» 1}\n\n\nStarting with the Sunday arrangement and applying each of the daily\npermutations consecutively, the arrangements will be:\n\n      {$today = %arrangment<Sun>}\n\n{join \"\\n\", @days[1..*].map: { sprintf \"%s:  %s\", $_, $today = $today.&apply-o: @o[$++] } }\n\n\nTo go from Wednesday to Friday in a single step they should use these cycles:\n{gist %arrangment<Wed> ➰ %arrangment<Fri>}\n\nSo that {%arrangment<Wed>} becomes {%arrangment<Fri>}\n\n\nThese are the signatures of the permutations:\n\n  Mon Tue Wed Thu Fri Sat Sun\n  {@c.map(&signature)».fmt(\"%2d\").join: '  '}\n\nThese are the orders of the permutations:\n\n  Mon Tue Wed Thu Fri Sat Sun\n  {@c.map(&order)».fmt(\"%2d\").join: '  '}\n\nApplying the Friday cycle to a string 10 times:\n\n   {$today = 'STOREDAILYPUNCH'}\n\n{join \"\\n\", (1..10).map: {sprintf \"%2d %s\", $_, $today = $today.&apply-c: @c[4]} }\nALF&BETTY\n\nsay 'and one last transform:';\nsay 'STOREDAILYPUNCH'.&apply-c: [[<1 6 12 2 3 4 13 15 9 11 5 14 8 10 7>],];\n\n```\n\nOutput:\n\n```\nOn Thursdays Alf and Betty should rearrange\ntheir letters using these cycles:  ([2 8 7 3 11 10 15 5 14 4] [9 12 13])\n\nSo that DRAINSTYLEPOUCH becomes DITCHSYRUPALONE\n\nor they could use the one-line notation:  (1 4 7 14 15 6 8 2 13 11 3 9 12 5 10)\n\n\nTo revert to the Wednesday arrangement they\nshould use these cycles:  ([2 4 14 5 15 10 11 3 7 8] [9 13 12])\n\nor with the one-line notation:  (1 8 11 2 14 6 3 7 12 15 10 13 9 4 5)\n\nSo that DITCHSYRUPALONE becomes DRAINSTYLEPOUCH\n\n\nStarting with the Sunday arrangement and applying each of the daily\npermutations consecutively, the arrangements will be:\n\n      RADIOLUNCHTYPES\n\nMon:  HANDYCOILSERUPT\nTue:  SPOILUNDERYACHT\nWed:  DRAINSTYLEPOUCH\nThu:  DITCHSYRUPALONE\nFri:  SOAPYTHIRDUNCLE\nSat:  SHINEPARTYCLOUD\nSun:  RADIOLUNCHTYPES\n\n\nTo go from Wednesday to Friday in a single step they should use these cycles:\n([1 10 15 7 6] [2 9 14 13 11 4 8 5 12])\n\nSo that DRAINSTYLEPOUCH becomes SOAPYTHIRDUNCLE\n\n\nThese are the signatures of the permutations:\n\n  Mon Tue Wed Thu Fri Sat Sun\n  -1  -1   1   1  -1   1  -1\n\nThese are the orders of the permutations:\n\n  Mon Tue Wed Thu Fri Sat Sun\n  18  30  12  30  10  33  40\n\nApplying the Friday cycle to a string 10 times:\n\n   STOREDAILYPUNCH\n\n 1 DNPYAOETISLCRUH\n 2 ORLSEPANTDIUYCH\n 3 PYIDALERNOTCSUH\n 4 LSTOEIAYRPNUDCH\n 5 IDNPATESYLRCOUH\n 6 TORLENADSIYUPCH\n 7 NPYIAREODTSCLUH\n 8 RLSTEYAPONDUICH\n 9 YIDNASELPROCTUH\n10 STOREDAILYPUNCH\n\nand one last transform:\nAUTOPSYCHILDREN\n\n```"}]}
{"messages": [{"role": "user", "content": "A **cyclops number** is a number with an odd number of digits that has a zero in the center, but nowhere else. They are named so in tribute to the one eyed giants Cyclops from Greek mythology.\n\nCyclops numbers can be found in any base. This task strictly is looking for cyclops numbers in base 10.\n\nThere are many different classifications of cyclops numbers with minor differences in characteristics. In an effort to head off a whole series of tasks with tiny variations, we will cover several variants here.\n\nTask\n\n* Find and display here on this page the first 50 **cyclops numbers** in base 10 (all of the sub tasks are restricted to base 10).\n\n* Find and display here on this page the first 50 **prime cyclops numbers**. (cyclops numbers that are prime.)\n\n* Find and display here on this page the first 50 **blind prime cyclops numbers**. (prime cyclops numbers that remain prime when \"blinded\"; the zero is removed from the center.)\n\n* Find and display here on this page the first 50 **palindromic prime cyclops numbers**. (prime cyclops numbers that are palindromes.)\n\nStretch\n\n* Find and display the first **cyclops number** greater than **ten million** (10,000,000) and the index (place) in the series where it is found.\n\n* Find and display the first **prime cyclops number** greater than **ten million** (10,000,000) and the index (place) in the series where it is found.\n\n* Find and display the first **blind prime cyclops number** greater than **ten million** (10,000,000) and the index (place) in the series where it is found.\n\n* Find and display the first **palindromic prime cyclops number** greater than **ten million** (10,000,000) and the index (place) in the series where it is found.\n\n(**Note:** there ***are*** no cyclops numbers between ten million and one hundred million, they need to have an odd number of digits)\n\nSee also\n\n* OEIS A134808 - Cyclops numbers\n\n* OEIS A134809 - Cyclops primes\n\n* OEIS A329737 - Cyclops primes that remain prime after being \"blinded\"\n\n* OEIS A136098 - Prime palindromic cyclops numbers"}, {"role": "assistant", "content": "<\n\n```\nuse Lingua::EN::Numbers;\n\nmy @cyclops = 0, |flat lazy ^∞ .map: -> $exp {\n      my @oom = (exp($exp, 10) ..^ exp($exp + 1, 10)).grep: { !.contains: 0 }\n      |@oom.hyper.map: { $_ ~ 0 «~« @oom }\n}\n\nmy @prime-cyclops = @cyclops.grep: { .is-prime };\n\nfor '',                   @cyclops,\n    'prime ',             @prime-cyclops,\n    'blind prime ',       @prime-cyclops.grep( { .trans('0' => '').is-prime } ),\n    'palindromic prime ', @prime-cyclops.grep( { $_ eq .flip } )\n  -> $type, $iterator {\n    say \"\\n\\nFirst 50 {$type}cyclops numbers:\\n\" ~ $iterator[^50].batch(10)».fmt(\"%7d\").join(\"\\n\") ~\n        \"\\n\\nFirst {$type}cyclops number > 10,000,000: \" ~ comma($iterator.first: * > 1e7 ) ~\n        \" - at (zero based) index: \" ~ comma $iterator.first: * > 1e7, :k;\n}\n\n```\n\nOutput:\n\n```\nFirst 50 cyclops numbers:\n      0     101     102     103     104     105     106     107     108     109\n    201     202     203     204     205     206     207     208     209     301\n    302     303     304     305     306     307     308     309     401     402\n    403     404     405     406     407     408     409     501     502     503\n    504     505     506     507     508     509     601     602     603     604\n\nFirst cyclops number > 10,000,000: 111,101,111 - at (zero based) index: 538,084\n\n\nFirst 50 prime cyclops numbers:\n    101     103     107     109     307     401     409     503     509     601\n    607     701     709     809     907   11027   11047   11057   11059   11069\n  11071   11083   11087   11093   12011   12037   12041   12043   12049   12071\n  12073   12097   13033   13037   13043   13049   13063   13093   13099   14011\n  14029   14033   14051   14057   14071   14081   14083   14087   15013   15017\n\nFirst prime cyclops number > 10,000,000: 111,101,129 - at (zero based) index: 39,319\n\n\nFirst 50 blind prime cyclops numbers:\n    101     103     107     109     307     401     503     509     601     607\n    701     709     809     907   11071   11087   11093   12037   12049   12097\n  13099   14029   14033   14051   14071   14081   14083   14087   15031   15053\n  15083   16057   16063   16067   16069   16097   17021   17033   17041   17047\n  17053   17077   18047   18061   18077   18089   19013   19031   19051   19073\n\nFirst blind prime cyclops number > 10,000,000: 111,101,161 - at (zero based) index: 11,393\n\n\nFirst 50 palindromic prime cyclops numbers:\n    101   16061   31013   35053   38083   73037   74047   91019   94049 1120211\n1150511 1160611 1180811 1190911 1250521 1280821 1360631 1390931 1490941 1520251\n1550551 1580851 1630361 1640461 1660661 1670761 1730371 1820281 1880881 1930391\n1970791 3140413 3160613 3260623 3310133 3380833 3460643 3470743 3590953 3670763\n3680863 3970793 7190917 7250527 7310137 7540457 7630367 7690967 7750577 7820287\n\nFirst palindromic prime cyclops number > 10,000,000: 114,808,411 - at (zero based) index: 66\n```"}]}
{"messages": [{"role": "user", "content": "The nth Cyclotomic polynomial, for any positive integer n, is the unique irreducible polynomial of largest degree with integer coefficients that is a divisor of x^n − 1, and is not a divisor of x^k − 1 for any k < n.\n\nTask\n\n* Find and print the first 30 cyclotomic polynomials.\n* Find and print the order of the first 10 cyclotomic polynomials that have n or -n as a coefficient.\n\nSee also\n\n* Wikipedia article, Cyclotomic polynomial, showing ways to calculate them.\n* The sequence A013594 with the smallest order of cyclotomic polynomial containing n or -n as a coefficient."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.01\n\n**Translation of**: Perl\n\nUses the same library as Perl, so comes with the same caveats.\n\n```\nuse Math::Polynomial::Cyclotomic:from<Perl5> <cyclo_poly_iterate cyclo_poly>;\n\nsay 'First 30 cyclotomic polynomials:';\nmy $iterator = cyclo_poly_iterate(1);\nsay \"Φ($_) = \" ~ super $iterator().Str for 1..30;\n\nsay \"\\nSmallest cyclotomic polynomial with |n| as a coefficient:\";\nsay \"Φ(1) has a coefficient magnitude: 1\";\n\nmy $index = 0;\nfor 2..9 -> $coefficient {\n    loop {\n        $index += 5;\n        my \\Φ = cyclo_poly($index);\n        next unless Φ ~~ / $coefficient\\* /;\n        say \"Φ($index) has a coefficient magnitude: $coefficient\";\n        $index -= 5;\n        last;\n    }\n}\n\nsub super ($str) {\n    $str.subst( / '^' (\\d+) /, { $0.trans([<0123456789>.comb] => [<⁰¹²³⁴⁵⁶⁷⁸⁹>.comb]) }, :g)\n}\n\n```\n\n```\nFirst 30 cyclotomic polynomials:\nΦ(1) = (x - 1)\nΦ(2) = (x + 1)\nΦ(3) = (x² + x + 1)\nΦ(4) = (x² + 1)\nΦ(5) = (x⁴ + x³ + x² + x + 1)\nΦ(6) = (x² - x + 1)\nΦ(7) = (x⁶ + x⁵ + x⁴ + x³ + x² + x + 1)\nΦ(8) = (x⁴ + 1)\nΦ(9) = (x⁶ + x³ + 1)\nΦ(10) = (x⁴ - x³ + x² - x + 1)\nΦ(11) = (x¹⁰ + x⁹ + x⁸ + x⁷ + x⁶ + x⁵ + x⁴ + x³ + x² + x + 1)\nΦ(12) = (x⁴ - x² + 1)\nΦ(13) = (x¹² + x¹¹ + x¹⁰ + x⁹ + x⁸ + x⁷ + x⁶ + x⁵ + x⁴ + x³ + x² + x + 1)\nΦ(14) = (x⁶ - x⁵ + x⁴ - x³ + x² - x + 1)\nΦ(15) = (x⁸ - x⁷ + x⁵ - x⁴ + x³ - x + 1)\nΦ(16) = (x⁸ + 1)\nΦ(17) = (x¹⁶ + x¹⁵ + x¹⁴ + x¹³ + x¹² + x¹¹ + x¹⁰ + x⁹ + x⁸ + x⁷ + x⁶ + x⁵ + x⁴ + x³ + x² + x + 1)\nΦ(18) = (x⁶ - x³ + 1)\nΦ(19) = (x¹⁸ + x¹⁷ + x¹⁶ + x¹⁵ + x¹⁴ + x¹³ + x¹² + x¹¹ + x¹⁰ + x⁹ + x⁸ + x⁷ + x⁶ + x⁵ + x⁴ + x³ + x² + x + 1)\nΦ(20) = (x⁸ - x⁶ + x⁴ - x² + 1)\nΦ(21) = (x¹² - x¹¹ + x⁹ - x⁸ + x⁶ - x⁴ + x³ - x + 1)\nΦ(22) = (x¹⁰ - x⁹ + x⁸ - x⁷ + x⁶ - x⁵ + x⁴ - x³ + x² - x + 1)\nΦ(23) = (x²² + x²¹ + x²⁰ + x¹⁹ + x¹⁸ + x¹⁷ + x¹⁶ + x¹⁵ + x¹⁴ + x¹³ + x¹² + x¹¹ + x¹⁰ + x⁹ + x⁸ + x⁷ + x⁶ + x⁵ + x⁴ + x³ + x² + x + 1)\nΦ(24) = (x⁸ - x⁴ + 1)\nΦ(25) = (x²⁰ + x¹⁵ + x¹⁰ + x⁵ + 1)\nΦ(26) = (x¹² - x¹¹ + x¹⁰ - x⁹ + x⁸ - x⁷ + x⁶ - x⁵ + x⁴ - x³ + x² - x + 1)\nΦ(27) = (x¹⁸ + x⁹ + 1)\nΦ(28) = (x¹² - x¹⁰ + x⁸ - x⁶ + x⁴ - x² + 1)\nΦ(29) = (x²⁸ + x²⁷ + x²⁶ + x²⁵ + x²⁴ + x²³ + x²² + x²¹ + x²⁰ + x¹⁹ + x¹⁸ + x¹⁷ + x¹⁶ + x¹⁵ + x¹⁴ + x¹³ + x¹² + x¹¹ + x¹⁰ + x⁹ + x⁸ + x⁷ + x⁶ + x⁵ + x⁴ + x³ + x² + x + 1)\nΦ(30) = (x⁸ + x⁷ - x⁵ - x⁴ - x³ + x + 1)\n\nSmallest cyclotomic polynomial with |n| as a coefficient:\nΦ(1) has a coefficient magnitude: 1\nΦ(105) has a coefficient magnitude: 2\nΦ(385) has a coefficient magnitude: 3\nΦ(1365) has a coefficient magnitude: 4\nΦ(1785) has a coefficient magnitude: 5\nΦ(2805) has a coefficient magnitude: 6\nΦ(3135) has a coefficient magnitude: 7\nΦ(6545) has a coefficient magnitude: 8\nΦ(6545) has a coefficient magnitude: 9\n```"}]}
{"messages": [{"role": "user", "content": "The Damm algorithm is a checksum algorithm which detects all single digit errors and adjacent transposition errors.\n\nThe algorithm is named after H. Michael Damm.\n\nTask\n\nVerify the checksum, stored as last digit of an input."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.05\n\n```\nsub damm ( *@digits ) {\n    my @tbl = [0, 3, 1, 7, 5, 9, 8, 6, 4, 2],\n              [7, 0, 9, 2, 1, 5, 4, 8, 6, 3],\n              [4, 2, 0, 6, 8, 7, 1, 3, 5, 9],\n              [1, 7, 5, 0, 9, 8, 3, 4, 2, 6],\n              [6, 1, 2, 3, 0, 4, 5, 9, 7, 8],\n              [3, 6, 7, 4, 2, 0, 9, 5, 8, 1],\n              [5, 8, 6, 9, 7, 2, 0, 1, 3, 4],\n              [8, 9, 4, 5, 3, 6, 2, 0, 1, 7],\n              [9, 4, 3, 8, 6, 1, 7, 2, 0, 5],\n              [2, 5, 8, 1, 4, 3, 6, 7, 9, 0];\n    my $row = 0;\n    for @digits -> $col { $row = @tbl[$row][$col] }\n    not $row\n}\n\n# Testing\nfor 5724, 5727, 112946 {\n    say \"$_:\\tChecksum digit { damm( $_.comb ) ?? '' !! 'in' }correct.\"\n}\n\n```\n\nOutput:\n\n```\n5724:\tChecksum digit correct.\n5727:\tChecksum digit incorrect.\n112946:\tChecksum digit correct.\n```"}]}
{"messages": [{"role": "user", "content": "Demonstrate the Data Encryption Standard. For a complete description of the algorithm see: The DES Algorithm Illustrated\n\n**Task:**\n\nUse the\n\n:   Key 0e329232ea6d0d73\n:   to encrypt 8787878787878787\n:   and display the result 0000000000000000.\n\nBonus (optional): add standard padding to match the C#, Java, Modula-2, Kotlin, and Phix entries, so the above encrypted result would instead be 0000000000000000A913F4CB0BD30F97."}, {"role": "assistant", "content": "(formerly Perl 6)\nThanks to SqrtNegInf for pointing out that \\r\\n is a single grapheme. (link 1, link 2)\n\n**Translation of**: Phix\n\n```\n# 20220222 Updated Raku programming solution\n\nmy \\PC1 = <\n   56 48 40 32 24 16  8         0 57 49 41 33 25 17  \n    9  1 58 50 42 34 26        18 10  2 59 51 43 35 \n   62 54 46 38 30 22 14         6 61 53 45 37 29 21 \n   13  5 60 52 44 36 28        20 12  4 27 19 11  3\n>; # Permuted choice 1 (PC-1) - Parity Drop Table, https://w.wiki/4yKS \n \nmy \\PC2 = <\n   13 16 10 23  0  4  2 27     14  5 20  9 22 18 11  3 \n   25  7 15  6 26 19 12  1     40 51 30 36 46 54 29 39 \n   50 44 32 47 43 48 38 55     33 52 45 41 49 35 28 31\n>; # Permuted choice 2 (PC-2) - Key Compression Table, https://w.wiki/4yKR\n \nmy \\IP = <\n   57 49 41 33 25 17  9  1     59 51 43 35 27 19 11  3 \n   61 53 45 37 29 21 13  5     63 55 47 39 31 23 15  7 \n   56 48 40 32 24 16  8  0     58 50 42 34 26 18 10  2 \n   60 52 44 36 28 20 12  4     62 54 46 38 30 22 14  6\n>; # Initial permutation (IP), https://w.wiki/4yKN\n \nmy \\IP2 = <\n   39  7 47 15 55 23 63 31     38  6 46 14 54 22 62 30 \n   37  5 45 13 53 21 61 29     36  4 44 12 52 20 60 28 \n   35  3 43 11 51 19 59 27     34  2 42 10 50 18 58 26 \n   33  1 41  9 49 17 57 25     32  0 40  8 48 16 56 24\n>; # Final permutation (IP⁻¹), https://w.wiki/4yKP\n \nmy \\S = ( <\n   14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7   0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8\n   4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0   15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13\n> , <\n   15 1 8 14 6 11 3 4 9 7 2 13 12 0 5 10   3 13 4 7 15 2 8 14 12 0 1 10 6 9 11 5\n   0 14 7 11 10 4 13 1 5 8 12 6 9 3 2 15   13 8 10 1 3 15 4 2 11 6 7 12 0 5 14 9\n> , <\n   10 0 9 14 6 3 15 5 1 13 12 7 11 4 2 8   13 7 0 9 3 4 6 10 2 8 5 14 12 11 15 1\n   13 6 4 9 8 15 3 0 11 1 2 12 5 10 14 7   1 10 13 0 6 9 8 7 4 15 14 3 11 5 2 12\n> , <\n   7 13 14 3 0 6 9 10 1 2 8 5 11 12 4 15   13 8 11 5 6 15 0 3 4 7 2 12 1 10 14 9\n   10 6 9 0 12 11 7 13 15 1 3 14 5 2 8 4   3 15 0 6 10 1 13 8 9 4 5 11 12 7 2 14\n> , <\n   2 12 4 1 7 10 11 6 8 5 3 15 13 0 14 9   14 11 2 12 4 7 13 1 5 0 15 10 3 9 8 6\n   4 2 1 11 10 13 7 8 15 9 12 5 6 3 0 14   11 8 12 7 1 14 2 13 6 15 0 9 10 4 5 3\n> , <\n   12 1 10 15 9 2 6 8 0 13 3 4 14 7 5 11   10 15 4 2 7 12 9 5 6 1 13 14 0 11 3 8\n   9 14 15 5 2 8 12 3 7 0 4 10 1 13 11 6   4 3 2 12 9 5 15 10 11 14 1 7 6 0 8 13\n> , <\n   4 11 2 14 15 0 8 13 3 12 9 7 5 10 6 1   13 0 11 7 4 9 1 10 14 3 5 12 2 15 8 6\n   1 4 11 13 12 3 7 14 10 15 6 8 0 5 9 2   6 11 13 8 1 4 10 7 9 5 0 15 14 2 3 12\n> , <\n   13 2 8 4 6 15 11 1 10 9 3 14 5 0 12 7   1 15 13 8 10 3 7 4 12 5 6 11 0 14 9 2\n   7 11 4 1 9 12 14 2 0 6 10 13 15 3 5 8   2 1 14 7 4 10 8 13 15 12 9 0 3 5 6 11\n> ); # S-Boxes, each replaces a 6-bit input with a 4-bit output, w.wiki/4yG8 \n \nmy \\P = <\n   15 6 19 20   28 11 27 16     0 14 22 25     4 17 30  9 \n    1 7 23 13   31 26  2  8    18 12 29  5    21 10  3 24\n>; # Permutation (P), shuffles the bits of a 32-bit half-block, w.wiki/4yKT\n \n# Expansion function (E), expand 32-bit half-block to 48 bits, w.wiki/4yGC\nmy \\E = flat 31,0..4,3..8,7..12,11..16,15..20,19..24,23..28,27..31,0;\n \nmy \\SHIFTS = flat 1, 1, 2 xx 6, 1, 2 xx 6, 1 ; # left shifts, w.wiki/4yKV\n \n## Helper subs\n \n# convert iso-8859-1 to hexadecimals(%02X)\nsub b2h (\\b) { b.ords.fmt('%02X','') }\n \n# convert UTF8s to bytes\nsub u2b (\\u) { u.encode.list.chrs } \n \n# convert hexadecimals(%02X) to UTF-8\nsub h2u (\\h) { Blob.new( h.comb(2)».&{ :16($_) } ).decode }\n \n# convert quadbits to hex\nsub q2h (\\q) { [~] q.comb(4)».&{ :2($_).fmt('%X') } }\n \n# convert every two quadbits to bytes\nsub q2b (\\q) { q.comb(8)».&{ :2($_) } }\n \n# turn a 16 digit hexadecimal str to a 64 bits list\nsub h2b (\\h) { flat h.comb».&{ :16($_).base(2).fmt('%04s').comb } }\n \n# convert hexadecimals to bytes\nsub h2B (\\h) { [~] h.comb(2)».&{ chr \"0x$_\" } }\n \n# s is 16 digit hexadecimal str, M is a permuation matrix/vector\nsub map64(\\s,\\M) { (h2b s)[M] } \n \n## Core subs\n \nsub get_subkeys(Str \\key --> Seq) { # return a Seq with 16 bit vectors\n   my (@C,@D) := { .rotor(.elems div 2)».Array }(map64 key, PC1); #w.wiki/4yKV\n   my \\CD = (^16)».&{ [ |@C.=rotate(SHIFTS[$_]), |@D.=rotate(SHIFTS[$_]) ] }\n   # key compression rounds, https://w.wiki/4yKb\n   return (^16).map: -> \\row { (^48).map: -> \\col { CD[row][ PC2[col] ] } }\n}\n \nsub ƒ (List \\R, Seq \\Kₙ --> List) {\n   my @er = map { Kₙ[$_] +^ R[E[$_]] }, ^48;\n \n   return ( flat (^8)».&{ # Sₙ(Bₙ) loop, process @er six bits at a time \n      S[$_][ ([~] @er[$_*6   ,  $_*6+5]).parse-base(2)*16 +   # 2 bits\n             ([~] @er[$_*6+1 .. $_*6+4]).parse-base(2)      ] # 4 bits\n      .fmt('%04b').comb } # ((S[][] to binary).split)*8.flat  \n   )[P] \n}\n \nsub process_block(Str \\message, Seq \\K --> Str) { # return 8 quadbits\n   my (@L,@R) := { .rotor(.elems div 2)».Array }(map64 (b2h message), IP);  \n   { my @Lₙ = @R; my @Rₙ = @L Z+^ ƒ @R, K[$_]; @L = @Lₙ; @R = @Rₙ } for ^16;\n \n   return [~] (|@R, |@L)[IP2] # inverse of the initial permutation\n}\n \nsub des(Str \\key, Str $msg is copy, Bool \\DECODE --> Str) { # return hexdecimal\n \n   my \\length = $msg.encode('iso-8859-1').bytes;\n \n   die \"Message must be in multiples of 8 bytes\" if ( DECODE and length % 8 );\n \n   my \\K = { DECODE ?? reverse $_ !! $_ }(get_subkeys key);\n \n   # CMS style padding as per RFC 1423 & RFC 5652\n   { $msg ~= (my \\Pad = 8 - length % 8).chr x Pad } unless DECODE; \n \n   my $quad = [~] ( 0, 8 … $msg.encode('iso-8859-1').bytes-8 ).map: \n                 { process_block substr($msg,$_,8), K }\n \n   DECODE ?? do { my @decrypt = q2b $quad; # quadbits to a byte code point list\n                  @decrypt.pop xx @decrypt.tail; # remove padding\n                  return b2h [~] @decrypt.chrs }      \n          !! do { return q2h $quad }\n}\n \nsay \"Encryption examples: \";\nsay des \"133457799BBCDFF1\", h2B(\"0123456789ABCDEF\"), False;\nsay des \"0E329232EA6D0D73\", h2B(\"8787878787878787\"), False;\nsay des \"0E329232EA6D0D73\", \"Your lips are smoother than vaseline\", False;\nsay des \"0E329232EA6D0D73\", \"Your lips are smoother than vaseline\\r\\n\", False;\nsay des \"0E329232EA6D0D73\", u2b(\"BMP: こんにちは ; Astral plane: 𝒳𝒴𝒵\"), False;\n \nsay \"\\nDecryption examples: \";\nsay des \"133457799BBCDFF1\", h2B(\"85E813540F0AB405FDF2E174492922F8\"), True;\nsay des \"0E329232EA6D0D73\", h2B(\"0000000000000000A913F4CB0BD30F97\"), True;\nsay h2B des \"0E329232EA6D0D73\", h2B(\"C0999FDDE378D7ED727DA00BCA5A84EE47F269A4D6438190D9D52F78F535849980A2E7453703513E\"), True;\nsay h2B des \"0E329232EA6D0D73\", h2B(\"C0999FDDE378D7ED727DA00BCA5A84EE47F269A4D6438190D9D52F78F53584997F922CCB5B068D99\"), True;\nsay h2u des \"0E329232EA6D0D73\", h2B(\"C040FB6A6E72D7C36D60CA9B9A35EB38D3194468AD808103C28E33AEF0B268D0E0366C160B028DDACF340003DCA8969343EBBD289DB94774\"), True;\n\n```\n\nOutput:\n\n```\nEncryption examples:\n85E813540F0AB405FDF2E174492922F8\n0000000000000000A913F4CB0BD30F97\nC0999FDDE378D7ED727DA00BCA5A84EE47F269A4D6438190D9D52F78F535849980A2E7453703513E\nC0999FDDE378D7ED727DA00BCA5A84EE47F269A4D6438190D9D52F78F53584997F922CCB5B068D99\nC040FB6A6E72D7C36D60CA9B9A35EB38D3194468AD808103C28E33AEF0B268D0E0366C160B028DDACF340003DCA8969343EBBD289DB94774\n\nDecryption examples:\n0123456789abcdef\n8787878787878787\nYour lips are smoother than vaseline\nYour lips are smoother than vaseline\n\nBMP: こんにちは ; Astral plane: 𝒳𝒴𝒵\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nTask\n\nDisplay the   current date   in the formats of:\n\n:   :   :   * **2007-11-23**     and\n            * **Friday, November 23, 2007**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Library:** DateTime::Format\n\n```\nuse DateTime::Format;\n\nmy $dt = DateTime.now;\n\nsay strftime('%Y-%m-%d', $dt);\nsay strftime('%A, %B %d, %Y', $dt);\n\n```\n\nThe built-in Date and DateTime classes both offer support for the ISO format:\n\n```\nmy $d = Date.today;\n\nsay $d.yyyy-mm-dd;\n\n```\n\nThey don't include the longer format specified in the task, but you can always roll your own formatter instead of importing the library:\n\n```\nmy @months = <January February March April May June July\n              August September October November December>;\nmy @days = <Monday Tuesday Wednesday Thursday Friday Saturday Sunday>;\nmy $us-long = sub ($self) { \"{@days[$self.day-of-week - 1]}, {@months[$self.month - 1]} {$self.day}, {$self.year}\" };\nmy $d = Date.today :formatter($us-long);\n\nsay $d.yyyy-mm-dd; # still works\nsay $d; # uses our formatter sub\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven the date string \"March 7 2009 7:30pm EST\",   \noutput the time 12 hours later in any human-readable format.\n\nAs extra credit, display the resulting time in a time zone different from your own."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku comes with a built-in DateTime type to support most aspects of standard civic time calculation\nthat are not dependent on cultural idiosyncrasies.\n\nUnfortunately, Raku does not yet have a date parsing module – mostly due to a reticence to inflict Western cultural imperialism on other cultures... or maybe just due to laziness. But that just gives us another opportunity to demonstrate the built-in grammar support.\n\n```\nmy @month = <January February March April May June July August September October November December>;\nmy %month = flat (@month Z=> 1..12), (@month».substr(0,3) Z=> 1..12), 'Sept' => 9;\n\ngrammar US-DateTime {\n    rule TOP { <month> <day>','? <year>','? <time> <tz> }\n\n    token month {\n\t(\\w+)'.'?  { make %month{$0} // die \"Bad month name: $0\" }\n    }\n\n    token day { (\\d ** 1..2) { make +$0 } }\n\n    token year { (\\d ** 1..4) { make +$0 } }\n\n    token time {\n\t(\\d ** 1..2) ':' (\\d ** 2) \\h* ( :i <[ap]> \\.? m | '' )\n\t{\n\t    my $h = $0 % 12;\n\t    my $m = $1;\n\t    $h += 12 if $2 and $2.substr(0,1).lc eq 'p';\n\t    make $h * 60 + $m;\n\t}\n    }\n\n    token tz {  # quick and dirty for this task\n        [\n        |        EDT  { make -4 }\n        | [ EST| CDT] { make -5 }\n        | [ CST| MDT] { make -6 }\n        | [ MST| PDT] { make -7 }\n        | [ PST|AKDT] { make -8 }\n        | [AKST|HADT] { make -9 }\n        |  HAST\n        ]\n    }\n}\n\n$/ = US-DateTime.parse('March 7 2009 7:30pm EST') or die \"Can't parse date\";\n\nmy $year     = $<year>.ast;\nmy $month    = $<month>.ast;\nmy $day      = $<day>.ast;\nmy $hour     = $<time>.ast div 60;\nmy $minute   = $<time>.ast mod 60;\nmy $timezone = $<tz>.ast * 3600;\n\nmy $dt = DateTime.new(:$year, :$month, :$day, :$hour, :$minute, :$timezone).in-timezone(0);\n\n$dt = $dt.later(hours => 12);\n\nsay \"12 hours later, UTC: $dt\";\nsay \"12 hours later, PDT: $dt.in-timezone(-7 * 3600)\";\n\n```\n\nOutput:\n\n```\n12 hours later, UTC: 2009-03-08T12:30:00Z\n12 hours later, PDT: 2009-03-08T05:30:00-08:00\n```"}]}
{"messages": [{"role": "user", "content": "Scenario\n\nA sailor signs up to a dating agency hoping to find a suitable mate.\n\nThe dating agency has 10 ladies on its books who may be suitable and uses the algorithm \"all the nice girls love a sailor\" to decide which ones to put forward for the sailor's consideration.\n\nThe sailor uses a different algorithm (\"lady is lovable\") to decide which ladies to actually date.\n\nTask\n\nModel this scenario in your language.\n\nGive the sailor and ladies some names.\n\nUse some arbitrary method based on the ladies' names to determine whether they're *nice* and/or *lovable*. For preference, choose a method where the outcomes are (more or less) equally likely.\n\nHence, determine which ladies the dating agency should suggest and which of these the sailor should offer to date.\n\nNote\n\nThis task is intended as a bit of fun as well as a simple exercise in object modelling so hopefully it won't offend anyone!"}, {"role": "assistant", "content": "Welcome to the **Arbitrary and Capricious Dating Agency**, (We don't use zodiacs, but we're just as arbitrary!)\n\n```\nuse Digest::SHA1::Native;\n\nmy %ladies = < Alice Beth Cecilia Donna Eunice Fran Genevieve Holly Irene Josephine Kathlene Loralie Margaret\n               Nancy Odelle Pamela Quinci Rhonda Stephanie Theresa Ursula Victoria Wren Yasmine Zoey >.map: -> $name {\n    $name => {\n        loves   => :16(sha1-hex($name).substr(0,4)),\n        lovable => :16(sha1-hex($name).substr(*-4))\n    }\n}\n\nmy %sailors = < Ahab Brutus Popeye >.map: -> $name {\n    $name => {\n        loves   => :16(sha1-hex($name).substr(0,4)),\n        lovable => :16(sha1-hex($name).substr(*-4))\n    }\n}\n\nfor %sailors.sort( *.key ) -> $sailor {\n    printf \"%6s will like: \", $sailor.key;\n    say join ', ', my @likes = %ladies.sort( { abs $sailor.value.<loves> - .value.<loves> } ).head(10)».key;\n    print '     Is liked by: ';\n    say join ', ',  my @liked = %ladies.sort( { abs $sailor.value.<lovable> - .value.<lovable> } ).head(10)».key;\n    my %matches;\n    for @liked.reverse Z, (1..10) { %matches{.[0]} += .[1] };\n    for @likes.reverse Z, (1..10) { %matches{.[0]} += .[1] };\n    say 'Best match(s): ' ~ %matches.grep(*.value == %matches.values.max)».key.sort.join(', ');\n    say '';\n}\n\n```\n\n```\n  Ahab will like: Eunice, Ursula, Irene, Holly, Fran, Genevieve, Zoey, Donna, Cecilia, Alice\n     Is liked by: Nancy, Theresa, Victoria, Genevieve, Alice, Rhonda, Kathlene, Odelle, Eunice, Pamela\nBest match(s): Eunice, Genevieve\n\nBrutus will like: Beth, Nancy, Quinci, Odelle, Josephine, Kathlene, Theresa, Rhonda, Wren, Margaret\n     Is liked by: Yasmine, Margaret, Loralie, Holly, Wren, Fran, Quinci, Eunice, Alice, Victoria\nBest match(s): Quinci\n\nPopeye will like: Loralie, Theresa, Stephanie, Yasmine, Alice, Cecilia, Donna, Zoey, Nancy, Genevieve\n     Is liked by: Loralie, Margaret, Holly, Wren, Yasmine, Fran, Quinci, Eunice, Alice, Victoria\nBest match(s): Loralie\n```"}]}
{"messages": [{"role": "user", "content": "A company decides that whenever Xmas falls on a Sunday they will give their workers all extra paid holidays so that, together with any public holidays, workers will not have to work the following week (between the 25th of December and the first of January).\n\nTask\n\n**In what years between 2008 and 2121 will the 25th of December be a Sunday?**\n\nUsing any standard date handling libraries of your programming language;\ncompare the dates calculated with the output of other languages to discover any anomalies in the handling of dates which may be due to, for example, overflow in types used to represent dates/times similar to   y2k   type problems."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2010.07\n\nAs Perl 5, except `DateTime` is built-in, so you don't need to download a module of that name:\n\n```\nsay join ' ', grep { Date.new($_, 12, 25).day-of-week == 7 }, 2008 .. 2121;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDetermine programatically and show on this page on what weekday Christmas Day, 2021 and New Year's Day, 2022 will fall or did fall."}, {"role": "assistant", "content": "```\nmy @d-o-w = < Sunday Monday Tuesday Wednesday Thursday Friday Saturday >;\n\n.say for (flat 2020..2022, (1500 .. 2500).roll(7)).sort.map: {\n     \"In {$_}, New Years is on a { @d-o-w[Date.new($_,  1,  1).day-of-week % 7] }, \" ~\n     \"and Christmas on a { @d-o-w[Date.new($_, 12, 25).day-of-week % 7] }.\"\n}\n\n```\n\nSample output:\n\n```\nIn 1578, New Years is on a Sunday, and Christmas on a Monday.\nIn 1590, New Years is on a Monday, and Christmas on a Tuesday.\nIn 1642, New Years is on a Wednesday, and Christmas on a Thursday.\nIn 1957, New Years is on a Tuesday, and Christmas on a Wednesday.\nIn 2020, New Years is on a Wednesday, and Christmas on a Friday.\nIn 2021, New Years is on a Friday, and Christmas on a Saturday.\nIn 2022, New Years is on a Saturday, and Christmas on a Sunday.\nIn 2242, New Years is on a Saturday, and Christmas on a Sunday.\nIn 2245, New Years is on a Wednesday, and Christmas on a Thursday.\nIn 2393, New Years is on a Friday, and Christmas on a Saturday.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCalculate the number of days between two dates.\n\nDate input should be of the form   **YYYY-MM-DD**.\n\nMotivation\n\nTo demonstrate one of the numerous ways this can be done."}, {"role": "assistant", "content": "(formerly Perl 6)\nDates are first class objects in Raku and may have arithmetic in days done directly on them.\n\n```\nsay Date.new('2019-09-30') - Date.new('2019-01-01');\n\nsay Date.new('2019-03-01') - Date.new('2019-02-01');\n\nsay Date.new('2020-03-01') - Date.new('2020-02-01');\n\nsay Date.new('2029-03-29') - Date.new('2019-03-29');\n\nsay Date.new('2019-01-01') + 90;\n\nsay Date.new('2020-01-01') + 90;\n\nsay Date.new('2019-02-29') + 30;\n\nCATCH { default { .message.say; exit; } };\n\n```\n\n```\n272\n28\n29\n3653\n2019-04-01\n2020-03-31\nDay out of range. Is: 29, should be in 1..28\n```"}]}
{"messages": [{"role": "user", "content": "The sequences are named after the Dutch mathematician   Nicolaas Govert de Bruijn.\n\nA note on Dutch capitalization:   Nicolaas' last name is   **de Bruijn**,   the   **de**   isn't normally capitalized\nunless it's the first word in a sentence.   Rosetta Code (more or less by default or by fiat) requires the first word in the task name to be\ncapitalized.\n\nIn combinatorial mathematics,   a   **de Bruijn sequence**   of order    *n*    on\na    size-*k*    alphabet (computer science)    *A*    is a cyclic sequence in which every\npossible    length-*n*    string (computer science, formal theory)   on    *A*    occurs\nexactly once as a contiguous substring.\n\nSuch a sequence is denoted by    *B*(*k*, *n*)    and has\nlength   *k**n*,   which is also the number of distinct substrings of\nlength   *n*   on   *A*;    \n  \nde Bruijn sequences are therefore optimally short.\n\nThere are:\n\n```\n                         (k!)k(n-1)   ÷   kn\n\n```\n\ndistinct de Bruijn sequences    *B*(*k*, *n*).\n\nTask\n\nFor this Rosetta Code task,   a   **de Bruijn**   sequence is to be generated that can be used to shorten a brute-force attack on\na   PIN-like   code lock that does not have an \"enter\"\nkey and accepts the last    *n*    digits entered.\n\nNote:   automated teller machines (ATMs)   used to work like\nthis,   but their software has been updated to not allow a brute-force attack.\n\nExample\n\nA   digital door lock   with a 4-digit code would\nhave *B* (10, 4) solutions,   with a length of   **10,000**   (digits).\n\nTherefore, only at most     **10,000 + 3**     (as the solutions are cyclic or *wrap-around*)   presses are needed to\nopen the lock.\n\nTrying all 4-digit codes separately would require   **4 × 10,000**   or   **40,000**   presses.\n\nTask requirements\n:   * Generate a de Bruijn sequence for a 4-digit (decimal) PIN code.\n\n    :   :   * Show the length of the generated de Bruijn sequence.\n            * (There are many possible de Bruijn sequences that solve this task,   one solution is shown on the *discussion* page).\n            * Show the first and last   **130**   digits of the de Bruijn sequence.\n\n    * Verify that all four-digit (decimal)   **1,000**   PIN codes are contained within the de Bruijn sequence.\n\n    :   :   * 0000, 0001, 0002, 0003,   ...   9996, 9997, 9998, 9999   (note the leading zeros).\n\n    * Reverse the de Bruijn sequence.\n    * Again, perform the (above) verification test.\n    * Replace the 4,444th digit with a period (.) in the original de Bruijn sequence.\n\n    :   :   * Perform the verification test (again).   There should be four PIN codes missing.\n\n(The last requirement is to ensure that the verification tests performs correctly.   The verification processes should list\nany and all missing PIN codes.)\n\nShow all output here, on this page.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet\n\nReferences\n:   * Wikipedia entry:   de Bruijn sequence.\n    * MathWorld entry:   de Bruijn sequence.\n    * An  OEIS  entry:   A166315 lexicographically earliest binary de Bruijn sequences, B(2,n)     --- Not B(10,4),   but possibly relevant."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nDeviates very slightly from the task spec. Generates a randomized de Bruijn sequence and replaces the 4444th digit with a the digit plus 1 mod 10 rather than a '.', mostly so it can demonstrate detection of extra PINs as well as missing ones.\n\n```\n# Generate the sequence\nmy $seq;\n\nfor ^100 {\n    my $a = .fmt: '%02d';\n    next if $a.substr(1,1) < $a.substr(0,1);\n    $seq ~= ($a.substr(0,1) == $a.substr(1,1)) ?? $a.substr(0,1) !! $a;\n    for +$a ^..^ 100 {\n        next if .fmt('%02d').substr(1,1) <= $a.substr(0,1);\n        $seq ~= sprintf \"%s%02d\", $a, $_ ;\n    }\n}\n\n$seq = $seq.comb.list.rotate((^10000).pick).join;\n\n$seq ~= $seq.substr(0,3);\n\nsub check ($seq) {\n    my %chk;\n    for ^($seq.chars) { %chk{$seq.substr( $_, 4 )}++ }\n    put 'Missing: ', (^9999).grep( { not %chk{ .fmt: '%04d' } } ).fmt: '%04d';\n    put 'Extra:   ', %chk.grep( *.value > 1 )».key.sort.fmt: '%04d';\n}\n\n## The Task\nput \"de Bruijn sequence length: \" ~ $seq.chars;\n\nput \"\\nFirst 130 characters:\\n\" ~ $seq.substr( 0, 130 );\n\nput \"\\nLast 130 characters:\\n\" ~ $seq.substr( * - 130 );\n\nput \"\\nIncorrect 4 digit PINs in this sequence:\";\ncheck $seq;\n\nput \"\\nIncorrect 4 digit PINs in the reversed sequence:\";\ncheck $seq.flip;\n\nmy $digit = $seq.substr(4443,1);\nput \"\\nReplacing the 4444th digit, ($digit) with { ($digit += 1) %= 10 }\";\nput \"Incorrect 4 digit PINs in the revised sequence:\";\n$seq.substr-rw(4443,1) = $digit;\ncheck $seq;\n\n```\n\nSample output:\n\n```\nde Bruijn sequence length: 10003\n\nFirst 130 characters:\n4558455945654566456745684569457545764577457845794585458645874588458945954596459745984599464647464846494655465646574658465946654666\n\nLast 130 characters:\n5445644574458445944654466446744684469447544764477447844794485448644874488448944954496449744984499454546454745484549455545564557455\n\nIncorrect 4 digit PINs in this sequence:\nMissing: \nExtra:   \n\nIncorrect 4 digit PINs in the reversed sequence:\nMissing: \nExtra:   \n\nReplacing the 4444th digit, (1) with 2\nIncorrect 4 digit PINs in the revised sequence:\nMissing: 0961 1096 6109 9610\nExtra:   0962 2096 6209 9620\n```"}]}
{"messages": [{"role": "user", "content": "Alphonse de Polignac, a French mathematician in the 1800s, conjectured that every positive odd integer could be formed from the sum of a power of 2 and a prime number.\n\nHe was subsequently proved incorrect.\n\nThe numbers that fail this condition are now known as de Polignac numbers.\n\nTechnically **1** is a de Polignac number, as there is no prime and power of 2 that sum to **1**. De Polignac was aware but thought that **1** was a special case. However.\n\n**127** is also fails that condition, as there is no prime and power of 2 that sum to **127**.\n\nAs it turns out, de Polignac numbers are not uncommon, in fact, there are an infinite number of them.\n\nTask\n\n* Find and display the first fifty de Polignac numbers.\n\nStretch\n\n* Find and display the one thousandth de Polignac number.\n* Find and display the ten thousandth de Polignac number.\n\nSee also\n\n* Numbers Aplenty - de Polignac numbers * OEIS:A006285 - Odd numbers not of form p + 2^k (de Polignac numbers)"}, {"role": "assistant", "content": "```\nuse List::Divvy;\nuse Lingua::EN::Numbers;\nconstant @po2 = (1..∞).map: 2 ** *;\nmy @dePolignac = lazy 1, |(2..∞).hyper.map(* × 2 + 1).grep: -> $n { all @po2.&upto($n).map: { !is-prime $n - $_ } };\n\nsay \"First fifty de Polignac numbers:\\n\" ~ @dePolignac[^50]».&comma».fmt(\"%5s\").batch(10).join: \"\\n\";\nsay \"\\nOne thousandth: \" ~ comma @dePolignac[999];\nsay \"\\nTen thousandth: \" ~ comma @dePolignac[9999];\n\n```\n\nOutput:\n\n```\nFirst fifty de Polignac numbers:\n    1   127   149   251   331   337   373   509   599   701\n  757   809   877   905   907   959   977   997 1,019 1,087\n1,199 1,207 1,211 1,243 1,259 1,271 1,477 1,529 1,541 1,549\n1,589 1,597 1,619 1,649 1,657 1,719 1,759 1,777 1,783 1,807\n1,829 1,859 1,867 1,927 1,969 1,973 1,985 2,171 2,203 2,213\n\nOne thousandth: 31,941\n\nTen thousandth: 273,421\n```"}]}
{"messages": [{"role": "user", "content": "*Free Cell* is the solitaire card game that Paul Alfille introduced to the PLATO system in 1978. Jim Horne, at Microsoft, changed the name to *FreeCell* and reimplemented the game for DOS, then Windows.   \nThis version introduced 32000 numbered deals. (The FreeCell FAQ tells this history.)\n\nAs the game became popular, Jim Horne disclosed the algorithm, and other implementations of FreeCell began to reproduce the Microsoft deals.   \nThese deals are numbered from 1 to 32000.\nNewer versions from Microsoft have 1 million deals, numbered from 1 to 1000000; some implementations allow numbers outside that range.\n\nThe algorithm uses this linear congruential generator from Microsoft C:\n\n* s\n  t\n  a\n  t\n\n  e\n\n  n\n  +\n  1\n  ≡\n  214013\n  ×\n  s\n  t\n  a\n  t\n\n  e\n\n  n\n  +\n  2531011\n\n\n  (\n  mod\n\n\n  2\n\n  31\n  )\n  {\\displaystyle {\\displaystyle state\\_{n+1}\\equiv 214013\\times state\\_{n}+2531011{\\pmod {2^{31}}}}}\n* r\n  a\n  n\n\n  d\n\n  n\n  =\n  s\n  t\n  a\n  t\n\n  e\n\n  n\n  ÷\n\n  2\n\n  16\n  {\\displaystyle {\\displaystyle rand\\_{n}=state\\_{n}\\div 2^{16}}}\n* r\n  a\n  n\n\n  d\n\n  n\n  {\\displaystyle {\\displaystyle rand\\_{n}}}\n   is in range 0 to 32767.\n* Rosetta Code has another task, linear congruential generator, with code for this RNG in several languages.\n\nThe algorithm follows:\n\n1. Seed the RNG with the number of the deal.\n2. Create an array of 52 cards: Ace of Clubs, Ace of Diamonds, Ace of Hearts, Ace of Spades, 2 of Clubs, 2 of Diamonds, and so on through the ranks: Ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King. The array indexes are 0 to 51, with Ace of Clubs at 0, and King of Spades at 51.\n3. Until the array is empty:\n   * Choose a random card at *index* ≡ *next random number* (mod *array length*).\n   * Swap this random card with the last card of the array.\n   * Remove this random card from the array. (Array length goes down by 1.)\n   * Deal this random card.\n4. Deal all 52 cards, face up, across 8 columns. The first 8 cards go in 8 columns, the next 8 cards go on the first 8 cards, and so on.\n\n:   :   :   :   | Order to deal cards | Game #1 | Game #617 |\n                | --- | --- | --- |\n                | ```  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 ``` | ``` JD 2D 9H JC 5D 7H 7C 5H KD KC 9S 5S AD QC KH 3H 2S KS 9D QD JS AS AH 3C 4C 5C TS QH 4H AC 4D 7S 3S TD 4S TH 8H 2C JH 7D 6D 8S 8D QS 6C 3D 8C TC 6S 9C 2H 6H ``` | ``` 7D AD 5C 3S 5S 8C 2D AH TD 7S QD AC 6D 8H AS KH TH QC 3H 9D 6S 8D 3D TC KD 5H 9S 3C 8S 7H 4D JS 4C QS 9C 9H 7C 6H 2C 2S 4S TS 2H 5D JC 6C JH QH JD KS KC 4H ``` |\n\nDeals can also be checked against FreeCell solutions to 1000000 games.\n(Summon a video solution, and it displays the initial deal.)\n\nWrite a program to take a deal number and deal cards in the same order as this algorithm.\nThe program may display the cards with ASCII, with Unicode, by drawing graphics, or any other way.\n\nRelated tasks:\n\n* Playing cards\n* Card shuffles\n* War Card\\_Game\n* Poker hand\\_analyser\n* Go Fish"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.05\n\n```\nsub dealgame ($game-number = 1) {\n    sub ms-lcg-method($seed = $game-number) { ( 214013 * $seed + 2531011 ) % 2**31 }\n\n    # lazy list of the random sequence\n    my @ms-lcg = |(&ms-lcg-method ... *).map: * +> 16;\n\n    constant CardBlock = '🂠'.ord;\n    my @deck = gather for flat(1..11,13,14) X+ (48,32...0) -> $off {\n        take chr CardBlock + $off;\n    }\n\n    my @game = gather while @deck {\n        @deck[@ms-lcg.shift % @deck, @deck-1] .= reverse;\n        take @deck.pop;\n    }\n\n    say \"Game #$game-number\";\n    say @game.splice(0, 8 min +@game) while @game;\n}\n\ndealgame;\ndealgame 617;\n\n```\n\nOutput:\n\n```\nGame #1\n🃋 🃂 🂹 🃛 🃅 🂷 🃗 🂵\n🃎 🃞 🂩 🂥 🃁 🃝 🂾 🂳\n🂢 🂮 🃉 🃍 🂫 🂡 🂱 🃓\n🃔 🃕 🂪 🂽 🂴 🃑 🃄 🂧\n🂣 🃊 🂤 🂺 🂸 🃒 🂻 🃇\n🃆 🂨 🃈 🂭 🃖 🃃 🃘 🃚\n🂦 🃙 🂲 🂶\nGame #617\n🃇 🃁 🃕 🂣 🂥 🃘 🃂 🂱\n🃊 🂧 🃍 🃑 🃆 🂸 🂡 🂾\n🂺 🃝 🂳 🃉 🂦 🃈 🃃 🃚\n🃎 🂵 🂩 🃓 🂨 🂷 🃄 🂫\n🃔 🂭 🃙 🂹 🃗 🂶 🃒 🂢\n🂤 🂪 🂲 🃅 🃛 🃖 🂻 🂽\n🃋 🂮 🃞 🂴\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay a region that consists of a large sphere with part of a smaller sphere removed from it as a result of geometric subtraction.\n\n(This will basically produce a shape like a \"death star\".)\n\nRelated tasks\n\n* draw a sphere\n* draw a cuboid\n* draw a rotating cube\n* write language name in 3D ASCII"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: C\n\nReimplemented to output a .pgm image.\n\n**Works with**: Rakudo version 2018.10\n\n```\nclass sphere {\n   has $.cx; # center x coordinate\n   has $.cy; # center y coordinate\n   has $.cz; # center z coordinate\n   has $.r;  # radius\n}\n\nmy $depth = 255;     # image color depth\n\nmy $width = my $height = 255; # dimensions of generated .pgm; must be odd\n\nmy $s = ($width - 1)/2;  # scaled dimension to build geometry\n\nmy @light = normalize([ 4, -1, -3 ]);\n\n# positive sphere at origin\nmy $pos = sphere.new(\n    cx => 0,\n    cy => 0,\n    cz => 0,\n    r  => $s.Int\n);\n\n# negative sphere offset to upper left\nmy $neg = sphere.new(\n    cx => (-$s*.90).Int,\n    cy => (-$s*.90).Int,\n    cz => (-$s*.3).Int,\n    r  => ($s*.7).Int\n);\n\nsub MAIN ($outfile = 'deathstar-perl6.pgm') {\n    spurt $outfile, (\"P5\\n$width $height\\n$depth\\n\"); # .pgm header\n    my $out = open( $outfile, :a, :bin ) orelse .die;\n    say 'Working...';\n    $out.write( Blob.new( |draw_ds(3, .15) ) );\n    say 'File written.';\n    $out.close;\n}\n\nsub draw_ds ( $k, $ambient ) {\n    my @pixels[$height];\n\n    (($pos.cy - $pos.r) .. ($pos.cy + $pos.r)).race.map: -> $y {\n        my @row[$width];\n        (($pos.cx - $pos.r) .. ($pos.cx + $pos.r)).map: -> $x {\n            # black if we don't hit positive sphere, ignore negative sphere\n            if not hit($pos, $x, $y, my $posz) {\n                @row[$x + $s] = 0;\n                next;\n            }\n            my @vec;\n            # is front of positive sphere inside negative sphere?\n            if hit($neg, $x, $y, my $negz) and $negz.min < $posz.min < $negz.max {\n                # make black if whole positive sphere eaten here\n                if $negz.min < $posz.max < $negz.max { @row[$x + $s] = 0; next; }\n                # render inside of negative sphere\n                @vec = normalize([$neg.cx - $x, $neg.cy - $y, -$negz.max - $neg.cz]);\n            }\n            else {\n                # render outside of positive sphere\n                @vec = normalize([$x - $pos.cx, $y - $pos.cy,  $posz.max - $pos.cz]);\n            }\n            my $intensity = dot(@light, @vec) ** $k + $ambient;\n            @row[$x + $s] = ($intensity * $depth).Int min $depth;\n        }\n         @pixels[$y + $s] = @row;\n    }\n    flat |@pixels.map: *.list;\n}\n\n# normalize a vector\nsub normalize (@vec) { @vec »/» ([+] @vec »*« @vec).sqrt }\n\n# dot product of two vectors\nsub dot (@x, @y) { -([+] @x »*« @y) max 0 }\n\n# are the coordinates within the radius of the sphere?\nsub hit ($sphere, $x is copy, $y is copy, $z is rw) {\n    $x -= $sphere.cx;\n    $y -= $sphere.cy;\n    my $z2 = $sphere.r * $sphere.r - $x * $x - $y * $y;\n    return False if $z2 < 0;\n    $z2 = $z2.sqrt;\n    $z = $sphere.cz - $z2 .. $sphere.cz + $z2;\n    True;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Repunits are numbers that consist entirely of repetitions of the digit one (unity). The notation **Rn** symbolizes the repunit made up of **n** ones.\n\nEvery prime **p** larger than 5, evenly divides the repunit **Rp-1**.\n\nE.G.\n\nThe repunit **R6** is evenly divisible by **7**.\n\n111111 / 7 = 15873\n\nThe repunit **R42** is evenly divisible by **43**.\n\n111111111111111111111111111111111111111111 / 43 = 2583979328165374677002583979328165374677\n\nAnd so on.\n\nThere are composite numbers that also have this same property. They are often referred to as *deceptive non-primes* or *deceptive numbers*.\n\nThe repunit **R90** is evenly divisible by the composite number **91** (=7\\*13).\n\n111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 / 91 = 1221001221001221001221001221001221001221001221001221001221001221001221001221001221001221\n\nTask\n\n* Find and show at least the first **10 deceptive numbers**; composite numbers **n** that evenly divide the repunit **Rn-1**\n\nSee also\n\n* Numbers Aplenty - Deceptive numbers * OEIS:A000864 - Deceptive nonprimes: composite numbers k that divide the repunit R\\_{k-1}"}, {"role": "assistant", "content": "```\nmy \\R = [\\+] 1, 10, 100 … *;\nput (2..∞).grep( {$_ % 2 && $_ % 3 && $_ % 5 && !.is-prime} ).grep( { R[$_-2] %% $_ } )[^25];\n\n```\n\nOutput:\n\n```\n91 259 451 481 703 1729 2821 2981 3367 4141 4187 5461 6533 6541 6601 7471 7777 8149 8401 8911 10001 11111 12403 13981 14701\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a program that takes a decimal floating point number and displays its binary representation and vice versa: takes a floating point binary number and outputs its decimal representation.\n\nThe output might be something like this:\n\n```\n       23.34375  => 10111.01011\n     1011.11101  =>    11.90625\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\ngiven \"23.34375\"   { say \"$_ => \", :10($_).base(2) }\ngiven \"1011.11101\" { say \"$_ => \", :2($_).base(10) }\n\n```\n\nOutput:\n\n```\n23.34375 => 10111.01011\n1011.11101 => 11.90625\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Decision Table. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nDecision Tables are a precise yet compact way to model complicated logic.\n\nTask\n\nDemonstrate how your language implements decision tables.\n\nUse this example of Printer Troubleshooting given in the Wikipedia article."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub decide (@q, @s) {\n    my $bit = 2 ** [+] (1,2,4...*) Z* reverse @q.map: {\n\tso prompt(.value ~ \"? \") ~~ /:i ^y/;\n    }\n    say \"  $_\" for @s.grep(*.key +& $bit)».value || \"No clue!\";\n}\n\nloop {\n    decide\n    (\n\t  \"Y Y Y Y N N N N\" => \"Printer does not print\",              \n\t  \"Y Y N N Y Y N N\" => \"A red light is flashing\",             \n\t  \"Y N Y N Y N Y N\" => \"Printer is unrecognised\",             \n    ), \n    (\n\t:2<0_0_1_0_0_0_0_0> => \"Check the power cable\",                \n\t:2<1_0_1_0_0_0_0_0> => \"Check the printer-computer cable\",     \n\t:2<1_0_1_0_1_0_1_0> => \"Ensure printer software is installed\", \n\t:2<1_1_0_0_1_1_0_0> => \"Check/replace ink\",                    \n\t:2<0_1_0_1_0_0_0_0> => \"Check for paper jam\",                  \n    );\n    say '';\n}\n\n```\n\nA bit of explanation: we pass in two pair lists for the questions and solutions; we ignore the keys of the questions, since they can be\ngenerated by regarding them as a binary counter from right to left, with the least significant bit on the bottom. The @q.map runs the prompts and maps them to booleans\nusing case-insensitive matching. We reverse that list and zip multiply with powers of two to figure out which bit we're going to grep for. (The zip stops on the shorter list, which is always going to be the list of booleans, since the list of powers of two is infinite.) We sum up those powers of two using a [+] reduction metaoperator, which in this case gives us a number from 0 to 7. Then we take 2 to that power.\n\nThe solutions list of pairs is conveniently keyed on binary numbers written in colon radix notation, so we grep the keys containing the correct bit, then map the pair list to its values using a hyperoperator to parallelize it. Unlike in Perl 5, we can use || on lists as well as scalars to provide a default result if nothing matches.\n\nOutput:\n\n```\nPrinter does not print? n\nA red light is flashing? y\nPrinter is unrecognised? n\n  Check/replace ink\n\nPrinter does not print? y\nA red light is flashing? n\nPrinter is unrecognised? y\n  Check the power cable\n  Check the printer-computer cable\n  Ensure printer software is installed\n\nPrinter does not print? n\nA red light is flashing? n\nPrinter is unrecognised? n\n  No clue!\n\nPrinter does not print? ^C\n```"}]}
{"messages": [{"role": "user", "content": "The convolution of two functions \n\nF\n{\\displaystyle {\\displaystyle {\\mathit {F}}}}\n and \n\nH\n{\\displaystyle {\\displaystyle {\\mathit {H}}}}\n of\nan integer variable is defined as the function \n\nG\n{\\displaystyle {\\displaystyle {\\mathit {G}}}}\nsatisfying\n\n:   G\n    (\n    n\n    )\n    =\n\n    ∑\n\n    m\n    =\n    −\n    ∞\n\n    ∞\n    F\n    (\n    m\n    )\n    H\n    (\n    n\n    −\n    m\n    )\n    {\\displaystyle {\\displaystyle G(n)=\\sum \\_{m=-\\infty }^{\\infty }F(m)H(n-m)}}\n\nfor all integers \n\nn\n{\\displaystyle {\\displaystyle {\\mathit {n}}}}\n. Assume \n\nF\n(\nn\n)\n{\\displaystyle {\\displaystyle F(n)}}\n can be non-zero only for \n\n0\n{\\displaystyle {\\displaystyle 0}}\n ≤ \n\nn\n{\\displaystyle {\\displaystyle {\\mathit {n}}}}\n ≤ \n\n|\n\n\nF\n\n|\n{\\displaystyle {\\displaystyle |{\\mathit {F}}|}}\n, where \n\n|\n\n\nF\n\n|\n{\\displaystyle {\\displaystyle |{\\mathit {F}}|}}\n is the \"length\" of \n\nF\n{\\displaystyle {\\displaystyle {\\mathit {F}}}}\n, and similarly for \n\nG\n{\\displaystyle {\\displaystyle {\\mathit {G}}}}\n and \n\nH\n{\\displaystyle {\\displaystyle {\\mathit {H}}}}\n, so that the functions can be modeled as finite sequences by identifying \n\nf\n\n0\n,\n\nf\n\n1\n,\n\nf\n\n2\n,\n…\n{\\displaystyle {\\displaystyle f\\_{0},f\\_{1},f\\_{2},\\dots }}\n with \n\nF\n(\n0\n)\n,\nF\n(\n1\n)\n,\nF\n(\n2\n)\n,\n…\n{\\displaystyle {\\displaystyle F(0),F(1),F(2),\\dots }}\n, etc.\nThen for example, values of \n\n|\n\n\nF\n\n|\n=\n6\n{\\displaystyle {\\displaystyle |{\\mathit {F}}|=6}}\n and \n\n|\n\n\nH\n\n|\n=\n5\n{\\displaystyle {\\displaystyle |{\\mathit {H}}|=5}}\n would determine the following value of \n\ng\n{\\displaystyle {\\displaystyle {\\mathit {g}}}}\n by definition.\n\n:   g\n\n    0\n\n    =\n\n\n    f\n\n    0\n\n    h\n\n    0\n\n    g\n\n    1\n\n    =\n\n\n    f\n\n    1\n\n    h\n\n    0\n\n    +\n\n\n    f\n\n    0\n\n    h\n\n    1\n\n    g\n\n    2\n\n    =\n\n\n    f\n\n    2\n\n    h\n\n    0\n\n    +\n\n\n    f\n\n    1\n\n    h\n\n    1\n\n    +\n\n\n    f\n\n    0\n\n    h\n\n    2\n\n    g\n\n    3\n\n    =\n\n\n    f\n\n    3\n\n    h\n\n    0\n\n    +\n\n\n    f\n\n    2\n\n    h\n\n    1\n\n    +\n\n\n    f\n\n    1\n\n    h\n\n    2\n\n    +\n\n\n    f\n\n    0\n\n    h\n\n    3\n\n    g\n\n    4\n\n    =\n\n\n    f\n\n    4\n\n    h\n\n    0\n\n    +\n\n\n    f\n\n    3\n\n    h\n\n    1\n\n    +\n\n\n    f\n\n    2\n\n    h\n\n    2\n\n    +\n\n\n    f\n\n    1\n\n    h\n\n    3\n\n    +\n\n\n    f\n\n    0\n\n    h\n\n    4\n\n    g\n\n    5\n\n    =\n\n\n    f\n\n    5\n\n    h\n\n    0\n\n    +\n\n\n    f\n\n    4\n\n    h\n\n    1\n\n    +\n\n\n    f\n\n    3\n\n    h\n\n    2\n\n    +\n\n\n    f\n\n    2\n\n    h\n\n    3\n\n    +\n\n\n    f\n\n    1\n\n    h\n\n    4\n\n    g\n\n    6\n\n    =\n\n    f\n\n    5\n\n    h\n\n    1\n\n    +\n\n\n    f\n\n    4\n\n    h\n\n    2\n\n    +\n\n\n    f\n\n    3\n\n    h\n\n    3\n\n    +\n\n\n    f\n\n    2\n\n    h\n\n    4\n\n    g\n\n    7\n\n    =\n\n    f\n\n    5\n\n    h\n\n    2\n\n    +\n\n\n    f\n\n    4\n\n    h\n\n    3\n\n    +\n\n\n    f\n\n    3\n\n    h\n\n    4\n\n    g\n\n    8\n\n    =\n\n    f\n\n    5\n\n    h\n\n    3\n\n    +\n\n\n    f\n\n    4\n\n    h\n\n    4\n\n    g\n\n    9\n\n    =\n\n    f\n\n    5\n\n    h\n\n    4\n    {\\displaystyle {\\displaystyle {\\begin{array}{lllllllllll}g\\_{0}&=&f\\_{0}h\\_{0}\\\\g\\_{1}&=&f\\_{1}h\\_{0}&+&f\\_{0}h\\_{1}\\\\g\\_{2}&=&f\\_{2}h\\_{0}&+&f\\_{1}h\\_{1}&+&f\\_{0}h\\_{2}\\\\g\\_{3}&=&f\\_{3}h\\_{0}&+&f\\_{2}h\\_{1}&+&f\\_{1}h\\_{2}&+&f\\_{0}h\\_{3}\\\\g\\_{4}&=&f\\_{4}h\\_{0}&+&f\\_{3}h\\_{1}&+&f\\_{2}h\\_{2}&+&f\\_{1}h\\_{3}&+&f\\_{0}h\\_{4}\\\\g\\_{5}&=&f\\_{5}h\\_{0}&+&f\\_{4}h\\_{1}&+&f\\_{3}h\\_{2}&+&f\\_{2}h\\_{3}&+&f\\_{1}h\\_{4}\\\\g\\_{6}&=&&&f\\_{5}h\\_{1}&+&f\\_{4}h\\_{2}&+&f\\_{3}h\\_{3}&+&f\\_{2}h\\_{4}\\\\g\\_{7}&=&&&&&f\\_{5}h\\_{2}&+&f\\_{4}h\\_{3}&+&f\\_{3}h\\_{4}\\\\g\\_{8}&=&&&&&&&f\\_{5}h\\_{3}&+&f\\_{4}h\\_{4}\\\\g\\_{9}&=&&&&&&&&&f\\_{5}h\\_{4}\\end{array}}}}\n\nWe can write this in matrix form as:\n\n:   (\n\n    g\n\n    0\n\n    g\n\n    1\n\n    g\n\n    2\n\n    g\n\n    3\n\n    g\n\n    4\n\n    g\n\n    5\n\n    g\n\n    6\n\n    g\n\n    7\n\n    g\n\n    8\n\n    g\n\n    9\n    )\n    =\n\n    (\n\n    f\n\n    0\n\n    f\n\n    1\n\n\n    f\n\n    0\n\n    f\n\n    2\n\n\n    f\n\n    1\n\n\n    f\n\n    0\n\n    f\n\n    3\n\n\n    f\n\n    2\n\n\n    f\n\n    1\n\n\n    f\n\n    0\n\n    f\n\n    4\n\n\n    f\n\n    3\n\n\n    f\n\n    2\n\n\n    f\n\n    1\n\n\n    f\n\n    0\n\n    f\n\n    5\n\n\n    f\n\n    4\n\n\n    f\n\n    3\n\n\n    f\n\n    2\n\n\n    f\n\n    1\n\n    f\n\n    5\n\n\n    f\n\n    4\n\n\n    f\n\n    3\n\n\n    f\n\n    2\n\n    f\n\n    5\n\n\n    f\n\n    4\n\n\n    f\n\n    3\n\n    f\n\n    5\n\n\n    f\n\n    4\n\n    f\n\n    5\n    )\n\n\n    (\n\n    h\n\n    0\n\n    h\n\n    1\n\n    h\n\n    2\n\n    h\n\n    3\n\n    h\n\n    4\n    )\n    {\\displaystyle {\\displaystyle \\left({\\begin{array}{l}g\\_{0}\\\\g\\_{1}\\\\g\\_{2}\\\\g\\_{3}\\\\g\\_{4}\\\\g\\_{5}\\\\g\\_{6}\\\\g\\_{7}\\\\g\\_{8}\\\\g\\_{9}\\\\\\end{array}}\\right)=\\left({\\begin{array}{lllll}f\\_{0}\\\\f\\_{1}&f\\_{0}\\\\f\\_{2}&f\\_{1}&f\\_{0}\\\\f\\_{3}&f\\_{2}&f\\_{1}&f\\_{0}\\\\f\\_{4}&f\\_{3}&f\\_{2}&f\\_{1}&f\\_{0}\\\\f\\_{5}&f\\_{4}&f\\_{3}&f\\_{2}&f\\_{1}\\\\&f\\_{5}&f\\_{4}&f\\_{3}&f\\_{2}\\\\&&f\\_{5}&f\\_{4}&f\\_{3}\\\\&&&f\\_{5}&f\\_{4}\\\\&&&&f\\_{5}\\end{array}}\\right)\\;\\left({\\begin{array}{l}h\\_{0}\\\\h\\_{1}\\\\h\\_{2}\\\\h\\_{3}\\\\h\\_{4}\\\\\\end{array}}\\right)}}\n\nor\n\n:   g\n    =\n    A\n\n    h\n    {\\displaystyle {\\displaystyle g=A\\;h}}\n\nFor this task, implement a function (or method, procedure, subroutine, etc.) `deconv` to perform *deconvolution* (i.e., the *inverse* of convolution) by constructing and solving such a system of equations represented by the above matrix \n\nA\n{\\displaystyle {\\displaystyle A}}\n for \n\nh\n{\\displaystyle {\\displaystyle {\\mathit {h}}}}\n given \n\nf\n{\\displaystyle {\\displaystyle {\\mathit {f}}}}\n and \n\ng\n{\\displaystyle {\\displaystyle {\\mathit {g}}}}\n.\n\n* The function should work for \n\n  G\n  {\\displaystyle {\\displaystyle {\\mathit {G}}}}\n   of arbitrary length (i.e., not hard coded or constant) and \n\n  F\n  {\\displaystyle {\\displaystyle {\\mathit {F}}}}\n   of any length up to that of \n\n  G\n  {\\displaystyle {\\displaystyle {\\mathit {G}}}}\n  . Note that \n\n  |\n\n\n  H\n\n  |\n  {\\displaystyle {\\displaystyle |{\\mathit {H}}|}}\n   will be given by \n\n  |\n\n\n  G\n\n  |\n  −\n\n  |\n\n\n  F\n\n  |\n  +\n  1\n  {\\displaystyle {\\displaystyle |{\\mathit {G}}|-|{\\mathit {F}}|+1}}\n  .\n* There may be more equations than unknowns. If convenient, use a function from a library that finds the best fitting solution to an overdetermined system of linear equations (as in the Multiple regression task). Otherwise, prune the set of equations as needed and solve as in the Reduced row echelon form task.\n* Test your solution on the following data. Be sure to verify both that `deconv`\n\n  (\n  g\n  ,\n  f\n  )\n  =\n  h\n  {\\displaystyle {\\displaystyle (g,f)=h}}\n   and `deconv`\n\n  (\n  g\n  ,\n  h\n  )\n  =\n  f\n  {\\displaystyle {\\displaystyle (g,h)=f}}\n   and display the results in a human readable form.\n\n`h = [-8,-9,-3,-1,-6,7]  \nf = [-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1]  \ng = [24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7]`"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nTranslation of Python, using a modified version of the subroutine `rref` from Reduced row echelon form task.\n\n```\nsub deconvolve (@g, @f) {\n    my \\h = 1 + @g - @f;\n    my @m;\n    @m[^@g;^h] »+=» 0;\n    @m[^@g; h] »=«  @g;\n    for ^h -> \\j { for @f.kv -> \\k, \\v { @m[j+k;j] = v } }\n    (rref @m)[^h;h]\n}\n\nsub convolve (@f, @h) {\n    my @g = 0 xx + @f + @h - 1;\n    @g[^@f X+ ^@h] »+=« (@f X× @h);\n    @g\n}\n \n# Reduced Row Echelon Form simultaneous equation solver\n# Can handle over-specified systems of equations (N unknowns in N + M equations)\nsub rref (@m) {\n    @m = trim-system @m;\n    my ($lead, $rows, $cols) = 0, @m, @m[0];\n    for ^$rows -> $r {\n        return @m unless $lead < $cols;\n        my $i = $r;\n        until @m[$i;$lead] {\n            next unless ++$i == $rows;\n            $i = $r;\n            return @m if ++$lead == $cols;\n        }\n        @m[$i, $r] = @m[$r, $i] if $r != $i;\n        @m[$r] »/=» $ = @m[$r;$lead];\n        for ^$rows -> $n {\n            next if $n == $r;\n            @m[$n] »-=» @m[$r] »×» (@m[$n;$lead] // 0);\n        }\n        ++$lead;\n    }\n    @m\n }\n\n# Reduce to N equations in N unknowns; a no-op unless rows > cols\nsub trim-system (@m) {\n    return @m unless @m ≥ @m[0]; \n    my (\\vars, @t) = @m[0] - 1;\n    for ^vars -> \\lead {\n        for ^@m -> \\row {\n            @t.append: @m.splice(row, 1) and last if @m[row;lead];\n        }\n    }\n    while @t < vars and @m { @t.push: shift @m }\n    @t\n}\n  \nmy @h = (-8,-9,-3,-1,-6,7);\nmy @f = (-3,-6,-1,8,-6,3,-1,-9,-9,3,-2,5,2,-2,-7,-1);\nmy @g = (24,75,71,-34,3,22,-45,23,245,25,52,25,-67,-96,96,31,55,36,29,-43,-7);\n \n.say for ~@g,   ~convolve(@f, @h),'';\n.say for ~@h, ~deconvolve(@g, @f),'';\n.say for ~@f, ~deconvolve(@g, @h),'';\n\n```\n\nOutput:\n\n```\n24 75 71 -34 3 22 -45 23 245 25 52 25 -67 -96 96 31 55 36 29 -43 -7\n24 75 71 -34 3 22 -45 23 245 25 52 25 -67 -96 96 31 55 36 29 -43 -7\n\n-8 -9 -3 -1 -6 7\n-8 -9 -3 -1 -6 7\n\n-3 -6 -1 8 -6 3 -1 -9 -9 3 -2 5 2 -2 -7 -1\n-3 -6 -1 8 -6 3 -1 -9 -9 3 -2 5 2 -2 -7 -1\n```"}]}
{"messages": [{"role": "user", "content": "This task is a straightforward generalization of Deconvolution/1D to higher dimensions. For example, the one dimensional case would be applicable to audio signals, whereas two dimensions would pertain to images. Define the discrete convolution in \n\nd\n{\\displaystyle {\\displaystyle {\\mathit {d}}}}\n dimensions of two functions\n\n:   H\n    ,\n    F\n    :\n\n\n    Z\n\n    d\n    →\n\n    R\n    {\\displaystyle {\\displaystyle H,F:\\mathbb {Z} ^{d}\\rightarrow \\mathbb {R} }}\n\ntaking \n\nd\n{\\displaystyle {\\displaystyle {\\mathit {d}}}}\n-tuples of integers to real numbers as the function\n\n:   G\n    :\n\n\n    Z\n\n    d\n    →\n\n    R\n    {\\displaystyle {\\displaystyle G:\\mathbb {Z} ^{d}\\rightarrow \\mathbb {R} }}\n\nalso taking \n\nd\n{\\displaystyle {\\displaystyle {\\mathit {d}}}}\n-tuples of integers to reals and satisfying\n\n:   G\n    (\n\n    n\n\n    0\n    ,\n    …\n    ,\n\n    n\n\n    d\n    −\n    1\n    )\n    =\n\n    ∑\n\n\n    m\n\n    0\n    =\n    −\n    ∞\n\n    ∞\n    …\n\n    ∑\n\n\n    m\n\n    d\n    −\n    1\n    =\n    −\n    ∞\n\n    ∞\n    F\n    (\n\n    m\n\n    0\n    ,\n    …\n    ,\n\n    m\n\n    d\n    −\n    1\n    )\n    H\n    (\n\n    n\n\n    0\n    −\n\n    m\n\n    0\n    ,\n    …\n    ,\n\n    n\n\n    d\n    −\n    1\n    −\n\n    m\n\n    d\n    −\n    1\n    )\n    {\\displaystyle {\\displaystyle G(n\\_{0},\\dots ,n\\_{d-1})=\\sum \\_{m\\_{0}=-\\infty }^{\\infty }\\dots \\sum \\_{m\\_{d-1}=-\\infty }^{\\infty }F(m\\_{0},\\dots ,m\\_{d-1})H(n\\_{0}-m\\_{0},\\dots ,n\\_{d-1}-m\\_{d-1})}}\n\nfor all \n\nd\n{\\displaystyle {\\displaystyle {\\mathit {d}}}}\n-tuples of integers \n\n(\n\nn\n\n0\n,\n…\n,\n\nn\n\nd\n−\n1\n)\n∈\n\n\nZ\n\nd\n{\\displaystyle {\\displaystyle (n\\_{0},\\dots ,n\\_{d-1})\\in \\mathbb {Z} ^{d}}}\n. Assume\n\nF\n{\\displaystyle {\\displaystyle {\\mathit {F}}}}\n and \n\nH\n{\\displaystyle {\\displaystyle {\\mathit {H}}}}\n (and therefore \n\nG\n{\\displaystyle {\\displaystyle {\\mathit {G}}}}\n) are non-zero over only a finite domain bounded by the origin, hence possible to represent as finite multi-dimensional arrays or nested lists \n\nf\n{\\displaystyle {\\displaystyle {\\mathit {f}}}}\n, \n\nh\n{\\displaystyle {\\displaystyle {\\mathit {h}}}}\n, and \n\ng\n{\\displaystyle {\\displaystyle {\\mathit {g}}}}\n.\n\nFor this task, implement a function (or method, procedure, subroutine, etc.) `deconv` to perform *deconvolution* (i.e., the *inverse* of convolution) by solving for \n\nh\n{\\displaystyle {\\displaystyle {\\mathit {h}}}}\n given \n\nf\n{\\displaystyle {\\displaystyle {\\mathit {f}}}}\n and \n\ng\n{\\displaystyle {\\displaystyle {\\mathit {g}}}}\n. (See Deconvolution/1D for details.)\n\n* The function should work for \n\n  g\n  {\\displaystyle {\\displaystyle {\\mathit {g}}}}\n   of arbitrary length in each dimension (i.e., not hard coded or constant) and \n\n  f\n  {\\displaystyle {\\displaystyle {\\mathit {f}}}}\n   of any length up to that of \n\n  g\n  {\\displaystyle {\\displaystyle {\\mathit {g}}}}\n   in the corresponding dimension.\n* The `deconv` function will need to be parameterized by the dimension \n\n  d\n  {\\displaystyle {\\displaystyle {\\mathit {d}}}}\n   unless the dimension can be inferred from the data structures representing \n\n  g\n  {\\displaystyle {\\displaystyle {\\mathit {g}}}}\n   and \n\n  f\n  {\\displaystyle {\\displaystyle {\\mathit {f}}}}\n  .\n* There may be more equations than unknowns. If convenient, use a function from a library that finds the best fitting solution to an overdetermined system of linear equations (as in the Multiple regression task). Otherwise, prune the set of equations as needed and solve as in the Reduced row echelon form task.\n* Debug your solution using this test data, of which a portion is shown below. Be sure to verify both that the deconvolution of \n\n  g\n  {\\displaystyle {\\displaystyle {\\mathit {g}}}}\n   with \n\n  f\n  {\\displaystyle {\\displaystyle {\\mathit {f}}}}\n   is \n\n  h\n  {\\displaystyle {\\displaystyle {\\mathit {h}}}}\n   and that the deconvolution of \n\n  g\n  {\\displaystyle {\\displaystyle {\\mathit {g}}}}\n   with \n\n  h\n  {\\displaystyle {\\displaystyle {\\mathit {h}}}}\n   is \n\n  f\n  {\\displaystyle {\\displaystyle {\\mathit {f}}}}\n  . Display the results in a human readable form for the three dimensional case *only*.\n\ndimension 1:\n\n```\nh: [-8, 2, -9, -2, 9, -8, -2]\nf: [ 6, -9, -7, -5]\ng: [-48, 84, -16, 95, 125, -70, 7, 29, 54, 10]\n\n```\n\ndimension 2:\n\n```\nh: [\n      [-8, 1, -7, -2, -9, 4], \n      [4, 5, -5, 2, 7, -1], \n      [-6, -3, -3, -6, 9, 5]]\nf: [\n      [-5, 2, -2, -6, -7], \n      [9, 7, -6, 5, -7], \n      [1, -1, 9, 2, -7], \n      [5, 9, -9, 2, -5], \n      [-8, 5, -2, 8, 5]]\ng: [\n      [40, -21, 53, 42, 105, 1, 87, 60, 39, -28], \n      [-92, -64, 19, -167, -71, -47, 128, -109, 40, -21], \n      [58, 85, -93, 37, 101, -14, 5, 37, -76, -56], \n      [-90, -135, 60, -125, 68, 53, 223, 4, -36, -48], \n      [78, 16, 7, -199, 156, -162, 29, 28, -103, -10], \n      [-62, -89, 69, -61, 66, 193, -61, 71, -8, -30], \n      [48, -6, 21, -9, -150, -22, -56, 32, 85, 25]]\n\n```\n\ndimension 3:\n\n```\nh: [\n      [[-6, -8, -5, 9], [-7, 9, -6, -8], [2, -7, 9, 8]], \n      [[7, 4, 4, -6], [9, 9, 4, -4], [-3, 7, -2, -3]]]\nf: [\n      [[-9, 5, -8], [3, 5, 1]], \n      [[-1, -7, 2], [-5, -6, 6]], \n      [[8, 5, 8],[-2, -6, -4]]]\ng: [\n      [\n         [54, 42, 53, -42, 85, -72], \n         [45, -170, 94, -36, 48, 73], \n         [-39, 65, -112, -16, -78, -72], \n         [6, -11, -6, 62, 49, 8]], \n      [\n         [-57, 49, -23, 52, -135, 66], \n         [-23, 127, -58, -5, -118, 64], \n         [87, -16, 121, 23, -41, -12], \n         [-19, 29, 35, -148, -11, 45]], \n      [\n         [-55, -147, -146, -31, 55, 60], \n         [-88, -45, -28, 46, -26, -144], \n         [-12, -107, -34, 150, 249, 66], \n         [11, -15, -34, 27, -78, -50]], \n      [\n         [56, 67, 108, 4, 2, -48], \n         [58, 67, 89, 32, 32, -8], \n         [-42, -31, -103, -30, -23, -8],\n         [6, 4, -26, -10, 26, 12]]]\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nTranslation of Tcl.\n\n```\n# Deconvolution of N dimensional matrices.\nsub deconvolve-N ( @g, @f ) {\n    my @hsize = @g.shape »-« @f.shape »+» 1;\n\n    my @toSolve = coords(@g.shape).map:\n      { [row(@g, @f, $^coords, @hsize)] };\n\n    my @solved = rref( @toSolve );\n\n    my @h;\n    for flat coords(@hsize) Z @solved[*;*-1] -> $_, $v {\n        @h.AT-POS(|$_) = $v;\n    }\n    @h\n}\n\n# Construct a row for each value in @g to be sent to the simultaneous equation solver\nsub row ( @g, @f, @gcoord, $hsize ) {\n    my @row;\n    @gcoord = @gcoord[(^@f.shape)]; # clip extraneous values\n    for coords( $hsize ) -> @hc {\n        my @fcoord;\n        for ^@hc -> $i {\n            my $window = @gcoord[$i] - @hc[$i];\n            @fcoord.push($window) and next if 0 ≤ $window < @f.shape[$i];\n            last;\n        }\n        @row.push: @fcoord == @hc ?? @f.AT-POS(|@fcoord) !! 0;\n    }\n    @row.push: @g.AT-POS(|@gcoord);\n    @row\n}\n\n# Constructs an AoA of coordinates to all elements of N dimensional array\nsub coords ( @dim ) {\n    @[reverse $_ for [X] ([^$_] for reverse @dim)]\n}\n\n# Reduced Row Echelon Form simultaneous equation solver\n# Can handle over-specified systems (N unknowns in N + M equations)\nsub rref (@m) {\n    @m = trim-system @m;\n    my ($lead, $rows, $cols) = 0, @m, @m[0];\n    for ^$rows -> $r {\n        return @m unless $lead < $cols;\n        my $i = $r;\n        until @m[$i;$lead] {\n            next unless ++$i == $rows;\n            $i = $r;\n            return @m if ++$lead == $cols;\n        }\n        @m[$i, $r] = @m[$r, $i] if $r != $i;\n        @m[$r] »/=» $ = @m[$r;$lead];\n        for ^$rows -> $n {\n            next if $n == $r;\n            @m[$n] »-=» @m[$r] »×» (@m[$n;$lead] // 0);\n        }\n        ++$lead;\n    }\n    @m\n }\n\n# Reduce to N equations in N unknowns; a no-op unless rows > cols\nsub trim-system (@m) {\n    return @m unless @m ≥ @m[0]; \n    my (\\vars, @t) = @m[0] - 1;\n    for ^vars -> \\lead {\n        for ^@m -> \\row {\n            @t.append: @m.splice(row, 1) and last if @m[row;lead];\n        }\n    }\n    while @t < vars and @m { @t.push: shift @m }\n    @t\n}\n\n# Pretty printer for N dimensional arrays\n# Assumes if first element in level is an array, then all are\nsub pretty-print ( @array, $indent = 0 ) {\n    if @array[0] ~~ Array {\n        say ' ' x $indent,\"[\";\n        pretty-print( $_, $indent + 2 ) for @array;\n        say ' ' x $indent, \"]{$indent??','!!''}\";\n    } else {\n        say ' ' x $indent, \"[{say_it(@array)} ]{$indent??','!!''}\";\n    }\n\n    sub say_it ( @array ) { return join \",\", @array».fmt(\"%4s\"); }\n}\n\nmy @f[3;2;3] = (\n  [\n    [ -9,  5, -8 ],\n    [  3,  5,  1 ],\n  ],\n  [\n    [ -1, -7,  2 ],\n    [ -5, -6,  6 ],\n  ],\n  [\n    [  8,  5,  8 ],\n    [ -2, -6, -4 ],\n  ]\n);\n\nmy @g[4;4;6] = (\n  [\n    [  54,  42,  53, -42,  85, -72 ],\n    [  45,-170,  94, -36,  48,  73 ],\n    [ -39,  65,-112, -16, -78, -72 ],\n    [   6, -11,  -6,  62,  49,   8 ],\n  ],\n  [\n    [ -57,  49, -23,  52,-135,  66 ],\n    [ -23, 127, -58,  -5,-118,  64 ],\n    [  87, -16, 121,  23, -41, -12 ],\n    [ -19,  29,  35,-148, -11,  45 ],\n  ],\n  [\n    [ -55,-147,-146, -31,  55,  60 ],\n    [ -88, -45, -28,  46, -26,-144 ],\n    [ -12,-107, -34, 150, 249,  66 ],\n    [  11, -15, -34,  27, -78, -50 ],\n  ],\n  [\n    [  56,  67, 108,   4,   2, -48 ],\n    [  58,  67,  89,  32,  32,  -8 ],\n    [ -42, -31,-103, -30, -23,  -8 ],\n    [   6,   4, -26, -10,  26,  12 ],\n  ]\n);\n\nsay \"# {+@f.shape}D array:\";\nmy @h = deconvolve-N( @g, @f );\nsay \"h =\";\npretty-print( @h );\nmy @h-shaped[2;3;4] = @(deconvolve-N( @g, @f ));\nmy @ff = deconvolve-N( @g, @h-shaped );\nsay \"\\nff =\";\npretty-print( @ff );\n\n```\n\nOutput:\n\n```\n# 3D array:\nh =\n[\n  [\n    [  -6,  -8,  -5,   9 ],\n    [  -7,   9,  -6,  -8 ],\n    [   2,  -7,   9,   8 ],\n  ],\n  [\n    [   7,   4,   4,  -6 ],\n    [   9,   9,   4,  -4 ],\n    [  -3,   7,  -2,  -3 ],\n  ],\n]\n\nff =\n[\n  [\n    [  -9,   5,  -8 ],\n    [   3,   5,   1 ],\n  ],\n  [\n    [  -1,  -7,   2 ],\n    [  -5,  -6,   6 ],\n  ],\n  [\n    [   8,   5,   8 ],\n    [  -2,  -6,  -4 ],\n  ],\n]\n```"}]}
{"messages": [{"role": "user", "content": "Introduction\n\nSuppose you have to sort a list of strings based on a property of each, called \"the key\", i.e. their lenghts. The most popular solution would require the use of a sorting algorithm with a custom comparator.\n\nNow suppose that key computation is an expensive operation, for example, it might involve intensive reading of files, databases, or exchanging information over a network. In such a case, using a sorting algorithm with a custom comparator is not optimal, because the key is computed multiple times for each element in the array, once each time the element needs to be compared to another (and also requires the calculation of the key for that other).\n\nThe decorate-sort-undecorate idiom\n\nOne solution of the problem is called the \"decorate-sort-undecorate\" idiom, pattern or technique. It was originated and named by the Lisp community.\n\nSuppose we want to sort the following list of words according to their lengths (the length was chosen for illustrative purposes, it is not precisely an \"expensive\" operation).\n\n`{\"Rosetta\", \"Code\", \"is\", \"a\", \"programming\", \"chrestomathy\", \"site\"}`\n\nAccording to the decorate-sort-decorate idiom, we have to \"decorate\" each element with its key, so each element of the original list becomes a pair. Notice that the key is calculated once (and only once) for each element in the list:\n\n`{{\"Rosetta\", 7}, {\"Code\", 4}, {\"is\", 2}, {\"a\", 1}, {\"programming\", 11}, {\"chrestomathy\", 12}, {\"site\", 4}}`\n\nThe list is then sorted according to the second element of each pair (the key), perhaps using a custom comparator:\n\n`{{\"a\", 1}, {\"is\", 2}, {\"site\", 4}, {\"Code\", 4}, {\"Rosetta\", 7}, {\"programming\", 11}, {\"chrestomathy\", 12}}`\n\nAnd finally, the list must be undecorated, we have to remove the second element of each pair (the key):\n\n`{\"a\", \"is\", \"site\", \"Code\", \"Rosetta\", \"programming\", \"chrestomathy\"}`\n\nSo, the decoration acts as a form of memoization.\n\nThe Schwartzian transform\n\nRandal L. Schwartz wrote an implementation of the decorate-sort-undecorate idiom in Perl in 1994, which gained much popularity in the Perl community. It was named \"Schwartzian transform\". Today the terms decorate-sort-undecorate and the Schwartzian transform are used interchangeably, even outside the Perl community.\n\nThe Wikipedia page states that a solution can be called a \"Schwartzian transform\" only if it does not use named temporary lists or arrays. The Lisp solution and even the solution shown by Schwartz actually use intermediate lists, but these lists do not have explicit names, instead they use a functional composition of map-sort-map operations.\n\nTask\n\nWrite in your programming language, a function, procedure, method, routine, etc. to sort a list of words by length (the key function), using the decorate-sort-undecorate idiom.\n\n* **Bonus 1**. If your solution can accept the key function as a callback.\n* **Bonus 2**. If your solution is also a \"Schwartzian transform\", this is, it does not use **named** temporary lists/arrays.\n\nYou can, at your choice, show two solutions, the first using intermediate named lists/arrays, and the second one not using them (a Schwartzian transform)(if applicable). The first solution is sometimes more valuable, because the use of named entities makes the code clearer.\n\nReferences\n\n:   * Wikipedia: Schwartzian transform"}, {"role": "assistant", "content": "It is somewhat rare to do, or even need to do an explicit schwartzian transform in Raku. You can pass a transform function to the sort operator, and it will use it to do its comparisons. As long as the transform is arity one (only takes one value,) the sort will *automatically* perform a schwartzian transform transparently, behind the scenes.\n\nHere the transform `.chars` is arity one, so a schwartzian transform is performed automatically by the compiler.\n\n```\n# automatic schwartzian transform\ndd <Rosetta Code is a programming chrestomathy site>.sort: *.chars;\n\n# explicit schwartzian transform\ndd <Rosetta Code is a programming chrestomathy site>.map({$_=>.chars}).sort({$^one.value cmp $^the-other.value}).map({.key});\n\n```\n\nOutput:\n\n( `dd` is the built in \"data-dumper\" function; a verbose and explicit representation of an objects contents.)\n\n```\n(\"a\", \"is\", \"Code\", \"site\", \"Rosetta\", \"programming\", \"chrestomathy\").Seq\n(\"a\", \"is\", \"Code\", \"site\", \"Rosetta\", \"programming\", \"chrestomathy\").Seq\n```\n\nMore complicated transforms may *require* an explicit schwartzian transform routine. An example of where an explicit transform is desirable is the `schwartzian()` routine in the Raku entry for the P-value\\_correction task."}]}
{"messages": [{"role": "user", "content": "Given a List (abstract data type) of integer values, find all its maximal-length non-increasing subsequences. Categorize each of these subsequences by its percentage change using the following groups:\n\n* Greater than 0% and less than 4%\n* Greater than or equal to 4% and less than 8%\n* Greater than or equal to 8% and less than 12%\n* Greater than or equal to 12% and less than 16%\n* Greater than or equal to 16% and less than 25%\n* Greater than or equal to 25%\n\nIf we were to plot these values, we'd be looking for peaks and troughs, categorized by the difference between the local maximum and the local minimum, as a percentage of the local maximum.\n\nA plot highlighting decreasing contiguous subsequences\n\nUsing the following example sequence, display the count of subsequences per group.\n\n```\n90, 90, 90, 91, 91, 92, 92, 92, 91, 91, 91, 90, 90, 90, 89, 89, 88, 87, 87, 87, 86, 86, 86, 85, 85,\n86, 86, 87, 87, 88, 89, 89, 89, 90, 90, 91, 91, 91, 92, 92, 92, 92, 92, 92, 92, 92, 92, 91, 91, 90,\n90, 90, 90, 90, 89, 89, 89, 89, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, 89,\n89, 90, 90, 90, 89, 89, 89, 89, 89, 89, 88, 88, 88, 88, 88, 88, 87, 88, 88, 88, 88, 88, 88, 88, 88,\n88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, 89, 88, 88, 88, 88, 88, 88, 89,\n89, 89, 89, 89, 89, 89, 89, 88, 88, 88, 88, 88, 88, 88, 88, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,\n87, 87, 88, 88, 88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, 89, 89, 89, 88, 88, 88, 88, 88, 88, 88,\n88, 88, 88, 88, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 88, 88, 88, 87, 87, 87, 87, 86, 86, 86, 86,\n86, 86, 87, 87, 87, 87, 87, 87, 87, 88, 88, 88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, 89, 89, 89,\n88, 88, 88, 88, 88, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 89, 89, 91,\n94, 94, 95, 96, 96, 96, 97, 97, 96, 96, 96, 96, 95, 95, 94, 93, 93, 92, 92, 91, 91, 90, 89, 89, 88,\n86, 86, 85, 83, 83, 81, 80, 80, 80, 79, 79, 79, 78, 78, 79, 81, 82, 82, 85, 89, 89, 91, 93, 93, 94,\n95, 95, 95, 95, 95, 95, 95, 95, 95, 94, 94, 94, 94, 93, 93, 93, 92, 92, 91, 91, 91, 90, 90, 90, 88,\n87, 87, 86, 85, 85, 84, 84, 84, 83, 84, 84, 84, 85, 86, 86, 87, 87, 87, 88, 88, 88, 89, 90, 90, 90,\n91, 91, 92, 92, 92, 93, 94, 94, 94, 95, 95, 95, 95, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91, 91, 90,\n89, 89, 87, 86, 85, 85, 84, 83, 83, 82, 82, 82, 81, 81, 81, 81, 81, 81, 82, 85, 85, 86, 89, 89, 91,\n92, 93, 93, 93, 94, 94, 94, 94, 94, 94, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91, 91, 91, 90, 89, 89,\n88, 88, 88, 87, 87, 87, 86, 86, 86, 85, 85, 85, 85, 85, 85, 86, 87, 87, 87, 88, 88, 88, 88, 88, 88,\n89, 89, 89, 89, 89, 89, 90, 90, 90, 90, 91, 91, 92, 93, 93, 94, 94, 95, 95, 95, 96, 96, 96, 95, 95,\n95, 94, 94, 93, 93, 93, 92, 90, 90, 89, 87, 87, 87, 85, 83, 83, 82, 81, 81, 81, 80, 80, 81, 81, 81,\n81, 81, 81, 81, 81, 81, 81, 81, 81, 83, 86, 88, 88, 90, 91, 91, 91, 92, 92, 93, 93, 93, 94, 95, 95,\n95, 96, 96, 96, 96, 96, 96, 96, 95, 95, 95, 95, 95, 94, 93, 93, 92, 92, 92, 91, 90, 90, 90, 90, 90,\n91, 93, 93, 94, 94, 94, 94, 95, 94, 94, 94, 94, 94, 94, 93, 93, 93, 93, 93, 93, 92, 92, 92, 92, 92,\n91, 91, 91, 91, 91, 91, 91, 91, 90, 90, 90, 90, 90, 90, 90, 90, 89, 89, 89, 89, 89, 89, 89, 89, 89,\n89, 90, 90, 90, 90, 91, 91, 92, 93, 93, 93, 94, 94, 94, 94, 94, 94, 94, 94, 94, 95, 95, 95, 95, 95,\n95, 95, 95, 95, 94, 93, 93, 93, 93, 93, 92, 92, 92, 91, 91, 91, 91, 90, 90, 90, 89, 89, 89, 88, 88,\n88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 91, 91, 91, 91,\n91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 91, 92,\n92, 93, 93, 93, 93, 94, 94, 94, 93, 93, 93, 93, 93, 93, 92, 92, 92, 91, 91, 91, 90, 90, 90, 89, 88,\n88, 87, 87, 87, 86, 86, 85, 85, 85, 86, 86, 86, 87, 87, 88, 88, 88, 89, 90, 90, 90, 91, 91, 91, 91,\n91, 91, 91, 91, 91, 92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 92, 92, 92, 91, 91, 90, 90, 90, 89, 88,\n87, 87, 87, 86, 86, 86, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 86, 86, 86, 86, 87, 88, 88, 88,\n89, 89, 90, 91, 91, 92, 93, 93, 93, 94, 94, 94, 94, 94, 94, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91,\n90, 90, 90, 89, 89, 88, 88, 88, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 88, 88, 88,\n90, 90, 91, 93, 93, 93, 93, 93, 94, 93, 93, 93, 93, 93, 93, 92, 92, 92, 91, 91, 91, 90, 90, 90, 89,\n89, 89, 88, 87, 87, 87, 87, 87, 86, 87, 87, 87, 87, 87, 87, 87, 87, 87, 88, 88, 88, 88, 88, 88, 88,\n89\n\n```\n\nIt's OK to hard code the example sequence or read it from a file. Plotting decreasing subsequences is optional."}, {"role": "assistant", "content": "Since these are percentages, no need to specify a span. The span is automatically 0-100. The carat in the bin ranges mean \"upto, but not including\".\n\n```\nmy @values =\n90, 90, 90, 91, 91, 92, 92, 92, 91, 91, 91, 90, 90, 90, 89, 89, 88, 87, 87, 87, 86, 86, 86, 85, 85,\n86, 86, 87, 87, 88, 89, 89, 89, 90, 90, 91, 91, 91, 92, 92, 92, 92, 92, 92, 92, 92, 92, 91, 91, 90,\n90, 90, 90, 90, 89, 89, 89, 89, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, 89,\n89, 90, 90, 90, 89, 89, 89, 89, 89, 89, 88, 88, 88, 88, 88, 88, 87, 88, 88, 88, 88, 88, 88, 88, 88,\n88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, 89, 88, 88, 88, 88, 88, 88, 89,\n89, 89, 89, 89, 89, 89, 89, 88, 88, 88, 88, 88, 88, 88, 88, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,\n87, 87, 88, 88, 88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, 89, 89, 89, 88, 88, 88, 88, 88, 88, 88,\n88, 88, 88, 88, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 88, 88, 88, 87, 87, 87, 87, 86, 86, 86, 86,\n86, 86, 87, 87, 87, 87, 87, 87, 87, 88, 88, 88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, 89, 89, 89,\n88, 88, 88, 88, 88, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 89, 89, 91,\n94, 94, 95, 96, 96, 96, 97, 97, 96, 96, 96, 96, 95, 95, 94, 93, 93, 92, 92, 91, 91, 90, 89, 89, 88,\n86, 86, 85, 83, 83, 81, 80, 80, 80, 79, 79, 79, 78, 78, 79, 81, 82, 82, 85, 89, 89, 91, 93, 93, 94,\n95, 95, 95, 95, 95, 95, 95, 95, 95, 94, 94, 94, 94, 93, 93, 93, 92, 92, 91, 91, 91, 90, 90, 90, 88,\n87, 87, 86, 85, 85, 84, 84, 84, 83, 84, 84, 84, 85, 86, 86, 87, 87, 87, 88, 88, 88, 89, 90, 90, 90,\n91, 91, 92, 92, 92, 93, 94, 94, 94, 95, 95, 95, 95, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91, 91, 90,\n89, 89, 87, 86, 85, 85, 84, 83, 83, 82, 82, 82, 81, 81, 81, 81, 81, 81, 82, 85, 85, 86, 89, 89, 91,\n92, 93, 93, 93, 94, 94, 94, 94, 94, 94, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91, 91, 91, 90, 89, 89,\n88, 88, 88, 87, 87, 87, 86, 86, 86, 85, 85, 85, 85, 85, 85, 86, 87, 87, 87, 88, 88, 88, 88, 88, 88,\n89, 89, 89, 89, 89, 89, 90, 90, 90, 90, 91, 91, 92, 93, 93, 94, 94, 95, 95, 95, 96, 96, 96, 95, 95,\n95, 94, 94, 93, 93, 93, 92, 90, 90, 89, 87, 87, 87, 85, 83, 83, 82, 81, 81, 81, 80, 80, 81, 81, 81,\n81, 81, 81, 81, 81, 81, 81, 81, 81, 83, 86, 88, 88, 90, 91, 91, 91, 92, 92, 93, 93, 93, 94, 95, 95,\n95, 96, 96, 96, 96, 96, 96, 96, 95, 95, 95, 95, 95, 94, 93, 93, 92, 92, 92, 91, 90, 90, 90, 90, 90,\n91, 93, 93, 94, 94, 94, 94, 95, 94, 94, 94, 94, 94, 94, 93, 93, 93, 93, 93, 93, 92, 92, 92, 92, 92,\n91, 91, 91, 91, 91, 91, 91, 91, 90, 90, 90, 90, 90, 90, 90, 90, 89, 89, 89, 89, 89, 89, 89, 89, 89,\n89, 90, 90, 90, 90, 91, 91, 92, 93, 93, 93, 94, 94, 94, 94, 94, 94, 94, 94, 94, 95, 95, 95, 95, 95,\n95, 95, 95, 95, 94, 93, 93, 93, 93, 93, 92, 92, 92, 91, 91, 91, 91, 90, 90, 90, 89, 89, 89, 88, 88,\n88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 91, 91, 91, 91,\n91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 91, 92,\n92, 93, 93, 93, 93, 94, 94, 94, 93, 93, 93, 93, 93, 93, 92, 92, 92, 91, 91, 91, 90, 90, 90, 89, 88,\n88, 87, 87, 87, 86, 86, 85, 85, 85, 86, 86, 86, 87, 87, 88, 88, 88, 89, 90, 90, 90, 91, 91, 91, 91,\n91, 91, 91, 91, 91, 92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 92, 92, 92, 91, 91, 90, 90, 90, 89, 88,\n87, 87, 87, 86, 86, 86, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 86, 86, 86, 86, 87, 88, 88, 88,\n89, 89, 90, 91, 91, 92, 93, 93, 93, 94, 94, 94, 94, 94, 94, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91,\n90, 90, 90, 89, 89, 88, 88, 88, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 88, 88, 88,\n90, 90, 91, 93, 93, 93, 93, 93, 94, 93, 93, 93, 93, 93, 93, 92, 92, 92, 91, 91, 91, 90, 90, 90, 89,\n89, 89, 88, 87, 87, 87, 87, 87, 86, 87, 87, 87, 87, 87, 87, 87, 87, 87, 88, 88, 88, 88, 88, 88, 88,\n89;\n\nmy @bins = 0^..^4, 4..^8, 8..^12, 12..^16, 16..^25, 25..100;\n\nmy @subseqs;\n\n@values.map: {\n    state $last = $_;\n    state $incr = 0;\n    ++$incr if $_ > $last;\n    @subseqs[$incr].push: $_;\n    $last = $_;\n};\n\nsub bin (@items, @bins, :&as) {\n    my @classified;\n    for @items {\n        my $value = .&as;\n        for @bins {\n            state $index = 0;\n            @classified[$index]++ if $value ∈ $_;\n            ++$index;\n        }\n    }\n    @classified\n}\n\nsay \"{.[0].gist}% : {.[1]}\" for @bins Z flat @subseqs.&bin(@bins, :as{[R-] .minmax.bounds}), 0 xx *;\n\n```\n\nOutput:\n\n```\n0^..^4% : 7\n4..^8% : 6\n8..^12% : 4\n12..^16% : 2\n16..^25% : 2\n25..100% : 0\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate how to copy data structures containing complex heterogeneous and cyclic semantics.\n\nThis is often referred to as deep copying, and is normally required where structures are mutable and to ensure that independent copies can be manipulated without side-effects.\n\nIf this facility is not built into the language, it is permissible to use functions from a common library, or a coded procedure.\n\nThe task should show:\n\n* Relevant semantics of structures, such as their homogeneous or heterogeneous properties, or containment of (self- or mutual-reference) cycles.\n\n* Any limitations of the method.\n\n* That the structure and its copy are different.\n\n* Suitable links to external documentation for common libraries."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku doesn't currently provide a proper mechanism for deep copies, but depending on your requirements you could use one of these work-arounds:\n\n**1) Use `.deepmap(*.clone)`:**\n\n.deepmap constructs a copy of the data structure, and .clone makes a shallow copy of each leaf node. Limitations:\n\n* Hangs indefinitely when given a self-referential data structure.\n* Descends only into Iterable collections (like Array/Hash), which means that a Pair or a typical custom object would be considered a leaf node.\n\n```\nmy %x = foo => 0, bar => [0, 1];\nmy %y = %x.deepmap(*.clone);\n\n%x<bar>[1]++;\nsay %x;\nsay %y;\n\n```\n\nOutput:\n\n```\n{bar => [0 2], foo => 0}\n{bar => [0 1], foo => 0}\n\n```\n\n**2) Use `.raku.EVAL`:**\n\n.raku serializes the data structure to Raku code, and .EVAL deserializes it. Limitations:\n\n* Doesn't work correctly if the data structure contains elements that can't be properly serialized, such as closures or file handles.\n\n```\nmy %x = foo => 0, bar => [0, 1];\nmy %y = %x.raku.EVAL;\n\n%x<bar>[1]++;\nsay %x;\nsay %y;\n\n```\n\nOutput:\n\n```\n{bar => [0 2], foo => 0}\n{bar => [0 1], foo => 0}\n\n```"}]}
{"messages": [{"role": "user", "content": "Demonstrate how to define a type that behaves like an integer but has a lowest valid value of 1 and a highest valid value of 10. Include all bounds checking you need to write, or explain how the compiler or interpreter creates those bounds checks for you."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsubset OneToTen of Int where 1..10;\n\nmy OneToTen $n = 5;\n$n += 6;\n\n```\n\nHere the result 11 fails to smartmatch against the range `1..10`, so the second assignment throws an exception. You may use any valid smartmatch predicate within a `where` clause, so the following one-argument closure is also legal:\n\n```\nsubset Prime of Int where -> $n { $n > 1 and so $n %% none 2 .. $n.sqrt }\n\n```"}]}
{"messages": [{"role": "user", "content": "A delegate is a helper object used by another object. The delegator may send the delegate certain messages, and provide a default implementation when there is no delegate or the delegate does not respond to a message. This pattern is heavily used in Cocoa framework on Mac OS X. See also wp:Delegation pattern.\n\nObjects responsibilities:\n\nDelegator:\n\n* Keep an optional delegate instance.\n* Implement \"operation\" method, returning the delegate \"thing\" if the delegate respond to \"thing\", or the string \"default implementation\".\n\nDelegate:\n\n* Implement \"thing\" and return the string \"delegate implementation\"\n\nShow how objects are created and used. First, without a delegate, then with a delegate that does not implement \"thing\", and last with a delegate that implements \"thing\"."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nclass Non-Delegate  { }\n\nclass Delegate {\n\tmethod thing {\n\t\treturn \"delegate implementation\"\n\t}\n}\n\nclass Delegator {\n\thas $.delegate is rw;\n\n\tmethod operation {\n\t\t$.delegate.^can( 'thing' ) ?? $.delegate.thing\n\t\t!! \"default implementation\"\n\t}\n}\n\nmy Delegator $d .= new;\n\nsay \"empty: \"~$d.operation;\n\n$d.delegate = Non-Delegate.new;\n\nsay \"Non-Delegate: \"~$d.operation;\n\n$d.delegate = Delegate.new;\n\nsay \"Delegate: \"~$d.operation;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDelete a file called \"input.txt\" and delete a directory called \"docs\".\n\nThis should be done twice: once \"here\", i.e. in the current working directory and once in the filesystem root."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nunlink 'input.txt';\nunlink '/input.txt';\nrmdir 'docs';\nrmdir '/docs';\n\n```"}]}
{"messages": [{"role": "user", "content": "W Edwards Deming was an American statistician and management guru who used physical demonstrations to illuminate his teachings. In one demonstration Deming repeatedly dropped marbles through a funnel at a target, marking where they landed, and observing the resulting pattern. He applied a sequence of \"rules\" to try to improve performance. In each case the experiment begins with the funnel positioned directly over the target.\n\n* **Rule 1**: The funnel remains directly above the target.\n* **Rule 2**: Adjust the funnel position by shifting the target to compensate after each drop. E.g. If the last drop missed 1 cm east, move the funnel 1 cm to the west of its current position.\n* **Rule 3**: As rule 2, but first move the funnel back over the target, before making the adjustment. E.g. If the funnel is 2 cm north, and the marble lands 3 cm north, move the funnel 3 cm south of the target.\n* **Rule 4**: The funnel is moved directly over the last place a marble landed.\n\nApply the four rules to the set of 50 pseudorandom displacements provided (e.g in the Racket solution) for the dxs and dys. **Output**: calculate the mean and standard-deviations of the resulting x and y values for each rule.\n\nNote that rules 2, 3, and 4 give successively worse results. Trying to deterministically compensate for a random process is counter-productive, but -- according to Deming -- quite a popular pastime: see the Further Information, below for examples.\n\n**Stretch goal 1**: Generate fresh pseudorandom data. The radial displacement of the drop from the funnel position is given by a Gaussian distribution (standard deviation is 1.0) and the angle of displacement is uniformly distributed.\n\n**Stretch goal 2**: Show scatter plots of all four results.\n\nFurther information\n\n* Further explanation and interpretation\n* Video demonstration of the funnel experiment at the Mayo Clinic."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.10\n\n```\nsub mean { @_ R/ [+] @_ }\nsub stddev {\n    # <(x - <x>)²> = <x²> - <x>²\n    sqrt( mean(@_ »**» 2) - mean(@_)**2 )\n}\n\nconstant @dz = <\n    -0.533  0.270  0.859 -0.043 -0.205 -0.127 -0.071  0.275\n     1.251 -0.231 -0.401  0.269  0.491  0.951  1.150  0.001\n    -0.382  0.161  0.915  2.080 -2.337  0.034 -0.126  0.014\n     0.709  0.129 -1.093 -0.483 -1.193  0.020 -0.051  0.047\n    -0.095  0.695  0.340 -0.182  0.287  0.213 -0.423 -0.021\n    -0.134  1.798  0.021 -1.099 -0.361  1.636 -1.134  1.315\n     0.201  0.034  0.097 -0.170  0.054 -0.553 -0.024 -0.181\n    -0.700 -0.361 -0.789  0.279 -0.174 -0.009 -0.323 -0.658\n     0.348 -0.528  0.881  0.021 -0.853  0.157  0.648  1.774\n    -1.043  0.051  0.021  0.247 -0.310  0.171  0.000  0.106\n     0.024 -0.386  0.962  0.765 -0.125 -0.289  0.521  0.017\n     0.281 -0.749 -0.149 -2.436 -0.909  0.394 -0.113 -0.598\n     0.443 -0.521 -0.799  0.087\n> Z+ (1i X* <\n     0.136  0.717  0.459 -0.225  1.392  0.385  0.121 -0.395\n     0.490 -0.682 -0.065  0.242 -0.288  0.658  0.459  0.000\n     0.426  0.205 -0.765 -2.188 -0.742 -0.010  0.089  0.208\n     0.585  0.633 -0.444 -0.351 -1.087  0.199  0.701  0.096\n    -0.025 -0.868  1.051  0.157  0.216  0.162  0.249 -0.007\n     0.009  0.508 -0.790  0.723  0.881 -0.508  0.393 -0.226\n     0.710  0.038 -0.217  0.831  0.480  0.407  0.447 -0.295\n     1.126  0.380  0.549 -0.445 -0.046  0.428 -0.074  0.217\n    -0.822  0.491  1.347 -0.141  1.230 -0.044  0.079  0.219\n     0.698  0.275  0.056  0.031  0.421  0.064  0.721  0.104\n    -0.729  0.650 -1.103  0.154 -1.720  0.051 -0.385  0.477\n     1.537 -0.901  0.939 -0.411  0.341 -0.411  0.106  0.224\n    -0.947 -1.424 -0.542 -1.032\n>);\n\nconstant @rule = \n-> \\z, \\dz { 0 },\n-> \\z, \\dz { -dz },\n-> \\z, \\dz { -z - dz },\n-> \\z, \\dz {  z + dz },\n;\n\nfor @rule {\n    say \"Rule $(++$):\";\n    my $target = 0i;\n    my @z = gather for @dz -> $dz {\n\ttake $target + $dz;\n\t$target = .($target, $dz)\n    }\n    printf \"Mean    x, y   : %7.4f %7.4f\\n\",   mean(@z».re),   mean(@z».im);\n    printf \"Std dev x, y   : %7.4f %7.4f\\n\", stddev(@z».re), stddev(@z».im);\n}\n\n```\n\nOutput:\n\n```\nRule 1:\nMean    x, y   :  0.0004  0.0702\nStd dev x, y   :  0.7153  0.6462\nRule 2:\nMean    x, y   :  0.0009 -0.0103\nStd dev x, y   :  1.0371  0.8999\nRule 3:\nMean    x, y   :  0.0439 -0.0063\nStd dev x, y   :  7.9871  4.7784\nRule 4:\nMean    x, y   :  3.1341  5.4210\nStd dev x, y   :  1.5874  3.9304\n```"}]}
{"messages": [{"role": "user", "content": "There is a highly organized city that has decided to assign a number to each of their departments:\n\n:   :   * police department\n        * sanitation department\n        * fire department\n\nEach department can have a number between   **1**   and   **7**   (inclusive).\n\nThe three department numbers are to be unique (different from each other) and must add up to   **12**.\n\nThe Chief of the Police doesn't like odd numbers and wants to have an even number for his department.\n\nTask\n\nWrite a computer program which outputs all valid combinations.\n\nPossible output   (for the 1st and 14th solutions):\n\n```\n --police--  --sanitation--  --fire-- \n     2             3            7 \n     6             5            1\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nfor (1..7).combinations(3).grep(*.sum == 12) {\n    for   .permutations\\  .grep(*.[0] %%  2) {\n        say <police fire sanitation> Z=> .list;\n    }\n}\n\n```\n\nOutput:\n\n```\n(police => 4 fire => 1 sanitation => 7)\n(police => 4 fire => 7 sanitation => 1)\n(police => 6 fire => 1 sanitation => 5)\n(police => 6 fire => 5 sanitation => 1)\n(police => 2 fire => 3 sanitation => 7)\n(police => 2 fire => 7 sanitation => 3)\n(police => 2 fire => 4 sanitation => 6)\n(police => 2 fire => 6 sanitation => 4)\n(police => 4 fire => 2 sanitation => 6)\n(police => 4 fire => 6 sanitation => 2)\n(police => 6 fire => 2 sanitation => 4)\n(police => 6 fire => 4 sanitation => 2)\n(police => 4 fire => 3 sanitation => 5)\n(police => 4 fire => 5 sanitation => 3)\n\n```"}]}
{"messages": [{"role": "user", "content": "Generate and show all primes with strictly descending decimal digits.\n\nSee also\n\n* OEIS:A052014 - Primes with distinct digits in descending order\n\nRelated\n\n* Ascending primes"}, {"role": "assistant", "content": "Trivial variation of Ascending primes task.\n\n```\nput (flat 2, 3, 5, 7, sort +*, gather (3..9).map: &recurse ).batch(10)».fmt(\"%8d\").join: \"\\n\";\n\nsub recurse ($str) {\n    .take for ($str X~ (1, 3, 7)).grep: { .is-prime && [>] .comb };\n    recurse $str × 10 + $_ for 2 ..^ $str % 10;\n}\n\n```\n\nOutput:\n\n```\n       2        3        5        7       31       41       43       53       61       71\n      73       83       97      421      431      521      541      631      641      643\n     653      743      751      761      821      853      863      941      953      971\n     983     5431     6421     6521     7321     7541     7621     7643     8431     8521\n    8543     8641     8731     8741     8753     8761     9421     9431     9521     9631\n    9643     9721     9743     9851     9871    75431    76421    76541    76543    86531\n   87421    87541    87631    87641    87643    94321    96431    97651    98321    98543\n   98621    98641    98731   764321   865321   876431   975421   986543   987541   987631\n 8764321  8765321  9754321  9875321 97654321 98764321 98765431\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function to detect a   *divide by zero error*   without checking if the denominator is zero."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n#### Try/Catch\n\n```\nsub div($a, $b) {\n    my $r;\n    try {\n        $r = $a / $b;\n        CATCH {\n            default { note \"Unexpected exception, $_\" }\n        }\n    }\n    return $r // Nil;\n}\nsay div(10,2);\nsay div(1, sin(0));\n\n```\n\nOutput:\n\n```\n5\nUnexpected exception, Attempt to divide 1 by zero using /\nNil\n```\n\n#### Multi Method Dispatch\n\n```\nmulti div($a, $b) { return $a / $b }\nmulti div($a, $b where { $b == 0 }) { note 'Attempt to divide by zero.'; return Nil }\n\nsay div(10, 2);\nsay div(1, sin(0));\n\n```\n\nOutput:\n\n```\n5\nAttempt to divide by zero.\nNil\n```"}]}
{"messages": [{"role": "user", "content": "For a given matrix, return the determinant and the permanent of the matrix.\n\nThe determinant is given by\n\n:   :   det\n        (\n        A\n        )\n        =\n\n        ∑\n\n        σ\n        sgn\n        ⁡\n        (\n        σ\n        )\n\n        ∏\n\n        i\n        =\n        1\n\n        n\n\n        M\n\n        i\n        ,\n\n        σ\n\n        i\n        {\\displaystyle {\\displaystyle \\det(A)=\\sum \\_{\\sigma }\\operatorname {sgn}(\\sigma )\\prod \\_{i=1}^{n}M\\_{i,\\sigma \\_{i}}}}\n\nwhile the permanent is given by\n\n:   :   perm\n        ⁡\n        (\n        A\n        )\n        =\n\n        ∑\n\n        σ\n\n        ∏\n\n        i\n        =\n        1\n\n        n\n\n        M\n\n        i\n        ,\n\n        σ\n\n        i\n        {\\displaystyle {\\displaystyle \\operatorname {perm} (A)=\\sum \\_{\\sigma }\\prod \\_{i=1}^{n}M\\_{i,\\sigma \\_{i}}}}\n\nIn both cases the sum is over the permutations \n\nσ\n{\\displaystyle {\\displaystyle \\sigma }}\n of the permutations of 1, 2, ..., *n*. (A permutation's sign is 1 if there are an even number of inversions and -1 otherwise; see parity of a permutation.)\n\nMore efficient algorithms for the determinant are known: LU decomposition, see for example wp:LU decomposition#Computing the determinant. Efficient methods for calculating the permanent are not known.\n\nRelated task\n\n* Permutations by swapping"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\nUses the permutations generator from the Permutations by swapping task. This implementation is naive and brute-force (slow) but exact.\n\n```\nsub insert ($x, @xs) { ([flat @xs[0 ..^ $_], $x, @xs[$_ .. *]] for 0 .. @xs) }\nsub order ($sg, @xs) { $sg > 0 ?? @xs !! @xs.reverse }\n\nmulti σ_permutations ([]) { [] => 1 }\n\nmulti σ_permutations ([$x, *@xs]) {\n    σ_permutations(@xs).map({ |order($_.value, insert($x, $_.key)) }) Z=> |(1,-1) xx *\n}\n\nsub m_arith ( @a, $op ) {\n    note \"Not a square matrix\" and return\n      if [||] map { @a.elems cmp @a[$_].elems }, ^@a;\n    sum σ_permutations([^@a]).race.map: {\n        my $permutation = .key;\n        my $term = $op eq 'perm' ?? 1 !! .value;\n        for $permutation.kv -> $i, $j { $term *= @a[$i][$j] };\n        $term\n    }\n}\n\n######### helper subs #########\nsub hilbert-matrix (\\h) {[(1..h).map(-> \\n {[(n..^n+h).map: {(1/$_).FatRat}]})]}\n\nsub rat-or-int ($num) {\n    return $num unless $num ~~ Rat|FatRat;\n    return $num.narrow if $num.narrow.WHAT ~~ Int;\n    $num.nude.join: '/';\n}\n\nsub say-it ($message, @array) {\n    my $max;\n    @array.map: {$max max= max $_».&rat-or-int.comb(/\\S+/)».chars};\n    say \"\\n$message\";\n    $_».&rat-or-int.fmt(\" %{$max}s\").put for @array;\n}\n\n########### Testing ###########\nmy @tests = (\n    [\n        [ 1, 2 ],\n        [ 3, 4 ]\n    ],\n    [\n        [  1,  2,  3,  4 ],\n        [  4,  5,  6,  7 ],\n        [  7,  8,  9, 10 ],\n        [ 10, 11, 12, 13 ]\n    ],\n    hilbert-matrix 7\n);\n\nfor @tests -> @matrix {\n    say-it 'Matrix:', @matrix;\n    say \"Determinant:\\t\", rat-or-int @matrix.&m_arith: <det>;\n    say \"Permanent:  \\t\", rat-or-int @matrix.&m_arith: <perm>;\n    say '-' x 40;\n}\n\n```\n\n**Output**\n\n```\nMatrix:\n 1  2\n 3  4\nDeterminant:\t-2\nPermanent:  \t10\n----------------------------------------\n\nMatrix:\n  1   2   3   4\n  4   5   6   7\n  7   8   9  10\n 10  11  12  13\nDeterminant:\t0\nPermanent:  \t29556\n----------------------------------------\n\nMatrix:\n    1   1/2   1/3   1/4   1/5   1/6   1/7\n  1/2   1/3   1/4   1/5   1/6   1/7   1/8\n  1/3   1/4   1/5   1/6   1/7   1/8   1/9\n  1/4   1/5   1/6   1/7   1/8   1/9  1/10\n  1/5   1/6   1/7   1/8   1/9  1/10  1/11\n  1/6   1/7   1/8   1/9  1/10  1/11  1/12\n  1/7   1/8   1/9  1/10  1/11  1/12  1/13\nDeterminant:\t1/2067909047925770649600000\nPermanent:  \t29453515169174062608487/2067909047925770649600000\n----------------------------------------\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a character string   (which may be empty, or have a length of zero characters):\n\n:   :   * create a function/procedure/routine to:\n\n        :   :   * determine if all the characters in the string are the same\n                * indicate if or which character is different from the previous character\n\n        * display each string and its length   (as the strings are being examined)\n        * a zero─length (empty) string shall be considered as all the same character(s)\n        * process the strings from left─to─right\n        * if       all the same character,   display a message saying such\n        * if not all the same character,   then:\n\n        :   :   * display a message saying such\n                * display what character is different\n                * only the 1st different character need be displayed\n                * display where the different character is in the string\n                * the above messages can be part of a single message\n                * display the hexadecimal value of the different character\n\nUse (at least) these seven test values   (strings):\n\n:   :   :   * a string of length   0   (an empty string)\n            * a string of length   3   which contains three blanks\n            * a string of length   1   which contains:   **2**\n            * a string of length   3   which contains:   **333**\n            * a string of length   3   which contains:   **.55**\n            * a string of length   6   which contains:   **tttTTT**\n            * a string of length   9   with a blank in the middle:   **4444   444k**\n\nShow all output here on this page.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\nThe last string demonstrates how Raku can recognize that glyphs made up of different combinations of combining characters can compare the same. It is built up from explicit codepoints to show that each of the glyphs is made up of different combinations.\n\n```\n  -> $str {\n    my $i = 0;\n    print \"\\n{$str.raku} (length: {$str.chars}), has \";\n    my %m;\n    %m{$_}.push: ++$i for $str.comb;\n\n    if %m > 1 {\n        say \"different characters:\";\n        say \"'{.key}' ({.key.uninames}; hex ordinal: {(.key.ords).fmt: \"0x%X\"})\" ~\n        \" in positions: {.value.join: ', '}\" for %m.sort( *.value[0] );\n    } else {\n        say \"the same character in all positions.\"\n    }\n} for\n    '',\n    '   ',\n    '2',\n    '333',\n    '.55',\n    'tttTTT',\n    '4444 444k',\n    '🇬🇧🇬🇧🇬🇧🇬🇧',\n    \"\\c[LATIN CAPITAL LETTER A]\\c[COMBINING DIAERESIS]\\c[COMBINING MACRON]\" ~\n    \"\\c[LATIN CAPITAL LETTER A WITH DIAERESIS]\\c[COMBINING MACRON]\" ~\n    \"\\c[LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON]\",\n    'AАΑꓮ𐌀𐊠Ꭺ'\n\n```\n\nOutput:\n\n```\n\"\" (length: 0), has the same character in all positions.\n\n\"   \" (length: 3), has the same character in all positions.\n\n\"2\" (length: 1), has the same character in all positions.\n\n\"333\" (length: 3), has the same character in all positions.\n\n\".55\" (length: 3), has different characters:\n'.' (FULL STOP; hex ordinal: 0x2E) in positions: 1\n'5' (DIGIT FIVE; hex ordinal: 0x35) in positions: 2, 3\n\n\"tttTTT\" (length: 6), has different characters:\n't' (LATIN SMALL LETTER T; hex ordinal: 0x74) in positions: 1, 2, 3\n'T' (LATIN CAPITAL LETTER T; hex ordinal: 0x54) in positions: 4, 5, 6\n\n\"4444 444k\" (length: 9), has different characters:\n'4' (DIGIT FOUR; hex ordinal: 0x34) in positions: 1, 2, 3, 4, 6, 7, 8\n' ' (SPACE; hex ordinal: 0x20) in positions: 5\n'k' (LATIN SMALL LETTER K; hex ordinal: 0x6B) in positions: 9\n\n\"🇬🇧🇬🇧🇬🇧🇬🇧\" (length: 4), has the same character in all positions.\n\n\"ǞǞǞ\" (length: 3), has the same character in all positions.\n\n\"AАΑꓮ𐌀𐊠Ꭺ\" (length: 7), has different characters:\n'A' (LATIN CAPITAL LETTER A; hex ordinal: 0x41) in positions: 1\n'А' (CYRILLIC CAPITAL LETTER A; hex ordinal: 0x410) in positions: 2\n'Α' (GREEK CAPITAL LETTER ALPHA; hex ordinal: 0x391) in positions: 3\n'ꓮ' (LISU LETTER A; hex ordinal: 0xA4EE) in positions: 4\n'𐌀' (OLD ITALIC LETTER A; hex ordinal: 0x10300) in positions: 5\n'𐊠' (CARIAN LETTER A; hex ordinal: 0x102A0) in positions: 6\n'Ꭺ' (CHEROKEE LETTER GO; hex ordinal: 0x13AA) in positions: 7\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a character string   (which may be empty, or have a length of zero characters):\n\n:   :   * create a function/procedure/routine to:\n\n        :   :   * determine if all the characters in the string are unique\n                * indicate if or which character is duplicated and where\n\n        * display each string and its length   (as the strings are being examined)\n        * a zero─length (empty) string shall be considered as unique\n        * process the strings from left─to─right\n        * if       unique,   display a message saying such\n        * if not unique,   then:\n\n        :   :   * display a message saying such\n                * display what character is duplicated\n                * only the 1st non─unique character need be displayed\n                * display where \"both\" duplicated characters are in the string\n                * the above messages can be part of a single message\n                * display the hexadecimal value of the duplicated character\n\nUse (at least) these five test values   (strings):\n\n:   :   :   * a string of length     0   (an empty string)\n            * a string of length     1   which is a single period   (**.**)\n            * a string of length     6   which contains:   **abcABC**\n            * a string of length     7   which contains a blank in the middle:   **XYZ  ZYX**\n            * a string of length   36   which   *doesn't*   contain the letter \"oh\":\n\n            :   :   :   :   :   **1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ**\n\nShow all output here on this page.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\nRaku works with unicode natively and handles combining characters and multi-byte emoji correctly. In the last string, notice the the length is correctly shown as 11 characters and that the delta with a combining circumflex in position 6 is not the same as the deltas without in positions 5 & 9.\n\n```\n  -> $str {\n    my $i = 0;\n    print \"\\n{$str.raku} (length: {$str.chars}), has \";\n    my %m = $str.comb.Bag;\n    if any(%m.values) > 1 {\n        say \"duplicated characters:\";\n        say \"'{.key}' ({.key.uninames}; hex ordinal: {(.key.ords).fmt: \"0x%X\"})\" ~\n        \" in positions: {.value.join: ', '}\" for %m.grep( *.value > 1 ).sort( *.value[0] );\n    } else {\n        say \"no duplicated characters.\"\n    }\n} for\n    '',\n    '.',\n    'abcABC',\n    'XYZ ZYX',\n    '1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ',\n    '01234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ0X',\n    '🦋🙂👨‍👩‍👧‍👦🙄ΔΔ̂ 🦋Δ👍👨‍👩‍👧‍👦'\n\n```\n\nOutput:\n\n```\n\"\" (length: 0), has no duplicated characters.\n\n\".\" (length: 1), has no duplicated characters.\n\n\"abcABC\" (length: 6), has no duplicated characters.\n\n\"XYZ ZYX\" (length: 7), has duplicated characters:\n'X' (LATIN CAPITAL LETTER X; hex ordinal: 0x58) in positions: 1, 7\n'Y' (LATIN CAPITAL LETTER Y; hex ordinal: 0x59) in positions: 2, 6\n'Z' (LATIN CAPITAL LETTER Z; hex ordinal: 0x5A) in positions: 3, 5\n\n\"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ\" (length: 36), has duplicated characters:\n'0' (DIGIT ZERO; hex ordinal: 0x30) in positions: 10, 25\n\n\"01234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ0X\" (length: 39), has duplicated characters:\n'0' (DIGIT ZERO; hex ordinal: 0x30) in positions: 1, 11, 26, 38\n'X' (LATIN CAPITAL LETTER X; hex ordinal: 0x58) in positions: 35, 39\n\n\"🦋🙂👨‍👩‍👧‍👦🙄ΔΔ̂ 🦋Δ👍👨‍👩‍👧‍👦\" (length: 11), has duplicated characters:\n'🦋' (BUTTERFLY; hex ordinal: 0x1F98B) in positions: 1, 8\n'👨‍👩‍👧‍👦' (MAN ZERO WIDTH JOINER WOMAN ZERO WIDTH JOINER GIRL ZERO WIDTH JOINER BOY; hex ordinal: 0x1F468 0x200D 0x1F469 0x200D 0x1F467 0x200D 0x1F466) in positions: 3, 11\n'Δ' (GREEK CAPITAL LETTER DELTA; hex ordinal: 0x394) in positions: 5, 9\n\n```"}]}
{"messages": [{"role": "user", "content": "Determine if a character string is   *collapsible*.\n\nAnd if so,   collapse the string   (by removing   *immediately repeated*   characters).\n\nIf a character string has   *immediately repeated*   character(s),   the repeated characters are to be\ndeleted (removed),   but not the primary (1st) character(s).\n\nAn   *immediately repeated*   character is any character that is   immediately   followed by an\nidentical character (or characters).   Another word choice could've been   *duplicated character*,   but that\nmight have ruled out   (to some readers)   triplicated characters   ···   or more.\n\n{This Rosetta Code task was inspired by a newly introduced   (as of around November 2019)   **PL/I**   BIF:   **collapse**.}\n\nExamples\n\nIn the following character string:\n\n```\n The better the 4-wheel drive, the further you'll be from help when ya get stuck! \n\n```\n\nOnly the 2nd   **t**,   **e**, and   **l**   are repeated characters,   indicated\nby underscores (above),   even though they (those characters) appear elsewhere in the character string.\n\nSo, after *collapsing* the string, the result would be:\n\n```\n The beter the 4-whel drive, the further you'l be from help when ya get stuck! \n\n```\n\nAnother example:\nIn the following character string:\n\n```\n headmistressship \n\n```\n\nThe \"collapsed\" string would be:\n\n```\n headmistreship \n\n```\n\nTask\n\nWrite a subroutine/function/procedure/routine···   to\nlocate   *repeated*   characters and   *collapse*   (delete)   them from the character\nstring.   The character string can be processed from either direction.\n\nShow all output here, on this page:\n\n:   * the   original string and its length\n    * the resultant string and its length\n    * the above strings should be \"bracketed\" with   **<<<**   and   **>>>**   (to delineate blanks)\n    * «««Guillemets may be used instead for \"bracketing\" for the more artistic programmers,   shown used here»»»\n\nUse (at least) the following five strings,   all strings are length seventy-two (characters, including blanks),   except\nthe 1st string:\n\n```\n string\n number\n        ╔╗\n   1    ║╚═══════════════════════════════════════════════════════════════════════╗   ◄■■■■■■  a null string  (length zero)\n   2    ║\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ║\n   3    ║..1111111111111111111111111111111111111111111111111111111111111117777888║\n   4    ║I never give 'em hell, I just tell the truth, and they think it's hell. ║\n   5    ║                                                    --- Harry S Truman  ║   ◄■■■■■■  has many repeated blanks\n        ╚════════════════════════════════════════════════════════════════════════╝\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nTechnically, the task is asking for a boolean. \"Determine if a string is collapsible\" is answerable with True/False, so return a boolean as well.\n\n```\nmap {\n    my $squish = .comb.squish.join;\n    printf \"\\nLength: %2d <<<%s>>>\\nCollapsible: %s\\nLength: %2d <<<%s>>>\\n\",\n      .chars, $_, .chars != $squish.chars, $squish.chars, $squish\n}, lines\n \nq:to/STRINGS/;\n    \n    \"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln \n    ..1111111111111111111111111111111111111111111111111111111111111117777888\n    I never give 'em hell, I just tell the truth, and they think it's hell. \n                                                        --- Harry S Truman  \n    The American people have a right to know if their president is a crook. \n                                                        --- Richard Nixon   \n    AАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑ\n    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n    STRINGS\n\n```\n\nOutput:\n\n```\nLength:  0 <<<>>>\nCollapsible: False\nLength:  0 <<<>>>\n\nLength: 72 <<<\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln >>>\nCollapsible: True\nLength: 70 <<<\"If I were two-faced, would I be wearing this one?\" - Abraham Lincoln >>>\n\nLength: 72 <<<..1111111111111111111111111111111111111111111111111111111111111117777888>>>\nCollapsible: True\nLength:  4 <<<.178>>>\n\nLength: 72 <<<I never give 'em hell, I just tell the truth, and they think it's hell. >>>\nCollapsible: True\nLength: 69 <<<I never give 'em hel, I just tel the truth, and they think it's hel. >>>\n\nLength: 72 <<<                                                    --- Harry S Truman  >>>\nCollapsible: True\nLength: 17 <<< - Hary S Truman >>>\n\nLength: 72 <<<The American people have a right to know if their president is a crook. >>>\nCollapsible: True\nLength: 71 <<<The American people have a right to know if their president is a crok. >>>\n\nLength: 72 <<<                                                    --- Richard Nixon   >>>\nCollapsible: True\nLength: 17 <<< - Richard Nixon >>>\n\nLength: 72 <<<AАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑ>>>\nCollapsible: False\nLength: 72 <<<AАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑ>>>\n\nLength: 72 <<<AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA>>>\nCollapsible: True\nLength:  1 <<<A>>>\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a boolean function which takes in a string and tells whether it is a numeric string (floating point and negative numbers included) in the syntax the language uses for numeric literals or numbers converted from strings.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.11\n\nRaku tries very hard to DWIM (do what I mean). As part of that, numeric strings are by default stored as allomorphic types which can be used as numbers or strings without any conversion. If we truly want to operate on strings, we have to explicitly coerce the allomorphs to strings. A subtlety that may not be immediately apparent, whitespace, empty strings and null strings may be treated as (False) boolean values in Raku, however booleans are allomorphic to numeric, so empty strings will coerce to a numeric value (0), and return as numeric unless specifically checked for. Interestingly, the actual strings 'True' and 'False' **don't** evaluate as numeric. (because there are no String | Boolean allomorphs.)\n\nNote: These routines are usable for most cases but won't detect unicode non-digit numeric forms; E.G. vulgar fractions, Roman numerals, circled numbers, etc. If it is necessary to detect those as numeric, a full fledged grammar may be necessary.\n\n```\nsub is-number-w-ws( Str $term --> Bool ) { # treat Falsey strings as numeric\n    $term.Numeric !~~ Failure;\n}\n\nsub is-number-wo-ws( Str $term --> Bool ) { # treat Falsey strings as non-numeric\n    ?($term ~~ / \\S /) && $term.Numeric !~~ Failure;\n}\n\nsay \"               Coerce     Don't coerce\";\nsay '    String   whitespace    whitespace';\nprintf \"%10s  %8s  %11s\\n\",\n\"<$_>\", .&is-number-w-ws, .&is-number-wo-ws for\n(|<1 1.2 1.2.3 -6 1/2 12e B17 1.3e+12 1.3e12 -2.6e-3 zero 0x 0xA10 0b1001 0o16 \n0o18 2+5i True False Inf NaN 0x10.50 0b102 0o_5_3 ௫௯>, '  12  ', '1 1 1', '', ' ' ).map: *.Str;\n```\n\n```\n               Coerce     Don't coerce\n    String   whitespace    whitespace\n       <1>      True         True\n     <1.2>      True         True\n   <1.2.3>     False        False\n      <-6>      True         True\n     <1/2>      True         True\n     <12e>     False        False\n     <B17>     False        False\n <1.3e+12>      True         True\n  <1.3e12>      True         True\n <-2.6e-3>      True         True\n    <zero>     False        False\n      <0x>     False        False\n   <0xA10>      True         True\n  <0b1001>      True         True\n    <0o16>      True         True\n    <0o18>     False        False\n    <2+5i>      True         True\n    <True>     False        False\n   <False>     False        False\n     <Inf>      True         True\n     <NaN>      True         True\n <0x10.50>      True         True\n   <0b102>     False        False\n  <0o_5_3>      True         True\n      <௫௯>      True         True\n <   12  >      True         True\n   <1 1 1>     False        False\n        <>      True        False\n       < >      True        False\n```"}]}
{"messages": [{"role": "user", "content": "Determine if a character string is   *squeezable*.\n\nAnd if so,   squeeze the string   (by removing any number of\na   *specified*   *immediately repeated*   character).\n\nThis task is very similar to the task     **Determine if a character string is collapsible**     except\nthat only a specified character is   *squeezed*   instead of any character that is *immediately repeated*.\n\nIf a character string has a specified   *immediately repeated*   character(s),   the repeated characters are to be\ndeleted (removed),   but not the primary (1st) character(s).\n\nA specified   *immediately repeated*   character is any specified character that is   immediately  \nfollowed by an identical character (or characters).   Another word choice could've been   *duplicated*\ncharacter*,   but that might have ruled out   (to some readers)   triplicated characters   ···   or more.*\n\n{This Rosetta Code task was inspired by a newly introduced   (as of around\nNovember 2019)   **PL/I**   BIF:   **squeeze**.}\n\nExamples\n\nIn the following character string with a specified   *immediately repeated*   character of   **e**:\n\n```\n The better the 4-wheel drive, the further you'll be from help when ya get stuck! \n\n```\n\nOnly the 2nd   **e**   is an specified repeated character,   indicated by an underscore\n(above),   even though they (the characters) appear elsewhere in the character string.\n\nSo, after *squeezing* the string, the result would be:\n\n```\n The better the 4-whel drive, the further you'll be from help when ya get stuck! \n\n```\n\nAnother example:\nIn the following character string,   using a specified immediately repeated character   **s**:\n\n```\n headmistressship \n\n```\n\nThe \"squeezed\" string would be:\n\n```\n headmistreship \n\n```\n\nTask\n\nWrite a subroutine/function/procedure/routine···   to locate a   *specified immediately repeated*   character\nand   *squeeze*   (delete)   them from the character string.   The\ncharacter string can be processed from either direction.\n\nShow all output here, on this page:\n\n:   * the   specified repeated character   (to be searched for and possibly *squeezed*):\n    * the   original string and its length\n    * the resultant string and its length\n    * the above strings should be \"bracketed\" with   **<<<**   and   **>>>**   (to delineate blanks)\n    * «««Guillemets may be used instead for \"bracketing\" for the more artistic programmers,   shown used here»»»\n\nUse (at least) the following five strings,   all strings are length seventy-two (characters, including blanks),   except\nthe 1st string:\n\n```\n                                                                                  immediately\n string                                                                            repeated\n number                                                                            character\n                                                                                     ( ↓   a blank,  a minus,  a seven,  a period)\n        ╔╗\n   1    ║╚═══════════════════════════════════════════════════════════════════════╗    ' '    ◄■■■■■■  a null string  (length zero)\n   2    ║\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ║    '-'\n   3    ║..1111111111111111111111111111111111111111111111111111111111111117777888║    '7'\n   4    ║I never give 'em hell, I just tell the truth, and they think it's hell. ║    '.'\n   5    ║                                                    --- Harry S Truman  ║  (below)  ◄■■■■■■  has many repeated blanks\n        ╚════════════════════════════════════════════════════════════════════════╝     ↑\n                                                                                       │\n                                                                                       │\n        For the 5th string  (Truman's signature line),  use each of these  specified immediately  repeated characters:\n                                  •  a blank\n                                  •  a minus\n                                  •  a lowercase  r\n\n```\n\nNote:   there should be seven results shown,   one each for the 1st four strings,   and three results for\nthe 5th string.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\n```\nmap {\n    my $squeeze = $^phrase;\n    sink $^reg;\n    $squeeze ~~ s:g/($reg)$0+/$0/;\n    printf \"\\nOriginal length: %d <<<%s>>>\\nSqueezable on \\\"%s\\\": %s\\nSqueezed length: %d <<<%s>>>\\n\",\n      $phrase.chars, $phrase, $reg.uniname, $phrase ne $squeeze, $squeeze.chars, $squeeze\n},  \n  '', ' ', \n  '\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ', '-',\n  '..1111111111111111111111111111111111111111111111111111111111111117777888', '7',\n  \"I never give 'em hell, I just tell the truth, and they think it's hell. \", '.',\n  '                                                    --- Harry S Truman  ', ' ',\n  '                                                    --- Harry S Truman  ', '-',\n  '                                                    --- Harry S Truman  ', 'r'\n\n```\n\nOutput:\n\n```\nOriginal length: 0 <<<>>>\nSqueezable on \"SPACE\": False\nSqueezed length: 0 <<<>>>\n\nOriginal length: 72 <<<\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln >>>\nSqueezable on \"HYPHEN-MINUS\": True\nSqueezed length: 70 <<<\"If I were two-faced, would I be wearing this one?\" - Abraham Lincoln >>>\n\nOriginal length: 72 <<<..1111111111111111111111111111111111111111111111111111111111111117777888>>>\nSqueezable on \"DIGIT SEVEN\": True\nSqueezed length: 69 <<<..1111111111111111111111111111111111111111111111111111111111111117888>>>\n\nOriginal length: 72 <<<I never give 'em hell, I just tell the truth, and they think it's hell. >>>\nSqueezable on \"FULL STOP\": False\nSqueezed length: 72 <<<I never give 'em hell, I just tell the truth, and they think it's hell. >>>\n\nOriginal length: 72 <<<                                                    --- Harry S Truman  >>>\nSqueezable on \"SPACE\": True\nSqueezed length: 20 <<< --- Harry S Truman >>>\n\nOriginal length: 72 <<<                                                    --- Harry S Truman  >>>\nSqueezable on \"HYPHEN-MINUS\": True\nSqueezed length: 70 <<<                                                    - Harry S Truman  >>>\n\nOriginal length: 72 <<<                                                    --- Harry S Truman  >>>\nSqueezable on \"LATIN SMALL LETTER R\": True\nSqueezed length: 71 <<<                                                    --- Hary S Truman  >>>\n\n```"}]}
{"messages": [{"role": "user", "content": "This task is to determine if there is only one instance of an application running. If the program discovers that an instance of it is already running, then it should display a message indicating that it is already running and exit."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\nAn old-school Unix solution, none the worse for the wear:\n\n```\nmy $name = $*PROGRAM-NAME;\nmy $pid = $*PID;\n\nmy $lockdir = \"/tmp\";\nmy $lockfile = \"$lockdir/$name.pid\";\nmy $lockpid = \"$lockfile$pid\";\nmy $havelock = False;\n\nEND {\n    unlink $lockfile if $havelock;\n    try unlink $lockpid;\n}\n\nmy $pidfile = open \"$lockpid\", :w orelse .die;\n$pidfile.say($pid);\n$pidfile.close;\n\nif try link($lockpid, $lockfile) {\n    $havelock = True;\n}\nelse {\n    shell \"kill -CONT `cat $lockfile` || rm $lockfile\";\n    if try link($lockfile, $lockpid) {\n        $havelock = True;\n    }\n    else {\n        die \"You can't run right now!\";\n    }\n}\nnote \"Got lock!\";\nunlink $lockpid;\n\n```"}]}
{"messages": [{"role": "user", "content": "Determining if two triangles in the same plane overlap is an important topic in collision detection.\n\nTask\n\nDetermine which of these pairs of triangles overlap in 2D:\n\n:   :   :   * (0,0),(5,0),(0,5)     and   (0,0),(5,0),(0,6)\n            * (0,0),(0,5),(5,0)     and   (0,0),(0,5),(5,0)\n            * (0,0),(5,0),(0,5)     and   (-10,0),(-5,0),(-1,6)\n            * (0,0),(5,0),(2.5,5)   and   (0,4),(2.5,-1),(5,4)\n            * (0,0),(1,1),(0,2)     and   (2,1),(3,0),(3,2)\n            * (0,0),(1,1),(0,2)     and   (2,1),(3,-2),(3,4)\n\nOptionally, see what the result is when only a single corner is in contact (there is no definitive correct answer):\n\n:   :   :   * (0,0),(1,0),(0,1)   and   (1,0),(2,0),(1,1)\n\nRelated tasks\n\n* Check if two polygons overlap\n* Check if a polygon overlaps with a rectangle"}, {"role": "assistant", "content": "(formerly Perl 6)\nFirst, check if any vertex is inside each other triangle (that should cover most overlapping cases including enclosures). Then see if an edge of triangle A intersects any of two edges of B (for shapes like Star of David [1])\n\n```\n# Reference:\n# https://stackoverflow.com/questions/2049582/how-to-determine-if-a-point-is-in-a-2d-triangle\n# https://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/\n\nsub if-overlap ($triangle-pair) {\n   my (\\A,\\B) = $triangle-pair;\n   my Bool $result = False;\n\n   sub sign (\\T) {\n      return (T[0;0] - T[2;0]) × (T[1;1] - T[2;1]) -\n             (T[1;0] - T[2;0]) × (T[0;1] - T[2;1]);\n   }\n\n   sub point-in-triangle (\\pt, \\Y --> Bool) {\n      my $d1 = sign (pt, Y[0], Y[1]);\n      my $d2 = sign (pt, Y[1], Y[2]);\n      my $d3 = sign (pt, Y[2], Y[0]);\n\n      my $has_neg = [or] $d1 < 0, $d2 < 0, $d3 < 0;\n      my $has_pos = [or] $d1 > 0, $d2 > 0, $d3 > 0;\n\n      return not ($has_neg and $has_pos);\n   }\n\n   sub orientation(\\P, \\Q, \\R --> Int) {\n      my \\val = (Q[1] - P[1]) × (R[0] - Q[0]) -\n                (Q[0] - P[0]) × (R[1] - Q[1]);\n\n      return 0 if val == 0;     # colinear\n      return val > 0 ?? 1 !! 2; # clock or counterclock wise\n   }\n\n   sub onSegment(\\P, \\Q, \\R --> Bool) {\n      Q[0] ≤ max(P[0], R[0]) and Q[0] ≥ min(P[0], R[0]) and\n      Q[1] ≤ max(P[1], R[1]) and Q[1] ≥ min(P[0], R[1])\n         ?? True !! False\n   }\n\n   sub intersect(\\A,\\B,\\C,\\D --> Bool) {\n      my \\o1 = orientation A, C, D;\n      my \\o2 = orientation B, C, D;\n      my \\o3 = orientation A, B, C;\n      my \\o4 = orientation A, B, D;\n\n         o1 != o2 and o3 != o4\n      or o1 ==  0 and onSegment A, C, D\n      or o2 ==  0 and onSegment B, C, D\n      or o3 ==  0 and onSegment A, B, C\n      or o4 ==  0 and onSegment A, B, D\n         ?? True !! False\n   }\n\n   for ^3 {\n      { $result = True; last } if\n          point-in-triangle A.[$^i], B or\n          point-in-triangle B.[$^i], A ;\n   }\n\n   unless $result {\n      $result = True if\n          intersect A.[0], A.[1], B.[0], B.[1] or\n          intersect A.[0], A.[1], B.[0], B.[2]\n   }\n\n   say \"{A.gist} and {B.gist} do{' NOT' unless $result} overlap.\";\n}\n\nmy \\DATA = [\n   [ [(0,0),(5,0),(0,5)]   ,  [(0,0),(5,0),(0,6)]     ],\n   [ [(0,0),(0,5),(5,0)]   ,  [(0,0),(0,5),(5,0)]     ],\n   [ [(0,0),(5,0),(0,5)]   ,  [(-10,0),(-5,0),(-1,6)] ],\n   [ [(0,0),(5,0),(2.5,5)] ,  [ (0,4),(2.5,-1),(5,4)] ],\n   [ [(0,0),(1,1),(0,2)]   ,  [(2,1),(3,0),(3,2)]     ],\n   [ [(0,0),(1,1),(0,2)]   ,  [(2,1),(3,-2),(3,4)]    ],\n   [ [(0,0),(1,0),(0,1)]   ,  [(1,0),(2,0),(1,1)]     ]\n];\n\nif-overlap $_ for DATA ;\n\n```\n\nOutput:\n\n```\n[(0 0) (5 0) (0 5)] and [(0 0) (5 0) (0 6)] do overlap.\n[(0 0) (0 5) (5 0)] and [(0 0) (0 5) (5 0)] do overlap.\n[(0 0) (5 0) (0 5)] and [(-10 0) (-5 0) (-1 6)] do NOT overlap.\n[(0 0) (5 0) (2.5 5)] and [(0 4) (2.5 -1) (5 4)] do overlap.\n[(0 0) (1 1) (0 2)] and [(2 1) (3 0) (3 2)] do NOT overlap.\n[(0 0) (1 1) (0 2)] and [(2 1) (3 -2) (3 4)] do NOT overlap.\n[(0 0) (1 0) (0 1)] and [(1 0) (2 0) (1 1)] do overlap.\n```"}]}
{"messages": [{"role": "user", "content": "Use these sentences:\n\"hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it”\n\nTask\n:   Search for the last used punctuation in a sentence, and determine its type according to its punctuation.\n\nOutput one of these letters\n:   \"E\" (Exclamation!), \"Q\" (Question?), \"S\" (Serious.), \"N\" (Neutral).\n\nExtra\n:   Make your code able to determine multiple sentences.\n\nDon't leave any errors!\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Sentence;\n\nmy $paragraph = q:to/PARAGRAPH/;\nhi there, how are you today? I'd like to present to you the washing machine\n9001. You have been nominated to win one of these! Just make sure you don't\nbreak it\n\n\nJust because there are punctuation characters like \"?\", \"!\" or especially \".\"\npresent, it doesn't necessarily mean you have reached the end of a sentence,\ndoes it Mr. Magoo? The syntax highlighting here for Raku isn't the best.\nPARAGRAPH\n\nsay join \"\\n\\n\", $paragraph.&sentences.map: {\n    /(<:punct>)$/;\n    $_ ~ ' | ' ~ do\n    given $0 {\n        when '!' { 'E' };\n        when '?' { 'Q' };\n        when '.' { 'S' };\n        default  { 'N' };\n    }\n}\n\n```\n\nOutput:\n\n```\nhi there, how are you today? | Q\n\nI'd like to present to you the washing machine\n9001. | S\n\nYou have been nominated to win one of these! | E\n\nJust make sure you don't\nbreak it | N\n\nJust because there are punctuation characters like \"?\", \"!\" or especially \".\"\npresent, it doesn't necessarily mean you have reached the end of a sentence,\ndoes it Mr. Magoo? | Q\n\nThe syntax highlighting here for Raku isn't the best. | S\n```"}]}
{"messages": [{"role": "user", "content": "Two players have a set of dice each. The first player has nine dice with four faces each, with numbers one to four. The second player has six normal dice with six faces each, each face has the usual numbers from one to six.\n\nThey roll their dice and sum the totals of the faces. The player with the highest total wins (it's a draw if the totals are the same). What's the probability of the first player beating the second player?\n\nLater the two players use a different set of dice each. Now the first player has five dice with ten faces each, and the second player has six dice with seven faces each. Now what's the probability of the first player beating the second player?\n\nThis task was adapted from the Project Euler Problem n.205:\nhttps://projecteuler.net/problem=205"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\n```\nsub likelihoods ($roll) {\n    my ($dice, $faces) = $roll.comb(/\\d+/);\n    my @counts;\n    @counts[$_]++ for [X+] |(1..$faces,) xx $dice;\n    return [@counts[]:p], $faces ** $dice;\n}\n \nsub beating-probability ([$roll1, $roll2]) {\n    my (@c1, $p1) := likelihoods $roll1;\n    my (@c2, $p2) := likelihoods $roll2;\n    my $p12 = $p1 * $p2;\n \n    [+] gather for flat @c1 X @c2 -> $p, $q {\n\ttake $p.value * $q.value / $p12 if $p.key > $q.key;\n    }\n}\n\n# We're using standard DnD notation for dice rolls here.\nsay .gist, \"\\t\", .raku given beating-probability < 9d4 6d6 >;\nsay .gist, \"\\t\", .raku given beating-probability < 5d10 6d7 >;\n\n```\n\nOutput:\n\n```\n0.573144077\t<48679795/84934656>\n0.64278862872\t<3781171969/5882450000>\n```\n\nNote that all calculations are in integer and rational arithmetic, so the results in fractional notation are exact."}]}
{"messages": [{"role": "user", "content": "Task\n\nTask desciption is taken from Project Euler (https://projecteuler.net/problem=30)\n  \nFind the sum of all the numbers that can be written as the sum of fifth powers of their digits.\n\nEven though 15 = 1, it is not expressed as a *sum* (a sum being the summation of a list of two or more numbers), and is therefore not included."}, {"role": "assistant", "content": "```\nprint q:to/EXPANATION/;\nSum of all integers (except 1 for some mysterious reason ¯\\_(ツ)_/¯),\nfor which the individual digits to the nth power sum to itself.\nEXPANATION\n\nsub super($i) { $i.trans('0123456789' => '⁰¹²³⁴⁵⁶⁷⁸⁹') }\n\nfor 3..8 -> $power {\n    print \"\\nSum of powers of n{super $power}: \";\n    my $threshold = 9**$power * $power;\n    put .join(' + '), ' = ', .sum with cache\n    (2..$threshold).hyper.map: {\n        state %p = ^10 .map: { $_ => $_ ** $power };\n        $_ if %p{.comb}.sum == $_\n    }\n}\n\n```\n\nOutput:\n\n```\nSum of all integers (except 1 for some mysterious reason ¯\\_(ツ)_/¯),\nfor which the individual digits to the nth power sum to itself.\n\nSum of powers of n³: 153 + 370 + 371 + 407 = 1301\n\nSum of powers of n⁴: 1634 + 8208 + 9474 = 19316\n\nSum of powers of n⁵: 4150 + 4151 + 54748 + 92727 + 93084 + 194979 = 443839\n\nSum of powers of n⁶: 548834 = 548834\n\nSum of powers of n⁷: 1741725 + 4210818 + 9800817 + 9926315 + 14459929 = 40139604\n\nSum of powers of n⁸: 24678050 + 24678051 + 88593477 = 137949578\n```"}]}
{"messages": [{"role": "user", "content": "The digital root, \n\nX\n{\\displaystyle {\\displaystyle X}}\n, of a number, \n\nn\n{\\displaystyle {\\displaystyle n}}\n, is calculated:\n\n:   find \n\n    X\n    {\\displaystyle {\\displaystyle X}}\n     as the sum of the digits of \n\n    n\n    {\\displaystyle {\\displaystyle n}}\n:   find a new \n\n    X\n    {\\displaystyle {\\displaystyle X}}\n     by summing the digits of \n\n    X\n    {\\displaystyle {\\displaystyle X}}\n    , repeating until \n\n    X\n    {\\displaystyle {\\displaystyle X}}\n     has only one digit.\n\nThe additive persistence is the number of summations required to obtain the single digit.\n\nThe task is to calculate the additive persistence and the digital root of a number, e.g.:\n\n:   627615\n    {\\displaystyle {\\displaystyle 627615}}\n     has additive persistence \n\n    2\n    {\\displaystyle {\\displaystyle 2}}\n     and digital root of \n\n    9\n    {\\displaystyle {\\displaystyle 9}}\n    ;\n:   39390\n    {\\displaystyle {\\displaystyle 39390}}\n     has additive persistence \n\n    2\n    {\\displaystyle {\\displaystyle 2}}\n     and digital root of \n\n    6\n    {\\displaystyle {\\displaystyle 6}}\n    ;\n:   588225\n    {\\displaystyle {\\displaystyle 588225}}\n     has additive persistence \n\n    2\n    {\\displaystyle {\\displaystyle 2}}\n     and digital root of \n\n    3\n    {\\displaystyle {\\displaystyle 3}}\n    ;\n:   393900588225\n    {\\displaystyle {\\displaystyle 393900588225}}\n     has additive persistence \n\n    2\n    {\\displaystyle {\\displaystyle 2}}\n     and digital root of \n\n    9\n    {\\displaystyle {\\displaystyle 9}}\n    ;\n\nThe digital root may be calculated in bases other than 10.\n\nSee\n\n* Casting out nines for this wiki's use of this procedure.\n* Digital root/Multiplicative digital root\n* Sum digits of an integer\n* Digital root sequence on OEIS\n* Additive persistence sequence on OEIS\n* Iterated digits squaring"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub digital-root ($r, :$base = 10) {\n    my $root = $r.base($base);\n    my $persistence = 0;\n    while $root.chars > 1 {\n        $root = $root.comb.map({:36($_)}).sum.base($base);\n        $persistence++;\n    }\n    $root, $persistence;\n}\n\nmy @testnums =\n    627615,\n    39390,\n    588225,\n    393900588225,\n    58142718981673030403681039458302204471300738980834668522257090844071443085937;\n\nfor 10, 8, 16, 36 -> $b {\n    for @testnums -> $n {\n        printf \":$b\\<%s>\\ndigital root %s, persistence %s\\n\\n\",\n            $n.base($b), digital-root $n, :base($b);\n    }\n}\n\n```\n\nOutput:\n\n```\n:10<627615>\ndigital root 9, persistence 2\n\n:10<39390>\ndigital root 6, persistence 2\n\n:10<588225>\ndigital root 3, persistence 2\n\n:10<393900588225>\ndigital root 9, persistence 2\n\n:10<58142718981673030403681039458302204471300738980834668522257090844071443085937>\ndigital root 4, persistence 3\n\n:8<2311637>\ndigital root 2, persistence 3\n\n:8<114736>\ndigital root 1, persistence 3\n\n:8<2174701>\ndigital root 1, persistence 3\n\n:8<5566623376301>\ndigital root 4, persistence 3\n\n:8<10021347156245115014463623107370014314341751427033746320331121536631531505161175135161>\ndigital root 3, persistence 3\n\n:16<9939F>\ndigital root F, persistence 2\n\n:16<99DE>\ndigital root F, persistence 2\n\n:16<8F9C1>\ndigital root F, persistence 2\n\n:16<5BB64DFCC1>\ndigital root F, persistence 2\n\n:16<808B9CDCA526832679323BE018CC70FA62E1BF3341B251AF666B345389F4BA71>\ndigital root 7, persistence 3\n\n:36<DG9R>\ndigital root U, persistence 2\n\n:36<UE6>\ndigital root F, persistence 2\n\n:36<CLVL>\ndigital root F, persistence 2\n\n:36<50YE8N29>\ndigital root P, persistence 2\n\n:36<37C71GOYNYJ25M3JTQQVR0FXUK0W9QM71C1LVNCBWNRVNOJYPD>\ndigital root H, persistence 3\n```\n\nOr if you are more inclined to the functional programming persuasion, you can use the … sequence operator to calculate the values without side effects:\n\n```\nsub digital-root ($r, :$base = 10) {\n    my &sum = { .comb.map({:36($_)}).sum.base($base) }\n\n    return .[*-1], .elems-1\n        given $r.base($base), &sum … { .chars == 1 }\n}\n\n```\n\nOutput same as above."}]}
{"messages": [{"role": "user", "content": "The multiplicative digital root (MDR) and multiplicative persistence (MP) of a number, \n\nn\n{\\displaystyle {\\displaystyle n}}\n, is calculated rather like the Digital root except digits are multiplied instead of being added:\n\n1. Set \n\n   m\n   {\\displaystyle {\\displaystyle m}}\n    to \n\n   n\n   {\\displaystyle {\\displaystyle n}}\n    and \n\n   i\n   {\\displaystyle {\\displaystyle i}}\n    to \n\n   0\n   {\\displaystyle {\\displaystyle 0}}\n   .\n2. While \n\n   m\n   {\\displaystyle {\\displaystyle m}}\n    has more than one digit:\n   * Find a replacement \n\n     m\n     {\\displaystyle {\\displaystyle m}}\n      as the multiplication of the digits of the current value of \n\n     m\n     {\\displaystyle {\\displaystyle m}}\n     .\n   * Increment \n\n     i\n     {\\displaystyle {\\displaystyle i}}\n     .\n3. Return \n\n   i\n   {\\displaystyle {\\displaystyle i}}\n    (= MP) and \n\n   m\n   {\\displaystyle {\\displaystyle m}}\n    (= MDR)\n\nTask\n\n* Tabulate the MP and MDR of the numbers 123321, 7739, 893, 899998\n* Tabulate MDR versus the first five numbers having that MDR, something like:\n\n```\nMDR: [n0..n4]\n===  ========\n  0: [0, 10, 20, 25, 30]\n  1: [1, 11, 111, 1111, 11111]\n  2: [2, 12, 21, 26, 34]\n  3: [3, 13, 31, 113, 131]\n  4: [4, 14, 22, 27, 39]\n  5: [5, 15, 35, 51, 53]\n  6: [6, 16, 23, 28, 32]\n  7: [7, 17, 71, 117, 171]\n  8: [8, 18, 24, 29, 36]\n  9: [9, 19, 33, 91, 119]\n\n```\n\nShow all output on this page.\n\nSimilar\n\nThe Product of decimal digits of n page was redirected here, and had the following description\n\n```\nFind the product of the decimal digits of a positive integer   n,   where n <= 100\n\n```\n\nThe three existing entries for Phix, REXX, and Ring have been moved here, under ===Similar=== headings, feel free to match or ignore them.\n\nReferences\n\n* Multiplicative Digital Root on Wolfram Mathworld.\n* Multiplicative digital root on The On-Line Encyclopedia of Integer Sequences.\n* What's special about 277777788888899? - Numberphile video"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub multiplicative-digital-root(Int $n) {\n    return .elems - 1, .[.end]\n        given cache($n, {[*] .comb} ... *.chars == 1)\n}\n\nfor 123321, 7739, 893, 899998 {\n    say \"$_: \", .&multiplicative-digital-root;\n}\n\nfor ^10 -> $d {\n    say \"$d : \", .[^5]\n        given (1..*).grep: *.&multiplicative-digital-root[1] == $d;\n}\n\n```\n\nOutput:\n\n```\n123321: 3 8\n7739: 3 8\n893: 3 2\n899998: 2 0\n0 : 10 20 25 30 40\n1 : 1 11 111 1111 11111\n2 : 2 12 21 26 34\n3 : 3 13 31 113 131\n4 : 4 14 22 27 39\n5 : 5 15 35 51 53\n6 : 6 16 23 28 32\n7 : 7 17 71 117 171\n8 : 8 18 24 29 36\n9 : 9 19 33 91 119\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\n**Dijkstra's algorithm**, conceived by Dutch computer scientist Edsger Dijkstra in 1956 and published in 1959, is a graph search algorithm that solves the single-source shortest path problem for a graph with non-negative edge path costs, producing a shortest path tree.\n\nThis algorithm is often used in routing and as a subroutine in other graph algorithms.\n\nFor a given source vertex (node) in the graph, the algorithm finds the path with lowest cost (i.e. the shortest path) between that vertex and every other vertex.\n\nFor instance\n\nIf the vertices of the graph represent cities and edge path costs represent driving distances between pairs of cities connected by a direct road,   Dijkstra's algorithm can be used to find the shortest route between one city and all other cities.\n\nAs a result, the shortest path first is widely used in network routing protocols, most notably:\n\n:   :   * IS-IS   (Intermediate System to Intermediate System)   and\n        * OSPF   (Open Shortest Path First).\n\nImportant note\n\nThe inputs to Dijkstra's algorithm are a directed and weighted graph consisting of **2** or more nodes, generally represented by:\n\n:   :   * an adjacency matrix or list,   and\n        * a start node.\n\nA destination node is not specified.\n\nThe output is a set of edges depicting the shortest path to each destination node.\n\nAn example, starting with\n\n```\n                                         a──►b,  cost=7,   lastNode=a  \n                                         a──►c,  cost=9,   lastNode=a \n                                         a──►d,  cost=NA,  lastNode=a\n                                         a──►e,  cost=NA,  lastNode=a \n                                         a──►f,  cost=14,  lastNode=a\n\n    The lowest cost is    a──►b    so    a──►b    is added to the output. \n\n    There is a connection from   b──►d   so the input is updated to: \n                                         a──►c,  cost=9,   lastNode=a \n                                         a──►d,  cost=22,  lastNode=b \n                                         a──►e,  cost=NA,  lastNode=a \n                                         a──►f,  cost=14,  lastNode=a\n\n    The lowest cost is    a──►c    so    a──►c    is added to the output. \n\n    Paths to    d    and    f    are cheaper via    c    so the input is updated to:\n                                         a──►d,  cost=20,  lastNode=c \n                                         a──►e,  cost=NA,  lastNode=a \n                                         a──►f,  cost=11,  lastNode=c\n\n    The lowest cost is    a──►f    so    c──►f    is added to the output. \n\n    The input is updated to:\n                                         a──►d,  cost=20,  lastNode=c \n                                         a──►e,  cost=NA,  lastNode=a\n\n    The lowest cost is    a──►d    so    c──►d    is added to the output. \n\n    There is a connection from    d──►e    so the input is updated to:\n                                         a──►e,  cost=26,  lastNode=d\n\n    Which just leaves adding    d──►e    to the output.\n\n    The output should now be:\n                                       [ d──►e\n                                         c──►d\n                                         c──►f\n                                         a──►c\n                                         a──►b ]\n\n```\n\nTask\n\n1. Implement a version of Dijkstra's algorithm that outputs a set of edges depicting the shortest path to each reachable node from an origin.\n2. Run your program with the following directed graph starting at node    **a**.\n3. Write a program which interprets the output from the above and use it to output the shortest path from node    **a**    to nodes    **e**    and  **f**.\n\n:   :   :   :   :   :   :   :   :   Vertices\n\n                                    | Number | Name |\n                                    | --- | --- |\n                                    | 1 | a |\n                                    | 2 | b |\n                                    | 3 | c |\n                                    | 4 | d |\n                                    | 5 | e |\n                                    | 6 | f |\n\nEdges\n\n| Start | End | Cost |\n| --- | --- | --- |\n| a | b | 7 |\n| a | c | 9 |\n| a | f | 14 |\n| b | c | 10 |\n| b | d | 15 |\n| c | d | 11 |\n| c | f | 2 |\n| d | e | 6 |\n| e | f | 9 |\n\nYou can use numbers or names to identify vertices in your program.\n\nSee also\n\n* Dijkstra's Algorithm vs. A\\* Search vs. Concurrent Dijkstra's Algorithm (youtube)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nclass Graph {\n  has (%.edges, %.nodes);\n\n  method new(*@args){\n    my (%edges, %nodes);\n    for @args {\n      %edges{.[0] ~ .[1]} = $_;\n      %nodes{.[0]}.push( .[0] ~ .[1] );\n      %nodes{.[1]}.push( .[0] ~ .[1] );\n    }\n    self.bless(edges => %edges, nodes => %nodes);\n  }\n\n  method neighbours ($source) {\n    my (%neighbours, $edges);\n    $edges = self.nodes{$source};\n    for @$edges -> $x {\n      for self.edges{$x}[0..1] -> $y {\n        if $y ne $source {\n          %neighbours{$y} = self.edges{$x}\n        }\n      }\n    }\n    return %neighbours\n  }\n\n  method dijkstra ($source, $dest) {\n    my (%node_data, $v, $u);\n    my @q = self.nodes.keys;\n\n    for self.nodes.keys {\n      %node_data{$_}{'dist'} = Inf;\n      %node_data{$_}{'prev'} = '';\n    }\n    %node_data{$source}{'dist'} = 0;\n\n    while @q {\n      # %node_data.perl.say;\n      my ($mindist, $idx) =\n        @((map {[%node_data{@q[$_]}{'dist'},$_]},^@q).min(*[0]));\n      $u = @q[$idx];\n\n      if $mindist eq Inf {\n        return ()\n      }\n      elsif $u eq $dest {\n        my @s;\n        while %node_data{$u}{'prev'} {\n          @s.unshift($u);\n          $u = %node_data{$u}{'prev'}\n        }\n        @s.unshift($source);\n        return @s;\n      }\n      else {\n        @q.splice($idx,1);\n      }\n\n      for self.neighbours($u).kv -> $v, $edge {\n        my $alt = %node_data{$u}{'dist'} + $edge[2];\n        if $alt < %node_data{$v}{'dist'} {\n          %node_data{$v}{'dist'} = $alt;\n          %node_data{$v}{'prev'} = $u\n        }\n      }\n    }\n  }\n}\n\nmy $a = Graph.new([\n  [\"a\", \"b\",  7],\n  [\"a\", \"c\",  9],\n  [\"a\", \"f\", 14],\n  [\"b\", \"c\", 10],\n  [\"b\", \"d\", 15],\n  [\"c\", \"d\", 11],\n  [\"c\", \"f\",  2],\n  [\"d\", \"e\",  6],\n  [\"e\", \"f\",  9]\n]).dijkstra('a', 'e').say;\n\n```\n\nOutput:\n\n```\n[a c f e]\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSolve Dinesman's multiple dwelling problem but in a way that most naturally follows the problem statement given below.\n\nSolutions are allowed (but not required) to parse and interpret the problem text, but should remain flexible and should state what changes to the problem text are allowed. Flexibility and ease of expression are valued.\n\nExamples may be be split into \"setup\", \"problem statement\", and \"output\" sections where the ease and naturalness of stating the problem and getting an answer, as well as the ease and flexibility of modifying the problem are the primary concerns.\n\nExample output should be shown here, as well as any comments on the examples flexibility.\n\nThe problem\n\nBaker, Cooper, Fletcher, Miller, and Smith live on different floors of an apartment house that contains only five floors.\n\n:   :   * Baker does not live on the top floor.\n        * Cooper does not live on the bottom floor.\n        * Fletcher does not live on either the top or the bottom floor.\n        * Miller lives on a higher floor than does Cooper.\n        * Smith does not live on a floor adjacent to Fletcher's.\n        * Fletcher does not live on a floor adjacent to Cooper's.\n\n*Where does everyone live?*"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### By parsing the problem\n\n**Translation of**: Perl\n\n```\nuse MONKEY-SEE-NO-EVAL;\n\nsub parse_and_solve ($text) {\n    my %ids;\n    my $expr = (grammar {\n        state $c = 0;\n        rule TOP { <fact>+ { make join ' && ', $<fact>>>.made } }\n        \n        rule fact { <name> (not)? <position>\n                    { make sprintf $<position>.made.fmt($0 ??  \"!(%s)\" !! \"%s\"),\n                                   $<name>.made }\n        }\n        rule position {\n            || on bottom             { make \"\\@f[%s] == 1\"                            }\n            || on top                { make \"\\@f[%s] == +\\@f\"                         }\n            || lower than <name>     { make \"\\@f[%s] < \\@f[{$<name>.made}]\"           }\n            || higher than <name>    { make \"\\@f[%s] > \\@f[{$<name>.made}]\"           }\n            || directly below <name> { make \"\\@f[%s] == \\@f[{$<name>.made}] - 1\"      }\n            || directly above <name> { make \"\\@f[%s] == \\@f[{$<name>.made}] + 1\"      }\n            || adjacent to <name>    { make \"\\@f[%s] == \\@f[{$<name>.made}] + (-1|1)\" }\n            || on <ordinal>          { make \"\\@f[%s] == {$<ordinal>.made}\"            }\n            || { note \"Failed to parse line \" ~ +$/.prematch.comb(/^^/); exit 1; }\n        }\n        \n        token name    { :i <[a..z]>+              { make %ids{~$/} //= $c++ } }\n        token ordinal { [1st | 2nd | 3rd | \\d+th] { make +$/.match(/(\\d+)/)[0]     } }\n    }).parse($text).made;\n    \n    EVAL 'for [1..%ids.elems].permutations -> @f {\n              say %ids.kv.map({ \"$^a=@f[$^b]\" }) if (' ~ $expr ~ ');\n          }'\n}\n\nparse_and_solve Q:to/END/;\n    Baker not on top\n    Cooper not on bottom\n    Fletcher not on top\n    Fletcher not on bottom\n    Miller higher than Cooper\n    Smith not adjacent to Fletcher\n    Fletcher not adjacent to Cooper\n    END\n\n```\n\nSupports the same grammar for the problem statement, as the Perl solution.\n\nOutput:\n\n```\nBaker=3 Cooper=2 Fletcher=4 Miller=5 Smith=1\n\n```\n\n### Simple solution\n\n**Works with**: rakudo version 2015-11-15\n\n```\n# Contains only five floors. 5! = 120 permutations.\nfor (flat (1..5).permutations) -> $b, $c, $f, $m, $s {\n    say \"Baker=$b Cooper=$c Fletcher=$f Miller=$m Smith=$s\"\n        if  $b != 5         # Baker    !live  on top floor.\n        and $c != 1         # Cooper   !live  on bottom floor.\n        and $f != 1|5       # Fletcher !live  on top or the bottom floor.\n        and $m  > $c        # Miller    lives on a higher floor than Cooper.\n        and $s != $f-1|$f+1 # Smith    !live  adjacent to Fletcher\n        and $f != $c-1|$c+1 # Fletcher !live  adjacent to Cooper\n    ;\n}\n\n```\n\nAdding more people and floors requires changing the list that's being used for the permutations, adding a variable for the new person, a piece of output in the string and finally to adjust all mentions of the \"top\" floor.\nAdjusting to different rules requires changing the multi-line if statement in the loop.\n\nOutput:\n\n```\nBaker=3 Cooper=2 Fletcher=4 Miller=5 Smith=1\n```"}]}
{"messages": [{"role": "user", "content": "The dining philosophers problem illustrates non-composability of low-level synchronization primitives like semaphores. It is a modification of a problem posed by Edsger Dijkstra.\n\nFive philosophers, Aristotle, Kant, Spinoza, Marx, and Russell (the tasks) spend their time thinking and eating spaghetti. They eat at a round table with five individual seats. For eating each philosopher needs two forks (the resources). There are five forks on the table, one left and one right of each seat. When a philosopher cannot grab both forks it sits and waits. Eating takes random time, then the philosopher puts the forks down and leaves the dining room. After spending some random time thinking about the nature of the universe, he again becomes hungry, and the circle repeats itself.\n\nIt can be observed that a straightforward solution, when forks are implemented by semaphores, is exposed to deadlock. There exist two deadlock states when all five philosophers are sitting at the table holding one fork each. One deadlock state is when each philosopher has grabbed the fork left of him, and another is when each has the fork on his right.\n\nThere are many solutions of the problem, program at least one, and explain how the deadlock is prevented."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-09\n\nWe use locking mutexes for the forks, and a lollipop to keep the last person who finished eating from getting hungry until the next person finishes eating, which prevents a cycle of dependency from forming. The algorithm should scale to many philosophers, and no philosopher need be singled out to be left-handed, so it's fair in that sense.\n\n```\nclass Fork {\n    has $!lock = Lock.new;\n    method grab($who, $which) {\n\tsay \"$who grabbing $which fork\";\n\t$!lock.lock;\n    }\n    method drop($who, $which) {\n\tsay \"$who dropping $which fork\";\n\t$!lock.unlock;\n    }\n}\n \nclass Lollipop {\n    has $!channel = Channel.new;\n    method mine($who) { $!channel.send($who) }\n    method yours { $!channel.receive }\n}\n \nsub dally($sec) { sleep 0.01 + rand * $sec }\n \nsub MAIN(*@names) {\n    @names ||= <Aristotle Kant Spinoza Marx Russell>;\n \n    my @lfork = Fork.new xx @names;\n    my @rfork = @lfork.rotate;\n \n    my $lollipop = Lollipop.new;\n    start { $lollipop.yours; }\n \n    my @philosophers = do for flat @names Z @lfork Z @rfork -> $n, $l, $r {\n\tstart { \n\t    sleep 1 + rand*4;\n\t    loop {\n\t\t$l.grab($n,'left');\n\t\tdally 1;  # give opportunity for deadlock\n\t\t$r.grab($n,'right');\n\t\tsay \"$n eating\";\n\t\tdally 10;\n\t\t$l.drop($n,'left');\n\t\t$r.drop($n,'right');\n \n\t\t$lollipop.mine($n);\n\t\tsleep 1;  # lick at least once\n\t\tsay \"$n lost lollipop to $lollipop.yours(), now digesting\";\n \n\t\tdally 20;\n\t    }\n\t}\n    }\n    sink await @philosophers;\n}\n\n```\n\nOutput:\n\n```\nAristotle grabbing left fork\nAristotle grabbing right fork\nAristotle eating\nMarx grabbing left fork\nMarx grabbing right fork\nMarx eating\nSpinoza grabbing left fork\nAristotle dropping left fork\nAristotle dropping right fork\nRussell grabbing left fork\nKant grabbing left fork\nKant grabbing right fork\nSpinoza grabbing right fork\nMarx dropping left fork\nMarx dropping right fork\nAristotle lost lollipop to Marx, now digesting\nSpinoza eating\nSpinoza dropping left fork\nSpinoza dropping right fork\nKant eating\nRussell grabbing right fork\nRussell eating\nMarx lost lollipop to Spinoza, now digesting\nKant dropping left fork\nKant dropping right fork\nSpinoza lost lollipop to Kant, now digesting\nRussell dropping left fork\nRussell dropping right fork\nKant lost lollipop to Russell, now digesting\nSpinoza grabbing left fork\nSpinoza grabbing right fork\nSpinoza eating\nAristotle grabbing left fork\nAristotle grabbing right fork\nAristotle eating\nAristotle dropping left fork\nAristotle dropping right fork\nRussell lost lollipop to Aristotle, now digesting\nSpinoza dropping left fork\nSpinoza dropping right fork\nAristotle lost lollipop to Spinoza, now digesting\nRussell grabbing left fork\nMarx grabbing left fork\nRussell grabbing right fork\nRussell eating\nMarx grabbing right fork\nKant grabbing left fork\nKant grabbing right fork\nKant eating\nRussell dropping left fork\nRussell dropping right fork\nSpinoza lost lollipop to Russell, now digesting\nMarx eating\nSpinoza grabbing left fork\nKant dropping left fork\nKant dropping right fork\nRussell lost lollipop to Kant, now digesting\nSpinoza grabbing right fork\n^C\n```"}]}
{"messages": [{"role": "user", "content": "A **Disarium number** is an integer where the sum of each digit raised to the power of its position in the number, is equal to the number.\n\nE.G.\n\n**135** is a **Disarium number**:\n\n11 + 32 + 53 == 1 + 9 + 125 == 135\n\nThere are a finite number of **Disarium numbers**.\n\nTask\n\n* Find and display the first 18 **Disarium numbers**.\n\nStretch\n\n* Find and display all 20 **Disarium numbers**.\n\nSee also\n\n* Geeks for Geeks - Disarium numbers * OEIS:A032799 - Numbers n such that n equals the sum of its digits raised to the consecutive powers (1,2,3,...) * Related task: Narcissistic decimal number * Related task: Own digits power sum *Which seems to be the same task as Narcissistic decimal number...*"}, {"role": "assistant", "content": "Not an efficient algorithm. First 18 in less than 1/4 second. 19th in around 45 seconds. Pretty much unusable for the 20th.\n\n```\nmy $disarium = (^∞).hyper.map: { $_ if $_ == sum .polymod(10 xx *).reverse Z** 1..* };\n\nput $disarium[^18];\nput $disarium[18];\n\n```\n\nOutput:\n\n```\n0 1 2 3 4 5 6 7 8 9 89 135 175 518 598 1306 1676 2427\n2646798\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nConvert a given date from the   Gregorian calendar   to the   Discordian calendar."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-11-04\n\n```\nmy @seasons = << Chaos Discord Confusion Bureaucracy 'The Aftermath' >>;\nmy @days = << Sweetmorn Boomtime Pungenday Prickle-Prickle 'Setting Orange' >>;\nsub ordinal ( Int $n ) { $n ~ ( $n % 100 == 11|12|13\n    ?? 'th' !! < th st nd rd th th th th th th >[$n % 10] ) }\n\nsub ddate ( Str $ymd ) {\n    my $d = DateTime.new: \"{$ymd}T00:00:00Z\" or die;\n\n    my $yold = 'in the YOLD ' ~ $d.year + 1166;\n\n    my $day_of_year0 = $d.day-of-year - 1;\n\n    if $d.is-leap-year {\n        return \"St. Tib's Day, $yold\" if $d.month == 2 and $d.day == 29;\n        $day_of_year0-- if $day_of_year0 >= 60; # Compensate for St. Tib's Day\n    }\n\n    my $weekday    = @days[    $day_of_year0 mod  5     ];\n    my $season     = @seasons[ $day_of_year0 div 73     ];\n    my $season_day = ordinal(  $day_of_year0 mod 73 + 1 );\n\n    return \"$weekday, the $season_day day of $season $yold\";\n}\n\nsay \"$_ is {.&ddate}\" for < 2010-07-22 2012-02-28 2012-02-29 2012-03-01 >;\n\n```\n\nOutput:\n\n```\n2010-07-22 is Pungenday, the 57th day of Confusion in the YOLD 3176\n2012-02-28 is Prickle-Prickle, the 59th day of Chaos in the YOLD 3178\n2012-02-29 is St. Tib's Day, in the YOLD 3178\n2012-03-01 is Setting Orange, the 60th day of Chaos in the YOLD 3178\n\n```"}]}
{"messages": [{"role": "user", "content": "The discrete Fourier transform is a linear, invertible transformation which transforms an arbitrary sequence of complex numbers to another sequence of complex numbers of the same length. The Fast Fourier transform (FFT) is an efficient implementation of this mechanism, but one which only works for sequences which have a length which is a power of 2.\n\nThe discrete Fourier transform is a useful testing mechanism to verify the correctness of code bases which use or implement the FFT.\n\nFor this task:\n\n1. Implement the discrete fourier transform\n2. Implement the inverse fourier transform\n3. (optional) implement a cleaning mechanism to remove small errors introduced by floating point representation.\n4. Verify the correctness of your implementation using a small sequence of integers, such as 2 3 5 7 11\n\nThe fourier transform of a sequence \n\nx\n\nn\n{\\displaystyle {\\displaystyle x\\_{n}}}\n of length \n\nN\n{\\displaystyle {\\displaystyle N}}\n is given by:\n\nX\n\nn\n=\n\n∑\n\nk\n=\n0\n\nN\n−\n1\n\nx\n\nk\n⋅\n\ne\n\n−\ni\n\n2\nπ\nN\nk\nn\n{\\displaystyle {\\displaystyle X\\_{n}=\\sum \\_{k=0}^{N-1}x\\_{k}\\cdot e^{-i{\\frac {2\\pi }{N}}kn}}}\n\nThe inverse transform is given by:\n\nx\n\nn\n=\n\n\n1\nN\n\n∑\n\nk\n=\n0\n\nN\n−\n1\n\nX\n\nk\n⋅\n\ne\n\ni\n\n2\nπ\nN\nk\nn\n{\\displaystyle {\\displaystyle x\\_{n}={\\frac {1}{N}}\\sum \\_{k=0}^{N-1}X\\_{k}\\cdot e^{i{\\frac {2\\pi }{N}}kn}}}"}, {"role": "assistant", "content": "* This task could be done with a loop of maps like  \n  @X[k] = sum @x.kv.map: -> \\n, \\v { v \\* exp( -i \\* tau / N \\* k \\* n ) }  \n  , but it is a better fit for Raku's concurrent Hyper-operators.\n* In the DFT formula, *N* becomes *+@x*, the element count. We would usually omit the plus sign and get the same result from numeric context, but that gets confusing to read when mixed with hyper-ops like »\\*« .\n* The exponents of DFT and IDFT only differ from each other in the sign of *i*, and the calculation of any given elements only differ by the *k* index of the element being output, so the inner loop is cleanly shareable between DFT and IDFT.\n* Euler's constant, imaginary unit, pi, and 2pi are built-in, with ASCII and Unicode spellings: e 𝑒 i pi π tau τ .\n* $one\\_thing «op« @many\\_things vectorizes the *op* operation: 5 «+« (1,2,3) is (6,7,8) .\n* @many\\_things »op« @many\\_more\\_things distributes the *op* operation pairwise: (5,6,7) »+« (1,2,3) is (6,8,10) .\n* (list)».method applies the method to each element of the list.\n* @array.keys, when @array has e.g. 4 elements, is 0,1,2,3 .\n* $n.round($r) returns *$n* rounded to the nearest *$r*. (13/16).round(1/4) is 3/4 .\n* .narrow changes a Numeric's type to a \"narrower\" type, when no precision would be lost.  \n  8/2 is 4, but is type Rat (rational). (8/2).narrow is also 4, but type Int.\n\n```\nsub ft_inner ( @x, $k, $pos_neg_i where * == i|-i ) {\n    my @exp := ( $pos_neg_i * tau / +@x * $k ) «*« @x.keys;\n    return sum @x »*« 𝑒 «**« @exp;\n}\nsub dft   ( @x ) { return @x.keys.map: { ft_inner( @x, $_, -i )       } }\nsub idft  ( @x ) { return @x.keys.map: { ft_inner( @x, $_,  i ) / +@x } }\nsub clean ( @x ) { @x».round(1e-12)».narrow }\n\nmy @tests = ( 1, 2-i, -i, -1+2i     ),\n            ( 2,   3,  5,     7, 11 ),\n;\nfor @tests -> @x {\n    my @x_dft  =  dft(@x);\n    my @x_idft = idft(@x_dft);\n\n    say .key.fmt('%6s:'), .value.&clean.fmt('%5s', ', ') for :@x, :@x_dft, :@x_idft;\n    say '';\n    warn \"Round-trip failed\" unless ( clean(@x) Z== clean(@x_idft) ).all;\n}\n\n```\n\nOutput:\n\n```\n     x:    1,  2-1i,  0-1i, -1+2i\n x_dft:    2, -2-2i,  0-2i,  4+4i\nx_idft:    1,  2-1i,  0-1i, -1+2i\n\n     x:    2,     3,     5,     7,    11\n x_dft:   28, -3.38196601125+8.784022634946i, -5.61803398875+2.800168985749i, -5.61803398875-2.800168985749i, -3.38196601125-8.784022634946i\nx_idft:    2,     3,     5,     7,    11\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay a finite linear combination in an infinite vector basis \n\n(\n\ne\n\n1\n,\n\ne\n\n2\n,\n…\n)\n{\\displaystyle {\\displaystyle (e\\_{1},e\\_{2},\\ldots )}}\n.\n\nWrite a function that, when given a finite list of scalars \n\n(\n\nα\n\n1\n,\n\nα\n\n2\n,\n…\n)\n{\\displaystyle {\\displaystyle (\\alpha ^{1},\\alpha ^{2},\\ldots )}}\n,   \ncreates a string representing the linear combination \n\n∑\n\ni\n\nα\n\ni\n\ne\n\ni\n{\\displaystyle {\\displaystyle \\sum \\_{i}\\alpha ^{i}e\\_{i}}}\n in an explicit format often used in mathematics, that is:\n\n:   α\n\n\n    i\n\n    1\n\n    e\n\n\n    i\n\n    1\n    ±\n\n    |\n\n    α\n\n\n    i\n\n    2\n\n    |\n\n    e\n\n\n    i\n\n    2\n    ±\n\n    |\n\n    α\n\n\n    i\n\n    3\n\n    |\n\n    e\n\n\n    i\n\n    3\n    ±\n    …\n    {\\displaystyle {\\displaystyle \\alpha ^{i\\_{1}}e\\_{i\\_{1}}\\pm |\\alpha ^{i\\_{2}}|e\\_{i\\_{2}}\\pm |\\alpha ^{i\\_{3}}|e\\_{i\\_{3}}\\pm \\ldots }}\n\nwhere \n\nα\n\n\ni\n\nk\n≠\n0\n{\\displaystyle {\\displaystyle \\alpha ^{i\\_{k}}\\neq 0}}\n\nThe output must comply to the following rules:\n\n* don't show null terms, unless the whole combination is null.\n\n:   :   :   :   :   :   :   **e(1)**     is fine,     **e(1) + 0\\*e(3)**     or     **e(1) + 0**     is wrong.\n\n* don't show scalars when they are equal to one or minus one.\n\n:   :   :   :   :   :   :   **e(3)**     is fine,     **1\\*e(3)**     is wrong.\n\n* don't prefix by a minus sign if it follows a preceding term.   Instead you use subtraction.\n\n:   :   :   :   :   :   :   **e(4) - e(5)**     is fine,     **e(4) + -e(5)**     is wrong.\n\nShow here output for the following lists of scalars:\n\n```\n 1)    1,  2,  3\n 2)    0,  1,  2,  3\n 3)    1,  0,  3,  4\n 4)    1,  2,  0\n 5)    0,  0,  0\n 6)    0\n 7)    1,  1,  1\n 8)   -1, -1, -1\n 9)   -1, -2,  0, -3\n10)   -1\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub linear-combination(@coeff) {\n    (@coeff Z=> map { \"e($_)\" }, 1 .. *)\n    .grep(+*.key)\n    .map({ .key ~ '*' ~ .value })\n    .join(' + ')\n    .subst('+ -', '- ', :g)\n    .subst(/<|w>1\\*/, '', :g)\n        || '0'\n}\n \nsay linear-combination($_) for \n[1, 2, 3],\n[0, 1, 2, 3],\n[1, 0, 3, 4],\n[1, 2, 0],\n[0, 0, 0],\n[0],\n[1, 1, 1],\n[-1, -1, -1],\n[-1, -2, 0, -3],\n[-1 ]\n;\n\n```\n\nOutput:\n\n```\ne(1) + 2*e(2) + 3*e(3)\ne(2) + 2*e(3) + 3*e(4)\ne(1) + 3*e(3) + 4*e(4)\ne(1) + 2*e(2)\n0\n0\ne(1) + e(2) + e(3)\n-e(1) - e(2) - e(3)\n-e(1) - 2*e(2) - 3*e(4)\n-e(1)\n```"}]}
{"messages": [{"role": "user", "content": "|  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- |\n| Display an outline as a nested table. | | | | | | |\n| Parse the outline to a tree, | | | count the leaves descending from each node, | | and write out a table with 'colspan' values | |\n| measuring the indent of each line, | translating the indentation to a nested structure, | and padding the tree to even depth. | defining the width of a leaf as 1, | and the width of a parent node as a sum. | either as a wiki table, | or as HTML. |\n|  |  |  |  | (The sum of the widths of its children) |  |  |\n\nThe graphic representation of outlines is a staple of mind-mapping and the planning of papers, reports, and speeches.\n\nTask\n\nGiven a outline with at least 3 levels of indentation, for example:\n\n```\nDisplay an outline as a nested table.\n    Parse the outline to a tree,\n        measuring the indent of each line,\n        translating the indentation to a nested structure,\n        and padding the tree to even depth.\n    count the leaves descending from each node,\n        defining the width of a leaf as 1,\n        and the width of a parent node as a sum.\n            (The sum of the widths of its children)\n    and write out a table with 'colspan' values\n        either as a wiki table,\n        or as HTML.\n```\n\nwrite a program in your language which translates your outline into a nested table, with WikiTable or HTML colspan values attached (where needed) to parent nodes in the nested table.\n\nThe WikiTable at the top of this page was generated from the indented outline shown above, producing the following markup string:\n\n```\n{| class=\"wikitable\" style=\"text-align: center;\"\n|-\n| style=\"background: #ffffe6; \" colspan=7 | Display an outline as a nested table.\n|-\n| style=\"background: #ffebd2; \" colspan=3 | Parse the outline to a tree,\n| style=\"background: #f0fff0; \" colspan=2 | count the leaves descending from each node,\n| style=\"background: #e6ffff; \" colspan=2 | and write out a table with 'colspan' values\n|-\n| style=\"background: #ffebd2; \" | measuring the indent of each line,\n| style=\"background: #ffebd2; \" | translating the indentation to a nested structure,\n| style=\"background: #ffebd2; \" | and padding the tree to even depth.\n| style=\"background: #f0fff0; \" | defining the width of a leaf as 1,\n| style=\"background: #f0fff0; \" | and the width of a parent node as a sum.\n| style=\"background: #e6ffff; \" | either as a wiki table,\n| style=\"background: #e6ffff; \" | or as HTML.\n|-\n|  | \n|  | \n|  | \n|  | \n| style=\"background: #f0fff0; \" | (The sum of the widths of its children)\n|  | \n|  | \n|}\n```\n\nExtra credit\n\nUse background color to distinguish the main stages of your outline, so that the subtree of each node at level two is consistently colored, and the edges between adjacent subtrees are immediately revealed.\n\nOutput\n\nDisplay your nested table on this page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nUse a slightly more complicated outline than the task example to test some edge conditions. Limited to 10 direct subnodes on any one node as is. Easily adapted for larger if necessary.\n\nStrictly speaking, this is not a nested table. It is just a single level table that has some column spans > 1. For an example of using actual nested tables, see the task entry: List\\_authors\\_of\\_task\\_descriptions#Raku, (and full output).\n\n```\nmy $outline = q:to/END/;\n    Display an outline as a nested table.\n        Parse the outline to a tree,\n            measuring the indent of each line,\n            translating the indentation to a nested structure,\n            and padding the tree to even depth.\n        count the leaves descending from each node,\n            defining the width of a leaf as 1,\n            and the width of a parent node as a sum.\n                (The sum of the widths of its children)\n                Propagating the sums upward as necessary.\n        and write out a table with 'colspan' values\n            either as a wiki table,\n            or as HTML.\n        Optionally add color to the nodes.\n    END\n\n# Import outline paragraph into native data structure\nsub import (Str $trees, $level = '  ') {\n    my $forest;\n    my $last = -Inf;\n\n    for $trees.lines -> $branch {\n        $branch ~~ / ($($level))* /;\n        my $this = +$0;\n        $forest ~= do {\n            given $this cmp $last {\n                when More { \"\\['{esc $branch.trim}', \" }\n                when Same { \"'{esc $branch.trim}', \" }\n                when Less { \"{']' x $last - $this}, '{esc $branch.trim}', \" }\n            }\n        }\n        $last = $this;\n    }\n\n    sub esc { $^s.subst( /(<['\\\\]>)/, -> $/ { \"\\\\$0\" }, :g) }\n\n    $forest ~= ']' x 1 + $last;\n    use MONKEY-SEE-NO-EVAL;\n    $forest.EVAL;\n}\n\nmy @AoA = import $outline, '    ';\nmy @layout;\n\n# Collect information about node depth, position and children\n{\n    my @width = 0;\n    my $depth = -1;\n    @AoA.&insert;\n\n    multi insert ($item) {\n        @width[*-1]++;\n        @layout.push: { :depth($depth.clone), :id(@width[*-1].clone), :text($item) };\n    }\n\n    multi insert (@array) {\n        @width.push: @width[*-1] * 10;\n        ++$depth;\n        @array.map: &insert;\n        --$depth;\n        @width.pop;\n    }\n}\n\nmy $max-depth = @layout.max( *.<depth> )<depth>;\n\n# Pad ragged nodes\nfor (^$max-depth) -> $d {\n    my @nodes = @layout.grep( *.<depth> == $d );\n    for @nodes.sort( +*.<id> ) -> $n {\n        unless @layout.first( *.<id> == $n<id> ~ 1 ) {\n            @layout.push: { :depth($n<depth> + 1), :id($n<id> *10 + 1), :text('') };\n        }\n    }\n}\n\n# Calculate spans (child nodes)\nfor (0..$max-depth).reverse -> $d {\n    my @nodes = @layout.grep( *.<depth> == $d );\n    for @nodes.sort( +*.<id> ) -> $n {\n        my @span = @layout.grep: {.<depth> == $d + 1 && .<id>.starts-with: $n<id> };\n        $n<span> = ( sum @span.map( { .<span> // 0} )) || +@span || 1;\n    }\n}\n\n# Programatically assign colors\nfor (0..$max-depth) -> $d {\n    my @nodes = @layout.grep( *.<depth> == $d );\n    my $incr = 1 / (1 + @nodes);\n    for @nodes.sort( +*.<id> ) -> $n {\n        my $color = $d > 1 ??\n        @layout.first( *.<id> eq $n<id>.chop )<color> !!\n        \"style=\\\"background: #\" ~ hsv2rgb( ++$ * $incr, .1, 1) ~ '\" ';\n        $n<color> = $n<text> ?? $color !! '';\n    }\n}\n\n# Generate wikitable\nsay '{| class=\"wikitable\" style=\"text-align: center;\"' ~ \"\\n\" ~\n(join \"\\n|-\\n\", (0..$max-depth).map: -> $d {\n    my @nodes = @layout.grep( *.<depth> == $d );\n    (join \"\\n\", @nodes.sort( +*.<id> ).map( -> $node {\n        '| ' ~\n        ($node<color> // '' ) ~\n        ($node<span> > 1 ?? \"colspan=$node<span>\" !! '' ) ~\n        ' | ' ~ $node<text> }\n    ))\n}) ~ \"\\n|}\";\n\nsay \"\\n\\nSometimes it makes more sense to display an outline as...\nwell... as an outline, rather than as a table.\" ~ Q|¯\\_(ツ)_/¯| ~ \"\\n\";\n\n{ ## Outline - Ordered List #######\n    my @type = <upper-roman upper-latin decimal lower-latin lower-roman>;\n    my $depth = 0;\n\n    multi ol ($item) { \"\\<li>$item\\n\" }\n\n    multi ol (@array) {\n        my $li = $depth ?? \"</li>\" !! '';\n        $depth++;\n        my $list = \"<ol style=\\\"list-style: {@type[$depth - 1]};\\\">\\n\" ~\n        ( @array.map( &ol ).join ) ~ \"</ol>$li\\n\";\n        $depth--;\n        $list\n    }\n\n    say \"<div style=\\\"background: #fee;\\\">\\n\" ~ @AoA.&ol ~ \"</div>\";\n}\n\nsub hsv2rgb ( $h, $s, $v ){\n    my $c = $v * $s;\n    my $x = $c * (1 - abs( (($h*6) % 2) - 1 ) );\n    my $m = $v - $c;\n    my ($r, $g, $b) = do given $h {\n        when   0..^(1/6) { $c, $x, 0 }\n        when 1/6..^(1/3) { $x, $c, 0 }\n        when 1/3..^(1/2) { 0, $c, $x }\n        when 1/2..^(2/3) { 0, $x, $c }\n        when 2/3..^(5/6) { $x, 0, $c }\n        when 5/6..1      { $c, 0, $x }\n    }\n    ( $r, $g, $b ).map( ((*+$m) * 255).Int)».base(16).join\n}\n\n```\n\nOutput:\n\n|  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| Display an outline as a nested table. | | | | | | | | |\n| Parse the outline to a tree, | | | count the leaves descending from each node, | | | and write out a table with 'colspan' values | | Optionally add color to the nodes. |\n| measuring the indent of each line, | translating the indentation to a nested structure, | and padding the tree to even depth. | defining the width of a leaf as 1, | and the width of a parent node as a sum. | | either as a wiki table, | or as HTML. |  |\n|  |  |  |  | (The sum of the widths of its children) | Propagating the sums upward as necessary. |  |  |  |\n\nSometimes it makes more sense to display an outline as...\nwell... as an outline, rather than as a table.¯\\\\_(ツ)\\_/¯\n\n1. Display an outline as a nested table.\n   1. Parse the outline to a tree,\n      1. measuring the indent of each line,\n      2. translating the indentation to a nested structure,\n      3. and padding the tree to even depth.\n   2. count the leaves descending from each node,\n      1. defining the width of a leaf as 1,\n      2. and the width of a parent node as a sum.\n         1. (The sum of the widths of its children)\n         2. Propagating the sums upward as necessary.\n   3. and write out a table with 'colspan' values\n      1. either as a wiki table,\n      2. or as HTML.\n   4. Optionally add color to the nodes."}]}
{"messages": [{"role": "user", "content": "It is very important in aviation to have knowledge of the nearby airports at any time in flight.\n\nTask\n\nDetermine the distance and bearing from an Airplane to the 20 nearest Airports whenever requested.\nUse the non-commercial data from openflights.org airports.dat as reference.\n\nA request comes from an airplane at position ( latitude, longitude ): ( **51.514669, 2.198581** ).\n\nYour report should contain the following information from table airports.dat (column shown in brackets):\n\nName(2), Country(4), ICAO(6), Distance and Bearing calculated from Latitude(7) and Longitude(8).\n\nDistance is measured in nautical miles (NM). Resolution is 0.1 NM.\n\nBearing is measured in degrees (°). 0° = 360° = north then clockwise 90° = east, 180° = south, 270° = west. Resolution is 1°.\n\nSee\n:   * openflights.org/data:  Airport, airline and route data\n    * Movable Type Scripts:  Calculate distance, bearing and more between Latitude/Longitude points"}, {"role": "assistant", "content": "```\nuse Text::CSV;\n\nconstant $EARTH_RADIUS_IN_NAUTICAL_MILES = 6372.8 / 1.852;\n\nsub degrees   ( Real $rad ) { $rad / tau * 360 }\nsub radians   ( Real $deg ) { $deg * tau / 360 }\nsub haversine ( Real $x   ) { ($x / 2).sin.²   }\nsub arc_haver ( Real $x   ) { $x.sqrt.asin * 2 }\n\nsub great_circle_distance ( \\φ1, \\λ1, \\φ2, \\λ2 ) {\n    # https://en.wikipedia.org/wiki/Haversine_formula\n    #   latitude (represented by φ) and longitude (represented by λ)\n    #   hav(θ) = hav(φ₂ − φ₁) + cos(φ₁) cos(φ₂) hav(λ₂ − λ₁)\n    arc_haver(\n        haversine(φ2 - φ1)\n      + haversine(λ2 - λ1) * cos(φ1) * cos(φ2)\n    );\n}\n\nsub great_circle_bearing ( \\φ1, \\λ1, \\φ2, \\λ2 ) {\n    atan2(                          φ2.cos * (λ2 - λ1).sin,\n        φ1.cos * φ2.sin - φ1.sin * φ2.cos * (λ2 - λ1).cos,\n    );\n}\n\nsub distance_and_bearing ( $lat1, $lon1, $lat2, $lon2 ) {\n    my @ll = map &radians, $lat1, $lon1, $lat2, $lon2;\n\n    my $dist  = great_circle_distance(|@ll);\n    my $theta = great_circle_bearing( |@ll);\n\n    return  $dist * $EARTH_RADIUS_IN_NAUTICAL_MILES,\n            degrees( $theta + (tau if $theta < 0) )\n}\n\nsub find_nearest_airports ( $latitude, $longitude, $csv_path ) {\n    my &d_and_b_from_here = &distance_and_bearing.assuming($latitude, $longitude);\n\n    my @airports = csv(\n        in => $csv_path,\n        headers => [<ID Name City Country IATA ICAO Latitude Longitude>],\n    );\n\n    for @airports -> %row {\n        %row<Distance Bearing> = d_and_b_from_here( +%row<Latitude>, +%row<Longitude> );\n    }\n\n    return @airports.sort(*.<Distance>);\n}\n\nsub MAIN ( $lat = 51.514669, $long = 2.198581, $wanted = 20, $csv = 'airports.dat' ) {\n    printf \"%7s\\t%7s\\t%-7s\\t%-15s\\t%s\\n\", <Dist Bear ICAO Country Name>;\n\n    for find_nearest_airports($lat, $long, $csv).head($wanted) {\n        printf \"%7.1f\\t    %03d\\t%-7s\\t%-15s\\t%s\\n\",\n            .<Distance Bearing ICAO Country Name>;\n    }\n}\n\n```\n\nOutput:\n\n```\n   Dist\t   Bear\tICAO   \tCountry        \tName\n   30.7\t    146\tEBFN   \tBelgium        \tKoksijde Air Base\n   31.3\t    127\tEBOS   \tBelgium        \tOstend-Bruges International Airport\n   33.6\t    252\tEGMH   \tUnited Kingdom \tKent International Airport\n   34.4\t    195\tLFAC   \tFrance         \tCalais-Dunkerque Airport\n   42.6\t    105\tEBKW   \tBelgium        \tWestkapelle heliport\n   51.6\t    240\tEGMK   \tUnited Kingdom \tLympne Airport\n   52.8\t    114\tEBUL   \tBelgium        \tUrsel Air Base\n   56.2\t    274\tEGMC   \tUnited Kingdom \tSouthend Airport\n   56.4\t    162\tLFQT   \tFrance         \tMerville-Calonne Airport\n   56.5\t    137\tEBKT   \tBelgium        \tWevelgem Airport\n   57.3\t    089\tEHMZ   \tNetherlands    \tMidden-Zeeland Airport\n   58.0\t    235\tEGMD   \tUnited Kingdom \tLydd Airport\n   59.0\t    309\tEGUW   \tUnited Kingdom \tRAF Wattisham\n   59.3\t    339\tEGSM   \tUnited Kingdom \tBeccles Airport\n   59.7\t    146\tLFQO   \tFrance         \tLille/Marcq-en-Baroeul Airport\n   62.2\t    250\tEGKH   \tUnited Kingdom \tLashenden (Headcorn) Airfield\n   63.7\t    200\tLFAT   \tFrance         \tLe Touquet-Côte d'Opale Airport\n   64.2\t    261\tEGTO   \tUnited Kingdom \tRochester Airport\n   66.3\t    149\tLFQQ   \tFrance         \tLille-Lesquin Airport\n   68.4\t    271\tEGMT   \tUnited Kingdom \tThurrock Airfield\n```"}]}
{"messages": [{"role": "user", "content": "Find all distinct palindromes contained as substrings in decimal representation of n. Note that for the\npurpose of the initial function, a single digit will be considered a palindrome.\n\nTask\n\n1. Find all the palindromes including single digits in the integers from 100 to 125, inclusive.\n2. Determine which if any of the following decimal integers contain palindromes of 2 digits or more:\n\n```\n 9, 169, 12769, 1238769, 123498769, 12346098769, 1234572098769,\n 123456832098769, 12345679432098769, 1234567905432098769, 123456790165432098769,\n 83071934127905179083, 1320267947849490361205695\n\n```\n\nAlso see\n:   * OEIS entry:   A262188 (Task 1).\n    * OEIS entry:   A151997 (Task 2).\n\nRelated tasks\n\nPalindrome\\_detection   \nLongest\\_palindromic\\_substrings   \nN\\_1's\\_followed\\_by\\_a\\_3"}, {"role": "assistant", "content": "A minor modification of the Longest palindromic substrings task. As such, works for any string, not just integers.\n\n```\nuse Sort::Naturally;\n\nsub getpal ($str) {\n    my @chars = $str.comb;\n    my @pal = flat @chars,\n    (1 ..^ @chars).map: -> \\idx {\n        my @s;\n        for 1, 2 {\n           my int ($rev, $fwd) = $_, 1;\n           loop {\n                quietly last if ($rev > idx) || (@chars[idx - $rev] ne @chars[idx + $fwd]);\n                $rev = $rev + 1;\n                $fwd = $fwd + 1;\n            }\n            @s.push: @chars[idx - $rev ^..^ idx + $fwd].join if $rev + $fwd > 2;\n            last if @chars[idx - 1] ne @chars[idx];\n        }\n        next unless +@s;\n        @s\n    }\n    @pal.unique.sort({.chars, .&naturally});\n}\n\nsay 'All palindromic substrings including (bizarrely enough) single characters:';\nput \"$_ => \", getpal $_ for 100..125;\nput \"\\nDo these strings contain a minimum two character palindrome?\";\nprintf \"%25s => %s\\n\", $_, getpal($_).tail.chars > 1 for flat\n    9, 169, 12769, 1238769, 123498769, 12346098769, 1234572098769,\n    123456832098769, 12345679432098769, 1234567905432098769,\n    123456790165432098769, 83071934127905179083, 1320267947849490361205695,\n    <Do these strings contain a minimum two character palindrome?>\n\n```\n\nOutput:\n\n```\nAll palindromic substrings including (bizarrely enough) single characters:\n100 => 0 1 00\n101 => 0 1 101\n102 => 0 1 2\n103 => 0 1 3\n104 => 0 1 4\n105 => 0 1 5\n106 => 0 1 6\n107 => 0 1 7\n108 => 0 1 8\n109 => 0 1 9\n110 => 0 1 11\n111 => 1 11 111\n112 => 1 2 11\n113 => 1 3 11\n114 => 1 4 11\n115 => 1 5 11\n116 => 1 6 11\n117 => 1 7 11\n118 => 1 8 11\n119 => 1 9 11\n120 => 0 1 2\n121 => 1 2 121\n122 => 1 2 22\n123 => 1 2 3\n124 => 1 2 4\n125 => 1 2 5\n\nDo these strings contain a minimum two character palindrome?\n                        9 => False\n                      169 => False\n                    12769 => False\n                  1238769 => False\n                123498769 => False\n              12346098769 => False\n            1234572098769 => False\n          123456832098769 => False\n        12345679432098769 => False\n      1234567905432098769 => False\n    123456790165432098769 => False\n     83071934127905179083 => False\n1320267947849490361205695 => True\n                       Do => False\n                    these => True\n                  strings => False\n                  contain => False\n                        a => False\n                  minimum => True\n                      two => False\n                character => True\n              palindrome? => False\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCompute all combinations of \n\na\n\nb\n{\\displaystyle {\\displaystyle a^{b}}}\n where a and b are integers between 2 and 5 inclusive.\n  \n  \nPlace them in numerical order, with any repeats removed.\n  \n  \nYou should get the following sequence of 15 distinct terms:\n  \n4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125"}, {"role": "assistant", "content": "```\nput squish sort [X**] (2..5) xx 2;\n\n```\n\nOutput:\n\n```\n4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125\n```"}]}
{"messages": [{"role": "user", "content": "Write two programs (or one program with two modes) which run on networked computers, and send some messages between them.\n\nThe protocol used may be language-specific or not, and should be **suitable for general distributed programming**; that is, the *protocol* should be generic (not designed just for the particular example application), readily capable of handling the independent communications of many different components of a single application, and the transferring of arbitrary data structures natural for the language.\n\nThis task is intended to demonstrate high-level communication facilities beyond just creating sockets."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nServer listens for JSON encoded messages. It processes requests for set|get|dump. 'set' stores a message, 'get' returns message, 'dump' returns all stored messages. Optional parameters for ip address and port.\n\nServer.raku:\n\n```\n./server.raku --usage\nUsage:\n  server.p6 [--server=<Any>] [--port=<Any>]\n```\n\n```\n#!/usr/bin/env raku\nuse JSON::Fast ;\nsub MAIN( :$server='0.0.0.0' , :$port=3333 ) {\n  my %db ;\n  react {\n    whenever IO::Socket::Async.listen( $server , $port ) -> $conn {\n        whenever $conn.Supply.lines -> $line {\n            my %response = 'status' => '' ;\n            my $msg = from-json $line ;\n            say $msg.raku;\n            given $msg{\"function\"} {\n                when 'set' {\n                    %db{ $msg<topic> } = $msg<message> ;\n                    %response<status> = 'ok' ;\n                }\n                when 'get' {\n                    %response<topic> = $msg<topic> ;\n                    %response<message> = %db{ $msg<topic> } ;\n                    %response<status> = 'ok' ;\n                }\n                when 'dump' {\n                    %response = %db ;\n                }\n                when 'delete' {\n                    %db{ $msg<topic> }:delete;\n                    %response<status> = 'ok' ;\n                }\n            }\n            $conn.print( to-json(%response, :!pretty) ~ \"\\n\" ) ;\n            LAST { $conn.close ; }\n            QUIT { default { $conn.close ; say \"oh no, $_\";}}\n            CATCH { default { say .^name, ': ', .Str ,  \" handled in $?LINE\";}}\n        }\n    }\n  }\n}\n\n```\n\nclient.raku:\n\n```\nUsage:\n  client.raku [--server=<Any>] [--port=<Any>] [--json=<Any>] set <topic> [<message>]\n  client.raku [--server=<Any>] [--port=<Any>] get <topic>\n  client.raku [--server=<Any>] [--port=<Any>] dump\n```\n\n```\n#!/usr/bin/env raku\nuse JSON::Fast ;\nmulti MAIN('set', $topic,  $message='', :$server='localhost', :$port='3333', :$json='') {\n    my %msg = function => 'set' , topic=> $topic , message=> $message ;\n    %msg{\"message\"} = from-json( $json ) if $json ;\n    sendmsg( %msg , $server, $port) ;\n}\nmulti MAIN('get', $topic, :$server='localhost', :$port='3333') {\n    my %msg = function => 'get' , topic=> $topic ;\n    sendmsg( %msg , $server, $port) ;\n}\nmulti MAIN('delete', $topic, :$server='localhost', :$port='3333') {\n    my %msg = function => 'delete' , topic=> $topic ;\n    sendmsg( %msg , $server, $port) ;\n}\nmulti MAIN('dump', :$server='localhost', :$port='3333') {\n    my %msg = function => 'dump'  ;\n    sendmsg( %msg , $server, $port) ;\n}\nsub sendmsg( %msg , $server, $port){\n    my $conn = await IO::Socket::Async.connect( $server , $port );\n    $conn.print: to-json( %msg,:!pretty)~\"\\n\";\n    react {\n        whenever $conn.Supply -> $data {\n            print $data;\n            $conn.close;\n        }\n    }\n}\n\n```\n\nexamples:\n\n```\necho '{\"function\":\"set\",\"topic\":\"push\",\"message\":[\"perl5\",\"raku\",\"rakudo\"]}' | nc localhost 3333\n\n./client.raku set version raku\n{\"status\": \"ok\"}\n./client.raku get version\n{\"status\": \"ok\",\"topic\": \"version\",\"message\": \"raku\"}\n./client.raku --json='[\"one\",\"two\",\"three\"]' set mylist\n{\"status\": \"ok\"}\n./client.raku dump\n{\"push\": [\"perl5\",\"raku\",\"rakudo\"],\"version\": \"raku\",\"mylist\": [\"one\",\"two\",\"three\"]}\n./client.raku delete version\n{\"status\": \"ok\"}\n\nserver output:\n${:function(\"set\"), :message($[\"perl5\", \"raku\", \"rakudo\"]), :topic(\"push\")}\n${:function(\"set\"), :message(\"raku\"), :topic(\"version\")}\n${:function(\"get\"), :topic(\"version\")}\n${:function(\"set\"), :message($[\"one\", \"two\", \"three\"]), :topic(\"mylist\")}\n${:function(\"dump\")}\n${:function(\"delete\"), :topic(\"version\")}\n```"}]}
{"messages": [{"role": "user", "content": "Large Factorials and the Distribution of '0' in base 10 digits.\n\nAbout the task\n\nWe can see that some features of factorial numbers (the series of numbers 1!, 2!, 3!, ...)\ncome about because such numbers are the product of a series of counting numbers, and so those\nproducts have predictable factors. For example, all factorials above 1! are even numbers,\nsince they have 2 as a factor. Similarly, all factorials from 5! up end in a 0, because they\nhave 5 and 2 as factors, and thus have 10 as a factor. In fact, the factorial integers add\nanother 0 at the end of the factorial for every step of 5 upward: 5! = 120, 10! = 3628800,\n15! = 1307674368000, 16! = 20922789888000 and so on.\n\nBecause factorial numbers, which quickly become quite large, continue to have another terminal 0\non the right hand side of the number for every factor of 5 added to the factorial product, one might\nthink that the proportion of zeros in a base 10 factorial number might be close to 1/5. However,\nthough the factorial products add another terminating 0 every factor of 5 multiplied into the product,\nas the numbers become quite large, the number of digits in the factorial product expands exponentially,\nand so the number above the terminating zeros tends toward 10% of each digit from 0 to 1 as the factorial\nbecomes larger. Thus, as the factorials become larger, the proportion of 0 digits in the factorial products\nshifts slowly from around 1/5 toward 1/10, since the number of terminating zeros in n! increases only in\nproportion to n, whereas the number of digits of n! in base 10 increases exponentially.\n\nThe task\n\nCreate a function to calculate the mean of the proportions of 0 digits out of the total digits found in each factorial\nproduct from 1! to N!. This proportion of 0 digits in base 10 should be calculated using the number as printed as a base 10 integer.\n\nExample: for 1 to 6 we have 1!, 2!, 3!, 4!, 5!, 6!, or (1, 2, 6, 24, 120, 720), so we need the mean of\n(0/1, 0/1, 0/1, 0/2, 1/3, 1/3) = (2/3) (totals of each proportion) / 6 (= N), or 0.1111111...\n\nExample: for 1 to 25 the mean of the proportions of 0 digits in the factorial products series of N! with N from 1 to 25 is 0.26787.\n\nDo this task for 1 to N where N is in (100, 1000, and 10000), so, compute the mean of the proportion of 0 digits for each product\nin the series of each of the factorials from 1 to 100, 1 to 1000, and 1 to 10000.\n\nStretch task\n\nFind the N in 10000 < N < 50000 where the mean of the proportions of 0 digits in the factorial products from 1 to N\npermanently falls below 0.16. This task took many hours in the Python example, though I wonder if there is a faster\nalgorithm out there."}, {"role": "assistant", "content": "Works, but depressingly slow for 10000.\n\n```\nsub postfix:<!> (Int $n) { ( constant factorial = 1, 1, |[\\*] 2..* )[$n] }\nsink 10000!; # prime the iterator to allow multithreading\n\nsub zs ($n) { ( constant zero-share = (^Inf).race(:32batch).map: { (.!.comb.Bag){'0'} / .!.chars } )[$n+1] }\n\n.say for (\n     100\n    ,1000\n    ,10000\n).map:  -> \\n { \"{n}: {([+] (^n).map: *.&zs) / n}\" }\n\n```\n\nOutput:\n\n```\n100: 0.24675318616743216\n1000: 0.20354455110316458\n10000: 0.17300384824186605\n\n```"}]}
{"messages": [{"role": "user", "content": "The   *wisdom of the crowd*   is the collective opinion of a group of individuals rather than that of a single expert.\n\nWisdom-of-the-crowds research routinely attributes the superiority of crowd averages over individual judgments to the elimination of individual noise,   an explanation that assumes independence of the individual judgments from each other.\n\nThus the crowd tends to make its best decisions if it is made up of diverse opinions and ideologies.\n\nScott E. Page introduced the diversity prediction theorem:\n\n:   *The squared error of the collective prediction equals the average squared error minus the predictive diversity*.\n\nTherefore,   when the diversity in a group is large,   the error of the crowd is small.\n\nDefinitions\n:   :   * Average Individual Error:   Average of the individual squared errors\n        * Collective Error:   Squared error of the collective prediction\n        * Prediction Diversity:   Average squared distance from the individual predictions to the collective prediction\n        * Diversity Prediction Theorem:   *Given a crowd of predictive models*,     then\n\n        :   :   :   :   Collective Error   =   Average Individual Error   ─   Prediction Diversity\n\nTask\n\nFor a given   true   value and a number of number of estimates (from a crowd),   show   (here on this page):\n\n:   :   :   * the true value   and   the crowd estimates\n            * the average error\n            * the crowd error\n            * the prediction diversity\n\nUse   (at least)   these two examples:\n\n:   :   :   * a true value of   **49**   with crowd estimates of:    **48   47   51**\n            * a true value of   **49**   with crowd estimates of:    **48   47   51   42**\n\nAlso see\n:   * Wikipedia entry:   Wisdom of the crowd\n    * University of Michigan: PDF paper         (exists on a web archive,   the *Wayback Machine*)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub diversity-calc($truth, @pred) {\n    my $ae = avg-error($truth, @pred); # average individual error\n    my $cp = ([+] @pred)/+@pred;       # collective prediction\n    my $ce = ($cp - $truth)**2;        # collective error\n    my $pd = avg-error($cp, @pred);    # prediction diversity\n    return $ae, $ce, $pd;\n}\n\nsub avg-error ($m, @v) { ([+] (@v X- $m) X**2) / +@v }\n\nsub diversity-format (@stats) {\n    gather {\n        for <average-error crowd-error diversity> Z @stats -> ($label,$value) {\n            take $label.fmt(\"%13s\") ~ ':' ~ $value.fmt(\"%7.3f\");\n        }\n    }\n}\n\n.say for diversity-format diversity-calc(49, <48 47 51>);\n.say for diversity-format diversity-calc(49, <48 47 51 42>);\n\n```\n\nOutput:\n\n```\naverage-error:  3.000\n  crowd-error:  0.111\n    diversity:  2.889\naverage-error: 14.500\n  crowd-error:  4.000\n    diversity: 10.500\n\n```"}]}
{"messages": [{"role": "user", "content": "Given the coordinates of a rectangle and a number, cut the rectangle into that\nnumber of random, non-similar triangles that exactly cover the rectangle without\ngaps or overlaps.\n\nThe number of triangles may have reasonable limits such as being above a small\nlimit, and/or odd or even, and/or prime for example.  \nThe number should not have an upper bound however, so that many triangles can be generated.\n\n* Explain, or refer to the algorithm employed.\n* Give a sample of sets of triangles produced from running the algorithm, on this page."}, {"role": "assistant", "content": "The first triangle bisects the rectangle via the diagonal. The rest of them all got one vertex at the origin and a side defined by ratios of numbers from a descending positive integer sequence.\n\n```\n# 20220123 Raku programming solution \n\n# Proof :\n#\n#    H-----------A---------B-------C-----D---E\n#    |                                       |\n#    |                                       |\n#    |                                       |\n#    O---------------------------------------L\n#\n#    ▲OEL is unique as its area is the sum of the rest.\n#\n#    and also in terms of area ▲OHA > ▲OAB > ... > ▲ODE\n \n\nsub UnequalDivider (\\L,\\H,\\N where N > 2) { \n\n   my \\sum = $ = 0 ; my \\part = $ = 0 ; my @sequence = (N^...1) ; \n\n   loop {                                               #   if  ▲OHA ~ ▲OEL    \n      sum  = @sequence.sum;                             #   increase 1st term \n      @sequence[0]*L*L/sum == H*H ?? (@sequence[0] +=1) !! last \n   }\n\n   (  [ (0,0), (L,H), (L,0) ],  ).Array.append: @sequence.map: -> \\chunk {\n      [ (0,0), (L*part/sum,H), (L*(part+=chunk)/sum,H) ] ;\n   } \n}\n\n.say for UnequalDivider(1000,500,5);\n\n```\n\nOutput:\n\n```\n[(0 0) (1000 500) (1000 0)]\n[(0 0) (0 500) (400 500)]\n[(0 0) (400 500) (700 500)]\n[(0 0) (700 500) (900 500)]\n[(0 0) (900 500) (1000 500)]\n\n```"}]}
{"messages": [{"role": "user", "content": "DNS is an internet service that maps domain names, like `rosettacode.org`, to IP addresses, like `66.220.0.231`.\n\nUse DNS to resolve `www.kame.net` to both IPv4 and IPv6 addresses. Print these addresses."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.01\n\n```\nuse Net::DNS;\n\nmy $resolver = Net::DNS.new('8.8.8.8');\n\nmy $ip4 = $resolver.lookup('A',    'orange.kame.net');\nmy $ip6 = $resolver.lookup('AAAA', 'orange.kame.net');\n\nsay $ip4[0].octets.join: '.';\nsay $ip6[0].octets.».fmt(\"%.2X\").join.comb(4).join: ':';\n\n```\n\nOutput:\n\n```\n203.178.141.194\n2001:0200:0dff:fff1:0216:3eff:feb1:44d7\n```"}]}
{"messages": [{"role": "user", "content": "Show how to insert documentation for classes, functions, and/or variables in your language. If this documentation is built-in to the language, note it. If this documentation requires external tools, note them.\n\nSee also\n\n* Related task: Comments\n* Related task: Here\\_document"}, {"role": "assistant", "content": "(formerly Perl 6)\nSimilarly to Perl 5, Raku is documented using Pod (a redesigned version of POD). However, it's not simply ignored by the parser as in Perl 5, it's an internal part of the language spec and can be used to attach documentation objects to almost any part of the code.\n\n```\n#= it's yellow\nsub marine { ... }\nsay &marine.WHY; # \"it's yellow\"\n\n#= a shaggy little thing\nclass Sheep {\n    #= not too scary\n    method roar { 'roar!' }\n}\nsay Sheep.WHY; # \"a shaggy little thing\"\nsay Sheep.^find_method('roar').WHY; # \"not too scary\"\n\n```\n\nA compiler has a built-in `--doc` switch that will generate documentation from a given source file. An output format can be specified in the switch. For example, `--doc=Markdown` will generate Markdown from Pod provided that the `Pod::To::Markdown` is installed."}]}
{"messages": [{"role": "user", "content": "Warning: If you are looking for pizza delivery you have come to the wrong page. Bloody Google (other search engines are available).\n\nTake a box of dominoes give them a good shuffle and then arrange them in diverse orientations such that they form a rectangle with 7 rows of 8 columns. Make a tableau of the face values e.g.\n\n```\n       05132231\n       05505246\n       43036620\n       06235126\n       11300245\n       21433466\n       64515414\n\n```\n\nNow torment your computer by making it identify where each domino is.\n\nDo this for the above tableau and one of your own construction.\n\nExtra credit:\n\nHow many ways are there to arrange dominoes in an 8x7 rectangle, first ignoring their values, then considering their values, and finally considering values but ignoring value symmetry, i.e. transposing 5 and 4."}, {"role": "assistant", "content": "```\nsub domino (Str $s) { $s.comb.sort.join }\n\nsub solve ( UInt $rows, UInt $cols, @tab ) {\n    die unless @tab.elems == $rows*$cols;\n    die unless @tab.elems %% 2;\n\n    my @orientations = 'A' xx @tab.elems; # [A]vailable,[R]ight,[D]own,[L]eft,[U]p\n\n    my SetHash $hand .= new: map &domino, [X~] @tab.unique xx 2;\n\n    return gather {\n        my sub place_domino_at_first_available_after ( UInt $pos_last = 0 ) {\n            my $p1 = $pos_last + @orientations.skip($pos_last).first(:k, 'A');\n\n            for (False, $p1+1    , <L R>),\n                (True , $p1+$cols, <D U>) -> ($is_down, $p2, @two_letters) {\n\n                next if $p2 > @tab.end or (!$is_down && $p2 %% $cols); # Board boundaries.\n\n                my @two_cells := @orientations[$p1, $p2]; # Bind to candidate location\n\n                next if @two_cells !eqv <A A>; # Both cells must be available for placement.\n\n                my $dom = domino( @tab[$p1, $p2].join );\n\n                $hand{$dom}-- or next;          # Take domino from hand, iff present\n                @two_cells = @two_letters;      # Assign placement\n\n                # Either the solution is complete, or we must recurse.\n                if !$hand { take @orientations.clone }\n                else      { place_domino_at_first_available_after($p1) }\n\n                @two_cells = <A A>;             # Unassign placement\n                $hand{$dom}++;                  # Restore domino into hand\n            }\n        }\n        place_domino_at_first_available_after();\n    }\n}\nsub bonus ( UInt $rows, UInt $cols ) {\n    die \"Both are odd, so no tiling possible\" if $rows !%% 2 and $cols !%% 2;\n\n    my $half = $rows * $cols div 2;\n\n    my sub T ($N) { map { ( pi * $_/($N+1) ).cos² * 4 }, 1..($N/2).ceiling }\n\n    my $arrangements = [*] T($rows) X+ T($cols);\n    my $flips        =     2 ** $half;\n    my $permutations = [*] 1 .. $half;\n    my $product      = [*] ($arrangements, $flips, $permutations);\n    return :$arrangements, :$flips, :$permutations, :$product;\n}\nmy @tests =\n    (7, 8, '05132231055052464303662006235126113002452143346664515414'),\n    (7, 8, '64220650162341432102355113505610426040114420536366525334'),\n    (3, 4, '001102221201'),\n;\nsub solution_works ( UInt $rows, UInt $cols, @tab, @sol --> Bool ) {\n    die unless @sol.all eq <L R U D>.any;\n    my BagHash $b .= new;\n    for @sol.keys -> $p1 {\n        given @sol[$p1] {\n            when 'L' { my $p2 = $p1+1;     die unless @sol[$p2] eq 'R'; $b{ domino( @tab[$p1,$p2].join ) }++; }\n            when 'D' { my $p2 = $p1+$cols; die unless @sol[$p2] eq 'U'; $b{ domino( @tab[$p1,$p2].join ) }++; }\n        }\n    }\n    die unless $b.values.max == 1 and $b.elems == $rows * $cols / 2;\n    return True;\n}\nfor @tests -> ( $rows, $cols, $flat_table ) {\n    my @solutions = solve($rows, $cols, $flat_table.comb);\n    say 'Solutions found: ', +@solutions;\n\n    # Confirm that every solution is valid.\n    solution_works($rows, $cols, $flat_table.comb, $_) or die for @solutions;\n\n    # Print first solution\n    say .join.trans( [<L R D U>] => [<╼ ╾ ╽ ╿>]) for @solutions[0].batch($cols);\n\n    if ++$ == 1 {\n        say 'Bonus:';\n        say .value.fmt(\"%45d \"), .key.tclc for bonus($rows, $cols);\n        say '';\n    }\n}\n\n```\n\nOutput:\n\n```\nSolutions found: 1\n╼╾╼╾╽╼╾╽\n╽╼╾╽╿╼╾╿\n╿╽╽╿╼╾╽╽\n╽╿╿╼╾╽╿╿\n╿╽╽╼╾╿╽╽\n╽╿╿╼╾╽╿╿\n╿╼╾╼╾╿╼╾\nBonus:\n                                      1292697 Arrangements\n                                    268435456 Flips\n               304888344611713860501504000000 Permutations\n105797996085635619122449324709940305294524416 Product\n\nSolutions found: 2025\n╼╾╼╾╼╾╽╽\n╼╾╼╾╼╾╿╿\n╼╾╼╾╼╾╼╾\n╼╾╼╾╼╾╼╾\n╼╾╽╽╼╾╼╾\n╼╾╿╿╽╼╾╽\n╼╾╼╾╿╼╾╿\nSolutions found: 4\n╼╾╼╾\n╼╾╼╾\n╼╾╼╾\n\n```"}]}
{"messages": [{"role": "user", "content": "About the task\n\nJohn Conway (1937-2020), was a mathematician who also invented several mathematically\noriented computer pastimes, such as the famous Game of Life cellular automaton program.\nDr. Conway invented a simple algorithm for finding the day of the week, given any date.\nThe algorithm was based on calculating the distance of a given date from certain\n\"anchor days\" which follow a pattern for the day of the week upon which they fall.\n\nAlgorithm\n\nThe formula is calculated assuming that Sunday is 0, Monday 1, and so forth with Saturday 7, and\n\n```\n   doomsday = (Tuesday(or 2) + 5(y mod 4) + 4(y mod 100) + 6(y mod 400)) % 7\n\n```\n\nwhich, for 2021, is 0 (Sunday).\n\nTo calculate the day of the week, we then count days from a close doomsday,\nwith these as charted here by month, then add the doomsday for the year,\nthen get the remainder after dividing by 7. This should give us the number\ncorresponding to the day of the week for that date.\n\n```\n   Month\t        Doomsday Dates for Month\n   --------------------------------------------\n   January (common years)   3, 10, 17, 24, 31\n   January (leap years)     4, 11, 18, 25\n   February (common years)  7, 14, 21, 28\n   February (leap years)    1, 8, 15, 22, 29\n   March                    7, 14, 21, 28\n   April                    4, 11, 18, 25\n   May                      2, 9, 16, 23, 30\n   June                     6, 13, 20, 27\n   July                     4, 11, 18, 25\n   August                   1, 8, 15, 22, 29\n   September                5, 12, 19, 26\n   October                  3, 10, 17, 24, 31\n   November                 7, 14, 21, 28\n   December                 5, 12, 19, 26\n\n```\n\nTask\n\nGiven the following dates:\n\n* 1800-01-06 (January 6, 1800)\n* 1875-03-29 (March 29, 1875)\n* 1915-12-07 (December 7, 1915)\n* 1970-12-23 (December 23, 1970)\n* 2043-05-14 (May 14, 2043)\n* 2077-02-12 (February 12, 2077)\n* 2101-04-02 (April 2, 2101)\n\nUse Conway's Doomsday rule to calculate the day of the week for each date.\n\nsee also\n\n* Doomsday rule\n* Tomorrow is the Day After Doomsday (p.28)"}, {"role": "assistant", "content": "```\nmy @dow = < Sunday Monday Tuesday Wednesday Thursday Friday Saturday >;\n\nmy %doomsday = False => [3,7,7,4,2,6,4,1,5,3,7,5], True => [4,1,7,4,2,6,4,1,5,3,7,5];\n\nsub conway ($date) {\n    my ($year, $month, $day) = $date.comb(/\\d+/)».Int;\n    my $is-leap = ($year %% 4) && (($year % 100) || ($year %% 400));\n\n    my $c = $year div 100;\n    my $s = ($year % 100) div 12;\n    my $t = ($year % 100)   % 12;\n    my $a = ( 5 * ($c % 4) + 2 ) % 7;\n    my $b = ( $s + $t + ($t div 4) + $a ) % 7;\n\n    ($b + $day - %doomsday{$is-leap}[$month - 1] + 7) % 7\n}\n\n\nfor < 1800-01-06 1875-03-29 1915-12-07 1970-12-23 2043-05-14 2077-02-12 2101-04-02 >\n{\n    say \"Conway  - $_ is a: \", @dow[.&conway];\n    # Or, we could use the method built into the compiler...\n    say \"Builtin - $_ is a: \", @dow[Date.new($_).day-of-week];\n    say '';\n}\n\n```\n\nOutput:\n\n```\nConway  - 1800-01-06 is a: Monday\nBuiltin - 1800-01-06 is a: Monday\n\nConway  - 1875-03-29 is a: Monday\nBuiltin - 1875-03-29 is a: Monday\n\nConway  - 1915-12-07 is a: Tuesday\nBuiltin - 1915-12-07 is a: Tuesday\n\nConway  - 1970-12-23 is a: Wednesday\nBuiltin - 1970-12-23 is a: Wednesday\n\nConway  - 2043-05-14 is a: Thursday\nBuiltin - 2043-05-14 is a: Thursday\n\nConway  - 2077-02-12 is a: Friday\nBuiltin - 2077-02-12 is a: Friday\n\nConway  - 2101-04-02 is a: Saturday\nBuiltin - 2101-04-02 is a: Saturday\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a function/use an in-built function, to compute the   **dot product**,   also known as the   **scalar product**   of two vectors.\n\nIf possible, make the vectors of arbitrary length.\n\nAs an example, compute the dot product of the vectors:\n\n:   :   :   :   `[1,  3, -5]`       and\n            :   `[4, -2, -1]`\n\nIf implementing the dot product of two vectors directly:\n\n:   :   :   * each vector must be the same length\n            * multiply corresponding terms from each vector\n            * sum the products   (to produce the answer)\n\nRelated task\n\n* Vector products"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2010.07\n\nWe use the square-bracket meta-operator to turn the infix operator `+` into a reducing list operator, and the guillemet meta-operator to vectorize the infix operator `*`. Length validation is automatic in this form.\n\n```\nsub infix:<·> { [+] @^a »*« @^b }\n\nsay (1, 3, 5)·(4, -2, 1);\n```"}]}
{"messages": [{"role": "user", "content": "**Definition**\n  \nLet (p1,p2) and (p3,p4) be twin primes where p3 - p2 = 4.\n  \nSuch primes called **Double Twin Primes**\n  \n   \n**Example**\n  \n[5,7,11,13]\n  \n**Task**\n  \nFind and show here all Double Twin Primes under 1000.\n\nSee also\n:   * OEIS:A007530\n    * Wikipedia:Prime\\_k-tuple"}, {"role": "assistant", "content": "Cousin twin primes:\n\n```\nsub dt { $^p, $p+2, $p+6, $p+8 }\n.&dt.say for (^1000).grep: { all .&dt».is-prime };\n\n```\n\nOutput:\n\n```\n(5 7 11 13)\n(11 13 17 19)\n(101 103 107 109)\n(191 193 197 199)\n(821 823 827 829)\n```"}]}
{"messages": [{"role": "user", "content": "Define the data structure for a complete Doubly Linked List.\n\n* The structure should support adding elements to the head, tail and middle of the list.\n* The structure should not allow circular loops\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\nThis shows a complete example. (Other entries in the section focus on aspects of this solution.)\n\n```\nrole DLElem[::T] {\n    has DLElem[T] $.prev is rw;\n    has DLElem[T] $.next is rw;\n    has T $.payload = T;\n\n    method pre-insert(T $payload) {\n\tdie \"Can't insert before beginning\" unless $!prev;\n\tmy $elem = ::?CLASS.new(:$payload);\n\t$!prev.next = $elem;\n\t$elem.prev = $!prev;\n\t$elem.next = self;\n\t$!prev = $elem;\n\t$elem;\n    }\n\n    method post-insert(T $payload) {\n\tdie \"Can't insert after end\" unless $!next;\n\tmy $elem = ::?CLASS.new(:$payload);\n\t$!next.prev = $elem;\n\t$elem.next = $!next;\n\t$elem.prev = self;\n\t$!next = $elem;\n\t$elem;\n    }\n\n    method delete {\n\tdie \"Can't delete a sentinel\" unless $!prev and $!next;\n\t$!next.prev = $!prev;\n\t$!prev.next = $!next;\t# conveniently returns next element\n    }\n}\n\nrole DLList[::DLE] {\n    has DLE $.first;\n    has DLE $.last;\n\n    submethod BUILD {\n\t$!first = DLE.new;\n\t$!last = DLE.new;\n\t$!first.next = $!last;\n\t$!last.prev = $!first;\n    }\n\n    method list { ($!first.next, *.next ...^ !*.next).map: *.payload }\n    method reverse { ($!last.prev, *.prev ...^ !*.prev).map: *.payload }\n}\n\nclass DLElem_Int does DLElem[Int] {}\nclass DLList_Int does DLList[DLElem_Int] {}\n\nmy $dll = DLList_Int.new;\n\n$dll.first.post-insert(1).post-insert(2).post-insert(3);\n$dll.first.post-insert(0);\n\n$dll.last.pre-insert(41).pre-insert(40).prev.delete;  # (deletes 3)\n$dll.last.pre-insert(42);\n\nsay $dll.list;     # 0 1 2 40 41 42\nsay $dll.reverse;  # 42 41 40 2 1 0\n\n```\n\nOutput:\n\n```\n0 1 2 40 41 42\n42 41 40 2 1 0\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDefine the data structure for a doubly-linked list element.\n\nThe element should include a data member to hold its value and pointers to both the next element in the list and the previous element in the list.\n\nThe pointers should be mutable.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nrole DLElem[::T] {\n    has DLElem[T] $.prev is rw;\n    has DLElem[T] $.next is rw;\n    has T $.payload = T;\n\n    method pre-insert(T $payload) {\n        die \"Can't insert before beginning\" unless $!prev;\n        my $elem = ::?CLASS.new(:$payload);\n        $!prev.next = $elem;\n        $elem.prev = $!prev;\n        $elem.next = self;\n        $!prev = $elem;\n        $elem;\n    }\n\n    method post-insert(T $payload) {\n        die \"Can't insert after end\" unless $!next;\n        my $elem = ::?CLASS.new(:$payload);\n        $!next.prev = $elem;\n        $elem.next = $!next;\n        $elem.prev = self;\n        $!next = $elem;\n        $elem;\n    }\n\n    method delete {\n        die \"Can't delete a sentinel\" unless $!prev and $!next;\n        $!next.prev = $!prev;\n        $!prev.next = $!next;   # conveniently returns next element\n    }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Use the link structure defined in Doubly-Linked List (element) to define a procedure for inserting a link into a doubly-linked list. Call this procedure to insert element C into a list {A,B}, between elements A and B.\n\nThis is much like inserting into a Singly-Linked List, but with added assignments so that the backwards-pointing links remain correct.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUsing the generic definitions from Doubly-linked\\_list/Definition#Raku:\n\n```\nrole DLElem[::T] {\n    has DLElem[T] $.prev is rw;\n    has DLElem[T] $.next is rw;\n    has T $.payload = T;\n\n    method pre-insert(T $payload) {\n        die \"Can't insert before beginning\" unless $!prev;\n        my $elem = ::?CLASS.new(:$payload);\n        $!prev.next = $elem;\n        $elem.prev = $!prev;\n        $elem.next = self;\n        $!prev = $elem;\n        $elem;\n    }\n\n    method post-insert(T $payload) {\n        die \"Can't insert after end\" unless $!next;\n        my $elem = ::?CLASS.new(:$payload);\n        $!next.prev = $elem;\n        $elem.next = $!next;\n        $elem.prev = self;\n        $!next = $elem;\n        $elem;\n    }\n\n    method delete {\n        die \"Can't delete a sentinel\" unless $!prev and $!next;\n        $!next.prev = $!prev;\n        $!prev.next = $!next;   # conveniently returns next element\n    }\n}\n\nrole DLList[::DLE] {\n    has DLE $.first;\n    has DLE $.last;\n\n    submethod BUILD {\n\t$!first = DLE.new;\n\t$!last = DLE.new;\n\t$!first.next = $!last;\n\t$!last.prev = $!first;\n    }\n\n    method list { ($!first.next, *.next ...^ !*.next).map: *.payload }\n    method reverse { ($!last.prev, *.prev ...^ !*.prev).map: *.payload }\n}\n\nclass DLElem_Str does DLElem[Str] {}\nclass DLList_Str does DLList[DLElem_Str] {}\n\nmy $sdll = DLList_Str.new;\nmy $b = $sdll.first.post-insert('A').post-insert('B');\n$b.pre-insert('C');\nsay $sdll.list;  # A C B\n\n```\n\nOutput:\n\n```\nA C B\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDefine a method to remove an element from a doubly-linked list and demonstrate its use.\n\nYou may wish to use the list element defined in Doubly-Linked List (element) for the purposes of this task."}, {"role": "assistant", "content": "Already implemented and demonstrated as part of Doubly-linked\\_list/Definition#Raku. Not going to duplicate the entire entry from there to here."}]}
{"messages": [{"role": "user", "content": "Traverse from the beginning of a doubly-linked list to the end, and from the end to the beginning.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nSince the list routines are supplied by the generic roles defined in Doubly-linked\\_list/Definition#Raku, it suffices to say:\n\n```\nsay $dll.list;\nsay $dll.reverse;\n\n```\n\nThese automatically return just the payloads, hiding the elements containing the forward and backward pointers."}]}
{"messages": [{"role": "user", "content": "Create and display a dragon curve fractal.\n\n(You may either display the curve directly or write it to an image file.)\n\nAlgorithms\n\nHere are some brief notes the algorithms used and how they might suit various languages.\n\n* Recursively a right curling dragon is a right dragon followed by a left dragon, at 90-degree angle. And a left dragon is a left followed by a right.\n\n```\n*---R----*     expands to     *       *\n                               \\     /\n                                R   L\n                                 \\ /\n                                  *\n\n                                  *\n                                 / \\\n                                L   R\n                               /     \\\n*---L---*      expands to     *       *\n```\n\n:   The co-routines `dcl` and `dcr` in various examples do this recursively to a desired expansion level.\n\n* The curl direction right or left can be a parameter instead of two separate routines.\n\n* Recursively, a curl direction can be eliminated by noting the dragon consists of two copies of itself drawn towards a central point at 45-degrees.\n\n```\n*------->*   becomes    *       *     Recursive copies drawn\n                         \\     /      from the ends towards\n                          \\   /       the centre.\n                           v v\n                            *\n```\n\n:   This can be seen in the SVG example. This is best suited to off-line drawing since the reversal in the second half means the drawing jumps backward and forward (in binary reflected Gray code order) which is not very good for a plotter or for drawing progressively on screen.\n\n* Successive approximation repeatedly re-writes each straight line as two new segments at a right angle,\n\n```\n                       *       \n*-----*   becomes     / \\      bend to left\n                     /   \\     if N odd\n                    *     *\n\n                    *     *   \n*-----*   becomes    \\   /     bend to right  \n                      \\ /      if N even \n                       *\n```\n\n:   Numbering from the start of the curve built so far, if the segment is at an odd position then the bend introduced is on the right side. If the segment is an even position then on the left. The process is then repeated on the new doubled list of segments. This constructs a full set of line segments before any drawing.\n\n:   The effect of the splitting is a kind of bottom-up version of the recursions. See the Asymptote example for code doing this.\n\n* Iteratively the curve always turns 90-degrees left or right at each point. The direction of the turn is given by the bit above the lowest 1-bit of n. Some bit-twiddling can extract that efficiently.\n\n```\nn = 1010110000\n        ^\n        bit above lowest 1-bit, turn left or right as 0 or 1\n\nLowMask = n BITXOR (n-1)   # eg. giving 0000011111\nAboveMask = LowMask + 1    # eg. giving 0000100000\nBitAboveLowestOne = n BITAND AboveMask\n```\n\n:   The first turn is at n=1, so reckon the curve starting at the origin as n=0 then a straight line segment to position n=1 and turn there.\n\n:   If you prefer to reckon the first turn as n=0 then take the bit above the lowest 0-bit instead. This works because \"...10000\" minus 1 is \"...01111\" so the lowest 0 in n-1 is where the lowest 1 in n is.\n\n:   Going by turns suits turtle graphics such as Logo or a plotter drawing with a pen and current direction.\n\n* If a language doesn't maintain a \"current direction\" for drawing then you can always keep that separately and apply turns by bit-above-lowest-1.\n\n* Absolute direction to move at point n can be calculated by the number of bit-transitions in n.\n\n```\nn = 11 00 1111 0 1\n      ^  ^    ^ ^     4 places where change bit value\n                      so direction=4*90degrees=East\n```\n\n:   This can be calculated by counting the number of 1 bits in \"n XOR (n RIGHTSHIFT 1)\" since such a shift and xor leaves a single 1 bit at each position where two adjacent bits differ.\n\n* Absolute X,Y coordinates of a point n can be calculated in complex numbers by some powers (i+1)^k and add/subtract/rotate. This is done in the gnuplot code. This might suit things similar to Gnuplot which want to calculate each point independently.\n\n* Predicate test for whether a given X,Y point or segment is on the curve can be done. This might suit line-by-line output rather than building an entire image before printing. See M4 for an example of this.\n\n:   A predicate works by dividing out complex number i+1 until reaching the origin, so it takes roughly a bit at a time from X and Y is thus quite efficient. Why it works is slightly subtle but the calculation is not difficult. (Check segment by applying an offset to move X,Y to an \"even\" position before dividing i+1. Check vertex by whether the segment either East or West is on the curve.)\n\n:   The number of steps in the predicate corresponds to doublings of the curve, so stopping the check at say 8 steps can limit the curve drawn to 2^8=256 points. The offsets arising in the predicate are bits of n the segment number, so can note those bits to calculate n and limit to an arbitrary desired length or sub-section.\n\n* As a Lindenmayer system of expansions. The simplest is two symbols F and S both straight lines, as used by the PGF code.\n\n```\nAxiom F, angle 90 degrees\nF -> F+S\nS -> F-S\n```\n\nThis always has F at even positions and S at odd. Eg. after 3 levels `F_S_F_S_F_S_F_S`. The +/- turns in between bend to the left or right the same as the \"successive approximation\" method above. Read more at for instance Joel Castellanos' L-system page.\n\nVariations are possible if you have only a single symbol for line draw, for example the Icon and Unicon and Xfractint code. The angles can also be broken into 45-degree parts to keep the expansion in a single direction rather than the endpoint rotating around.\n\nThe string rewrites can be done recursively without building the whole string, just follow its instructions at the target level. See for example C by IFS Drawing code. The effect is the same as \"recursive with parameter\" above but can draw other curves defined by L-systems."}, {"role": "assistant", "content": "(formerly Perl 6)\nWe'll use a L-System role, and draw the dragon in SVG.\n\n```\nuse SVG;\n\nrole Lindenmayer {\n    has %.rules;\n    method succ { \n\t    self.comb.map( { %!rules{$^c} // $c } ).join but Lindenmayer(%!rules)\n    }\n}\n\nmy $dragon = \"FX\" but Lindenmayer( { X => 'X+YF+', Y => '-FX-Y' } );\n\n$dragon++ xx ^15;\n\nmy @points = 215, 350;\n\nfor $dragon.comb {\n    state ($x, $y) = @points[0,1];\n    state $d = 2 + 0i;\n    if /'F'/ { @points.append: ($x += $d.re).round(.1), ($y += $d.im).round(.1) }\n    elsif /< + - >/ { $d *= \"{$_}1i\" }\n}\n\nsay SVG.serialize(\n    svg => [\n        :600width, :450height, :style<stroke:rgb(0,0,255)>,\n        :rect[:width<100%>, :height<100%>, :fill<white>],\n        :polyline[ :points(@points.join: ','), :fill<white> ],\n    ],\n);\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDraw a clock.\n\nMore specific:\n\n1. Draw a time keeping device. It can be a stopwatch, hourglass, sundial, a mouth counting \"one thousand and one\", anything. Only showing the seconds is required, e.g.: a watch with just a second hand will suffice. However, it must clearly change every second, and the change must cycle every so often (one minute, 30 seconds, etc.) It must be *drawn*; printing a string of numbers to your terminal doesn't qualify. Both text-based and graphical drawing are OK.\n2. The clock is unlikely to be used to control space flights, so it needs not be hyper-accurate, but it should be usable, meaning if one can read the seconds off the clock, it must agree with the system clock.\n3. A clock is rarely (never?) a major application: don't be a CPU hog and poll the system timer every microsecond, use a proper timer/signal/event from your system or language instead. For a bad example, many OpenGL programs update the frame-buffer in a busy loop even if no redraw is needed, which is very undesirable for this task.\n4. A clock is rarely (never?) a major application: try to keep your code simple and to the point. Don't write something too elaborate or convoluted, instead do whatever is natural, concise and clear in your language.\n\nKey points\n\n* animate simple object\n* timed event\n* polling system resources\n* code clarity"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy ($rows,$cols) = qx/stty size/.words;\nmy $v = floor $rows / 2;\nmy $h = floor $cols / 2 - 16;\n\nmy @t = < ⡎⢉⢵ ⠀⢺⠀ ⠊⠉⡱ ⠊⣉⡱ ⢀⠔⡇ ⣏⣉⡉ ⣎⣉⡁ ⠊⢉⠝ ⢎⣉⡱ ⡎⠉⢱ ⠀⠶⠀>;\nmy @b = < ⢗⣁⡸ ⢀⣸⣀ ⣔⣉⣀ ⢄⣀⡸ ⠉⠉⡏ ⢄⣀⡸ ⢇⣀⡸ ⢰⠁⠀ ⢇⣀⡸ ⢈⣉⡹ ⠀⠶⠀>;\n\nloop {\n    my @x = DateTime.now.Str.substr(11,8).ords X- ord('0');\n    print \"\\e[H\\e[J\";\n    print \"\\e[$v;{$h}H\";\n    print ~@t[@x];\n    print \"\\e[{$v+1};{$h}H\";\n    print ~@b[@x];\n    print \"\\e[H\";\n    sleep 1;\n}\n\n```\n\nOutput:\n\n```\n⠀⢺⠀ ⢀⠔⡇ ⠀⠶⠀ ⠊⠉⡱ ⠊⣉⡱ ⠀⠶⠀ ⣏⣉⡉ ⡎⢉⢵\n⢀⣸⣀ ⠉⠉⡏ ⠀⠶⠀ ⣔⣉⣀ ⢄⣀⡸ ⠀⠶⠀ ⢄⣀⡸ ⢗⣁⡸\n```\n\nA simpler version that does not clear the screen:\n\n```\nconstant @t = < ⡎⢉⢵ ⠀⢺⠀ ⠊⠉⡱ ⠊⣉⡱ ⢀⠔⡇ ⣏⣉⡉ ⣎⣉⡁ ⠊⢉⠝ ⢎⣉⡱ ⡎⠉⢱ ⠀⠶⠀>;\nconstant @b = < ⢗⣁⡸ ⢀⣸⣀ ⣔⣉⣀ ⢄⣀⡸ ⠉⠉⡏ ⢄⣀⡸ ⢇⣀⡸ ⢰⠁⠀ ⢇⣀⡸ ⢈⣉⡹ ⠀⠶⠀>;\n\nsignal(SIGINT).tap: { print \"\\e[?25h\\n\"; exit }\nprint \"\\e7\\e[?25l\"; # saves cursor position, make it invisible\nloop {\n    my @x = DateTime.now.Str.substr(11,8).ords X- ord('0');\n    put ~.[@x] for @t, @b;\n    sleep 1;\n    print \"\\e8\"; # restores cursor position\n}\n\n```\n\nFinally a more minimalist version that shows three progress bars (hours, minutes, seconds):\n\n```\nprint \"\\e7\";\nloop {\n    my $time = DateTime.now;\n    put '#' x $_ ~ '.' x (24 - $_) given $time.hour.round;\n    put '#' x $_ ~ '.' x (60 - $_) given $time.minute.round;\n    put '#' x $_ ~ '.' x (60 - $_) given $time.second.round;\n    sleep 1;\n    print \"\\e8\";\n}\nEND put \"\\n\";\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDraw a   cuboid   with relative dimensions of    2 × 3 × 4.\n\nThe cuboid can be represented graphically, or in   ASCII art,   depending on the language capabilities.\n\nTo fulfill the criteria of being a cuboid, three faces must be visible.\n\nEither static or rotational projection is acceptable for this task.\n\nRelated tasks\n\n* draw a sphere\n* draw a rotating cube\n* write language name in 3D ASCII\n* draw a Deathstar"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: moar version 2015-11-27\n\n```\nsub braille-graphics (%a) {\n    my ($ylo, $yhi, $xlo, $xhi);\n    for %a.keys -> $y {\n\t$ylo min= +$y; $yhi max= +$y;\n\tfor %a{$y}.keys -> $x {\n\t    $xlo min= +$x; $xhi max= +$x;\n\t}\n    }\n\n    for $ylo, $ylo + 4 ...^ * > $yhi -> \\y {\n\tfor $xlo, $xlo + 2 ...^ * > $xhi -> \\x {\n\t    my $cell = 0x2800;\n\t    $cell += 1   if %a{y + 0}{x + 0};\n\t    $cell += 2   if %a{y + 1}{x + 0};\n\t    $cell += 4   if %a{y + 2}{x + 0};\n\t    $cell += 8   if %a{y + 0}{x + 1};\n\t    $cell += 16  if %a{y + 1}{x + 1};\n\t    $cell += 32  if %a{y + 2}{x + 1};\n\t    $cell += 64  if %a{y + 3}{x + 0};\n\t    $cell += 128 if %a{y + 3}{x + 1};\n\t    print chr($cell);\n\t}\n\tprint \"\\n\";\n    }\n}\n\nsub cuboid ( [$x, $y, $z] ) {\n    my \\x = $x * 4;\n    my \\y = $y * 4;\n    my \\z = $z * 2;\n    my %t;\n    sub horz ($X, $Y) { %t{$Y     }{$X + $_} = True for 0 .. x }\n    sub vert ($X, $Y) { %t{$Y + $_}{$X     } = True for 0 .. y }\n    sub diag ($X, $Y) { %t{$Y - $_}{$X + $_} = True for 0 .. z }\n \n    horz(0, z); horz(z, 0); horz(  0, z+y);\n    vert(0, z); vert(x, z); vert(z+x,   0);\n    diag(0, z); diag(x, z); diag(  x, z+y);\n \n    say \"[$x, $y, $z]\";\n    braille-graphics %t;\n}\n \ncuboid $_ for [2,3,4], [3,4,2], [4,2,3], [1,1,1], [8,1,1], [1,8,1], [1,1,8];\n\n```\n\nOutput:"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a window and draw a pixel in it, subject to the following:\n\n:   :   1. the window is 320 x 240\n        2. the color of the pixel must be red (255,0,0)\n        3. the position of the pixel is x = 100, y = 100"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.05\n\nReally? Draw a single pixel? Sigh.\n\n```\nuse GTK::Simple;\nuse GTK::Simple::DrawingArea;\nuse Cairo;\n\nmy $app = GTK::Simple::App.new(:title('Draw a Pixel'));\nmy $da  = GTK::Simple::DrawingArea.new;\ngtk_simple_use_cairo;\n\n$app.set-content( $da );\n$app.border-width = 5;\n$da.size-request(320,240);\n\nsub rect-do( $d, $ctx ) {\n    given $ctx {\n        .rgb(1, 0, 0);\n        .rectangle(100, 100, 1, 1);\n        .fill;\n    }\n}\n\nmy $ctx = $da.add-draw-handler( &rect-do );\n$app.run;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDraw a rotating cube.\n\nIt should be oriented with one vertex pointing straight up, and its opposite vertex on the main diagonal (the one farthest away) straight down. It can be solid or wire-frame, and you can use ASCII art if your language doesn't have graphical capabilities. Perspective is optional.\n\nRelated tasks\n\n* Draw a cuboid\n* write language name in 3D ASCII"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nRaku has no native graphics libraries built in, but makes it fairly easy to bind to third party libraries. Here we'll use bindings to Libcaca, the **C**olor **A**S**C**II **A**rt library to generate a rotating cube in an ASCII terminal.\n\n```\nuse Terminal::Caca;\ngiven my $canvas = Terminal::Caca.new {\n    .title('Rosetta Code - Rotating cube - Press any key to exit');\n\n    sub scale-and-translate($x, $y, $z) {\n        $x * 5 / ( 5 + $z ) * 15 + 40,\n        $y * 5 / ( 5 + $z ) *  7 + 15,\n        $z;\n    }\n\n    sub rotate3d-x( $x, $y, $z, $angle ) {\n        my ($cosθ, $sinθ) = cis( $angle * π / 180.0 ).reals;\n        $x,\n        $y * $cosθ - $z * $sinθ,\n        $y * $sinθ + $z * $cosθ;\n    }\n\n    sub rotate3d-y( $x, $y, $z, $angle ) {\n        my ($cosθ, $sinθ) = cis( $angle * π / 180.0 ).reals;\n        $x * $cosθ - $z * $sinθ,\n        $y,\n        $x * $sinθ + $z * $cosθ;\n    }\n\n    sub rotate3d-z( $x, $y, $z, $angle ) {\n        my ($cosθ, $sinθ) = cis( $angle * π / 180.0 ).reals;\n        $x * $cosθ - $y * $sinθ,\n        $x * $cosθ + $y * $sinθ,\n        $z;\n    }\n\n    # Unit cube from polygon mesh, aligned to axes\n    my @mesh =\n      [ [1, 1, -1], [-1, -1, -1], [-1,  1, -1] ], # far face\n      [ [1, 1, -1], [-1, -1, -1], [ 1, -1, -1] ],\n      [ [1, 1,  1], [-1, -1,  1], [-1,  1,  1] ], # near face\n      [ [1, 1,  1], [-1, -1,  1], [ 1, -1,  1] ];\n      @mesh.push: [$_».rotate( 1)».Array] for @mesh[^4]; # positive and\n      @mesh.push: [$_».rotate(-1)».Array] for @mesh[^4]; # negative rotations\n\n    # Rotate to correct orientation for task\n    for ^@mesh X ^@mesh[0] -> ($i, $j) {\n        @(@mesh[$i;$j]) = rotate3d-x |@mesh[$i;$j], 45;\n        @(@mesh[$i;$j]) = rotate3d-z |@mesh[$i;$j], 40;\n    }\n\n    my @colors = red, blue, green, cyan, magenta, yellow;\n\n    loop {\n        for ^359 -> $angle {\n            .color( white, white );\n            .clear;\n\n            # Flatten 3D into 2D and rotate for all faces\n            my @faces-z;\n            my $c-index = 0;\n            for @mesh -> @triangle {\n                my @points;\n                my $sum-z = 0;\n                for @triangle -> @node {\n                    my ($px, $py, $z) = scale-and-translate |rotate3d-y |@node, $angle;\n                    @points.append: $px.Int, $py.Int;\n                    $sum-z += $z;\n                }\n\n                @faces-z.push: %(\n                    color  => @colors[$c-index++ div 2],\n                    points => @points,\n                    avg-z  => $sum-z / +@points;\n                );\n            }\n\n            # Draw all faces\n            # Sort by z to draw farthest first\n            for @faces-z.sort( -*.<avg-z> ) -> %face {\n                # Draw filled triangle\n                .color( %face<color>, %face<color> );\n                .fill-triangle( |%face<points> );\n                # And frame\n                .color( black, black );\n                .thin-triangle( |%face<points> );\n            }\n\n            .refresh;\n            exit if .wait-for-event(key-press);\n        }\n    }\n\n    # Cleanup on scope exit\n    LEAVE {\n        .cleanup;\n    }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDraw a sphere.\n\nThe sphere can be represented graphically, or in ASCII art, depending on the language capabilities.\n\nEither static or rotational projection is acceptable for this task.\n\nRelated tasks\n\n* draw a cuboid\n* draw a rotating cube\n* write language name in 3D ASCII\n* draw a Deathstar"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Pure Raku\n\n**Translation of**: C\n\nThe C code is modified to output a .pgm file.\n\n**Works with**: Rakudo version 2018.10\n\n```\nmy $width = my $height = 255; # must be odd\n\nmy @light = normalize([ 3, 2, -5 ]);\n\nmy $depth = 255;\n\nsub MAIN ($outfile = 'sphere-perl6.pgm') {\n    spurt $outfile, \"P5\\n$width $height\\n$depth\\n\"; # .pgm header\n    my $out = open( $outfile, :a, :bin ) orelse .die;\n    $out.write( Blob.new(draw_sphere( ($width-1)/2, .9, .2) ) );\n    $out.close;\n}\n\nsub normalize (@vec) { @vec »/» ([+] @vec »*« @vec).sqrt }\n\nsub dot (@x, @y) { -([+] @x »*« @y) max 0 }\n\nsub draw_sphere ( $rad, $k, $ambient ) {\n    my @pixels[$height];\n    my $r2 = $rad * $rad;\n    my @range = -$rad .. $rad;\n    @range.hyper.map: -> $x {\n        my @row[$width];\n        @range.map: -> $y {\n            if (my $x2 = $x * $x) + (my $y2 = $y * $y) < $r2 {\n                my @vector = normalize([$x, $y, ($r2 - $x2 - $y2).sqrt]);\n                my $intensity = dot(@light, @vector) ** $k + $ambient;\n                my $pixel = (0 max ($intensity * $depth).Int) min $depth;\n                @row[$y+$rad] = $pixel;\n            }\n            else {\n                @row[$y+$rad] = 0;\n            }\n        }\n        @pixels[$x+$rad] = @row;\n    }\n    flat |@pixels.map: *.list;\n}\n\n```\n\n### Cairo graphics library\n\n```\nuse Cairo;\n\ngiven Cairo::Image.create(Cairo::FORMAT_ARGB32, 256, 256) {\n    given Cairo::Context.new($_) {\n\n        my Cairo::Pattern::Solid $bg .= create(.5,.5,.5);\n        .rectangle(0, 0, 256, 256);\n        .pattern($bg);\n        .fill;\n        $bg.destroy;\n\n        my Cairo::Pattern::Gradient::Radial $shadow .=\n           create(105.2, 102.4, 15.6, 102.4,  102.4, 128.0);\n        $shadow.add_color_stop_rgba(0, .3, .3, .3, .3);\n        $shadow.add_color_stop_rgba(1, .1, .1, .1, .02);\n        .pattern($shadow);\n        .arc(136.0, 134.0, 110, 0, 2 * pi);\n        .fill;\n        $shadow.destroy;\n\n        my Cairo::Pattern::Gradient::Radial $sphere .=\n           create(115.2, 102.4, 25.6, 102.4,  102.4, 128.0);\n        $sphere.add_color_stop_rgba(0, 1, 1, .698, 1);\n        $sphere.add_color_stop_rgba(1, .923, .669, .144, 1);\n        .pattern($sphere);\n        .arc(128.0, 128.0, 110, 0, 2 * pi);\n        .fill;\n        $sphere.destroy;\n    };\n    .write_png('sphere2-perl6.png');\n}\n\n```\n\nSee sphere2-perl6.png (offsite .png image)"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a window and draw a pixel in it, subject to the following:\n\n:   :   1. the window is 640 x 480\n        2. the color of the pixel must be yellow (255,255,0)\n        3. the position of the pixel is random"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.05\n\nCoordinates of random pixel displayed in window title. To make the single pixel show up better I filled in the drawing area background with black to get better contrast.\n\n```\nuse GTK::Simple;\nuse GTK::Simple::DrawingArea;\nuse Cairo;\nmy ($w, $h) = 640, 480;\nmy ($x, $y) = (^$w).pick, (^$h).pick;\n\nmy $app = GTK::Simple::App.new(:title(\"Draw Pixel 2 @ $x,$y\"));\nmy $da  = GTK::Simple::DrawingArea.new;\ngtk_simple_use_cairo;\n\n$app.set-content( $da );\n$app.border-width = 5;\n$da.size-request($w, $h);\n\nsub rect-do( $d, $ctx ) {\n    given $ctx {\n        .rgb(0, 0, 0);\n        .rectangle(0, 0, $w, $h);\n        .fill;\n        .rgb(1, 1, 0);\n        .rectangle($x, $y, 1, 1);\n        .fill;\n    }\n}\n\nmy $ctx = $da.add-draw-handler( &rect-do );\n$app.run;\n\n```"}]}
{"messages": [{"role": "user", "content": "A **Duffinian number** is a composite number **k** that is relatively prime to its sigma sum **σ**.\n\n*The sigma sum of **k** is the sum of the divisors of **k**.*\n\nE.G.\n\n**161** is a **Duffinian number**.\n\n* It is composite. (7 × 23)\n* The sigma sum **192** (1 + 7 + 23 + 161) is relatively prime to **161**.\n\nDuffinian numbers are very common.\n\nIt is not uncommon for two consecutive integers to be Duffinian (a Duffinian twin) (8, 9), (35, 36), (49, 50), etc.\n\nLess common are Duffinian triplets; three consecutive Duffinian numbers. (63, 64, 65), (323, 324, 325), etc.\n\nMuch, much less common are Duffinian quadruplets and quintuplets. The first Duffinian quintuplet is (202605639573839041, 202605639573839042, 202605639573839043, 202605639573839044, 202605639573839045).\n\nIt is not possible to have six consecutive Duffinian numbers\n\nTask\n\n* Find and show the first 50 Duffinian numbers.\n* Find and show at least the first 15 Duffinian triplets.\n\nSee also\n\n* Numbers Aplenty - Duffinian numbers * OEIS:A003624 - Duffinian numbers: composite numbers k relatively prime to sigma(k)"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\n\nmy @duffinians = lazy (3..*).hyper.grep: { !.is-prime && $_ gcd .&divisors.sum == 1 };\n\nput \"First 50 Duffinian numbers:\\n\" ~\n@duffinians[^50].batch(10)».fmt(\"%3d\").join: \"\\n\";\n\nput \"\\nFirst 40 Duffinian triplets:\\n\" ~\n    ((^∞).grep: -> $n { (@duffinians[$n] + 1 == @duffinians[$n + 1]) && (@duffinians[$n] + 2 == @duffinians[$n + 2]) })[^40]\\\n    .map( { \"({@duffinians[$_ .. $_+2].join: ', '})\" } ).batch(4)».fmt(\"%-24s\").join: \"\\n\";\n\n```\n\nOutput:\n\n```\nFirst 50 Duffinian numbers:\n  4   8   9  16  21  25  27  32  35  36\n 39  49  50  55  57  63  64  65  75  77\n 81  85  93  98 100 111 115 119 121 125\n128 129 133 143 144 155 161 169 171 175\n183 185 187 189 201 203 205 209 215 217\n\nFirst 40 Duffinian triplets:\n(63, 64, 65)             (323, 324, 325)          (511, 512, 513)          (721, 722, 723)         \n(899, 900, 901)          (1443, 1444, 1445)       (2303, 2304, 2305)       (2449, 2450, 2451)      \n(3599, 3600, 3601)       (3871, 3872, 3873)       (5183, 5184, 5185)       (5617, 5618, 5619)      \n(6049, 6050, 6051)       (6399, 6400, 6401)       (8449, 8450, 8451)       (10081, 10082, 10083)   \n(10403, 10404, 10405)    (11663, 11664, 11665)    (12481, 12482, 12483)    (13447, 13448, 13449)   \n(13777, 13778, 13779)    (15841, 15842, 15843)    (17423, 17424, 17425)    (19043, 19044, 19045)   \n(26911, 26912, 26913)    (30275, 30276, 30277)    (36863, 36864, 36865)    (42631, 42632, 42633)   \n(46655, 46656, 46657)    (47523, 47524, 47525)    (53137, 53138, 53139)    (58563, 58564, 58565)   \n(72961, 72962, 72963)    (76175, 76176, 76177)    (79523, 79524, 79525)    (84099, 84100, 84101)   \n(86527, 86528, 86529)    (94177, 94178, 94179)    (108899, 108900, 108901) (121103, 121104, 121105)\n```"}]}
{"messages": [{"role": "user", "content": "File:Dutch flag 3.jpg\n\nThe Dutch national flag is composed of three coloured bands in the order:\n\n:   :   * red     (top)\n        * then white,   and\n        * lastly blue   (at the bottom).\n\nThe problem posed by Edsger Dijkstra is:\n\n:   Given a number of red, blue and white balls in random order, arrange them in the order of the colours in the Dutch national flag.\n\nWhen the problem was first posed, Dijkstra then went on to successively refine a solution, minimising the number of swaps and the number of times the colour of a ball needed to determined and restricting the balls to end in an array, ...\n\nTask\n\n1. Generate a randomized order of balls *ensuring that they are not in the order of the Dutch national flag*.\n2. Sort the balls in a way idiomatic to your language.\n3. Check the sorted balls *are* in the order of the Dutch national flag.\n\nC.f.\n\n* Dutch national flag problem\n* Probabilistic analysis of algorithms for the Dutch national flag problem by Wei-Mei Chen. (pdf)"}, {"role": "assistant", "content": "(formerly Perl 6)\nHere are five ways to do it, all one liners (apart from the test apparatus).\n\n```\nenum NL <red white blue>;\nmy @colors;\n\nsub how'bout (&this-way) {\n    sub show {\n        say @colors;\n        say \"Ordered: \", [<=] @colors;\n    }\n\n    @colors = NL.roll(20);\n    show;\n    this-way;\n    show;\n    say '';\n}\n\nsay \"Using functional sort\";\nhow'bout { @colors = sort *.value, @colors }\n\nsay \"Using in-place sort\";\nhow'bout { @colors .= sort: *.value }\n\nsay \"Using a Bag\";\nhow'bout { @colors = flat red, white, blue Zxx bag(@colors».key)<red white blue> }\n\nsay \"Using the classify method\";\nhow'bout { @colors = flat (.list for %(@colors.classify: *.value){0,1,2}) }\n\nsay \"Using multiple greps\";\nhow'bout { @colors = flat (.grep(red), .grep(white), .grep(blue) given @colors) }\n\n```\n\nOutput:\n\n```\nUsing functional sort\nred red white white red red red red red red red white red white red red red white white white\nOrdered: False\nred red red red red red red red red red red red red white white white white white white white\nOrdered: True\n\nUsing in-place sort\nred blue white red white blue white blue red white blue blue blue red white white red blue red blue\nOrdered: False\nred red red red red red white white white white white white blue blue blue blue blue blue blue blue\nOrdered: True\n\nUsing a Bag\nred blue blue blue white red white red white blue blue red red red red blue blue red white blue\nOrdered: False\nred red red red red red red red white white white white blue blue blue blue blue blue blue blue\nOrdered: True\n\nUsing the classify method\nblue red white blue blue white white red blue red red white red blue white white red blue red white\nOrdered: False\nred red red red red red red white white white white white white white blue blue blue blue blue blue\nOrdered: True\n\nUsing multiple greps\nred white blue white white red blue white red white red white white white white white red red blue red\nOrdered: False\nred red red red red red red white white white white white white white white white white blue blue blue\nOrdered: True\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a variable with a user-defined name.\n\nThe variable name should *not* be written in the program text, but should be taken from the user dynamically.\n\nSee also\n\n* Eval in environment is a similar task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nYou can interpolate strings as variable names:\n\n```\nour $our-var = 'The our var';\nmy  $my-var  = 'The my var';\n\nmy $name  = prompt 'Variable name: ';\nmy $value = $::('name'); # use the right sigil, etc\n\nput qq/Var ($name) starts with value ｢$value｣/;\n\n$::('name') = 137;\n\nput qq/Var ($name) ends with value ｢{$::('name')}｣/;\n\n```"}]}
{"messages": [{"role": "user", "content": "When calculating prime numbers > 2, the difference between adjacent primes is always an even number. This difference, also referred to as the gap, varies in an random pattern; at least, no pattern has ever been discovered, and it is strongly conjectured that no pattern exists. However, it is also conjectured that between some two adjacent primes will be a gap corresponding to every positive even integer.\n\n| gap | minimal starting prime | ending prime |\n| --- | --- | --- |\n| 2 | 3 | 5 |\n| 4 | 7 | 11 |\n| 6 | 23 | 29 |\n| 8 | 89 | 97 |\n| 10 | 139 | 149 |\n| 12 | 199 | 211 |\n| 14 | 113 | 127 |\n| 16 | 1831 | 1847 |\n| 18 | 523 | 541 |\n| 20 | 887 | 907 |\n| 22 | 1129 | 1151 |\n| 24 | 1669 | 1693 |\n| 26 | 2477 | 2503 |\n| 28 | 2971 | 2999 |\n| 30 | 4297 | 4327 |\n\nThis task involves locating the minimal primes corresponding to those gaps.\n\nThough every gap value exists, they don't seem to come in any particular order. For example, this table shows the gaps and minimum starting value primes for 2 through 30:\n\nFor the purposes of this task, considering only primes greater than 2, consider prime gaps that differ by exactly two to be adjacent.\n\nTask\n\nFor each order of magnitude **m** from **10¹** through **10⁶**:\n\n* Find the first two sets of minimum adjacent prime gaps where the absolute value of the difference between the prime gap start values is greater than **m**.\n\nE.G.\n\nFor an **m** of **10¹**;\n\nThe start value of gap 2 is 3, the start value of gap 4 is 7, the difference is 7 - 3 or 4. 4 < **10¹** so keep going.\n\nThe start value of gap 4 is 7, the start value of gap 6 is 23, the difference is 23 - 7, or 16. 16 > **10¹** so this the earliest adjacent gap difference > **10¹**.\n\nStretch goal\n\n* Do the same for **10⁷** and **10⁸** (and higher?) orders of magnitude\n\nNote: the earliest value found for each order of magnitude may not be unique, in fact, *is* not unique; also, with the gaps in ascending order, the minimal starting values are not strictly ascending."}, {"role": "assistant", "content": "1e1 through 1e7 are pretty speedy (less than 5 seconds total). 1e8 and 1e9 take several minutes.\n\n```\nuse Math::Primesieve;\nuse Lingua::EN::Numbers;\n\nmy $iterator = Math::Primesieve::iterator.new;\nmy @gaps;\nmy $last = 2;\n\nfor 1..9 {\n    my $m = exp $_, 10;\n    my $this;\n    loop {\n        $this = (my $p = $iterator.next) - $last;\n        if !@gaps[$this].defined {\n             @gaps[$this]= $last;\n             check-gap($m, $this, @gaps) && last\n               if $this > 2 and @gaps[$this - 2].defined and (abs($last - @gaps[$this - 2]) > $m);\n        }\n        $last = $p;\n    }\n}\n\nsub check-gap ($n, $this, @p) {\n    my %upto = @p[^$this].pairs.grep: *.value;\n    my @upto = (1..$this).map: { last unless %upto{$_ * 2}; %upto{$_ * 2} }\n    my $key = @upto.rotor(2=>-1).first( {.sink; abs(.[0] - .[1]) > $n}, :k );\n    return False unless $key;\n    say \"Earliest difference > {comma $n} between adjacent prime gap starting primes:\";\n    printf \"Gap %s starts at %s, gap %s starts at %s, difference is %s\\n\\n\",\n    |(2 * $key + 2, @upto[$key], 2 * $key + 4, @upto[$key+1], abs(@upto[$key] - @upto[$key+1]))».&comma;\n    True\n}\n\n```\n\nOutput:\n\n```\nEarliest difference > 10 between adjacent prime gap starting primes:\nGap 4 starts at 7, gap 6 starts at 23, difference is 16\n\nEarliest difference > 100 between adjacent prime gap starting primes:\nGap 14 starts at 113, gap 16 starts at 1,831, difference is 1,718\n\nEarliest difference > 1,000 between adjacent prime gap starting primes:\nGap 14 starts at 113, gap 16 starts at 1,831, difference is 1,718\n\nEarliest difference > 10,000 between adjacent prime gap starting primes:\nGap 36 starts at 9,551, gap 38 starts at 30,593, difference is 21,042\n\nEarliest difference > 100,000 between adjacent prime gap starting primes:\nGap 70 starts at 173,359, gap 72 starts at 31,397, difference is 141,962\n\nEarliest difference > 1,000,000 between adjacent prime gap starting primes:\nGap 100 starts at 396,733, gap 102 starts at 1,444,309, difference is 1,047,576\n\nEarliest difference > 10,000,000 between adjacent prime gap starting primes:\nGap 148 starts at 2,010,733, gap 150 starts at 13,626,257, difference is 11,615,524\n\nEarliest difference > 100,000,000 between adjacent prime gap starting primes:\nGap 198 starts at 46,006,769, gap 200 starts at 378,043,979, difference is 332,037,210\n\nEarliest difference > 1,000,000,000 between adjacent prime gap starting primes:\nGap 276 starts at 649,580,171, gap 278 starts at 4,260,928,601, difference is 3,611,348,430\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nAn   **eban**   number is a number that has no letter    **e**    in it when the number is spelled in English.\n\nOr more literally,   spelled numbers that contain the letter   **e**   are banned.\n\nThe American version of spelling numbers will be used here   (as opposed to the British).\n\n**2,000,000,000**   is two billion,   *not*   two milliard.\n\nOnly numbers less than   **one sextillion**   (**1021**)   will be considered in/for this task.\n\nThis will allow optimizations to be used.\n\nTask\n:   :   :   * show all eban numbers   ≤   **1,000**   (in a horizontal format),   and a count\n            * show all eban numbers between   **1,000**   and   **4,000**   (inclusive),   and a count\n            * show a count of all eban numbers up and including           **10,000**\n            * show a count of all eban numbers up and including         **100,000**\n            * show a count of all eban numbers up and including      **1,000,000**\n            * show a count of all eban numbers up and including    **10,000,000**\n            * show all output here.\n\nSee also\n:   * The MathWorld entry:   eban numbers.\n    * The OEIS entry:   A6933, eban numbers.\n    * Number names."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nModular approach, very little is hard coded. Change the $upto order-of-magnitude limit to adjust the search/display ranges. Change the letter(s) given to the enumerate / count subs to modify which letter(s) to disallow.\n\nWill handle multi-character 'bans'. Demonstrate for e-ban, t-ban and subur-ban.\n\nDirectly find :\n\n:   * OEIS:A006933 Numbers without e: Eban\n    * OEIS:A008521 Numbers without o: Oban\n    * OEIS:A008523 Numbers without t: Tban\n    * OEIS:A072954 Numbers without a, i, l, t: TALIban\n    * OEIS:A072955 Numbers without b, r, s, u: SUBURban\n    * OEIS:A072956 Numbers without r, t, u: TURban\n    * OEIS:A072957 Numbers without r, u: URban\n    * OEIS:A072958 Numbers without a, c, i, l: CALIban\n    * OEIS:A089589 Numbers without i: Iban\n    * OEIS:A089590 Numbers without u: Uban\n    * *and so on...*\n\nConsidering numbers up to **1021**, as the task directions suggest.\n\n```\nuse Lingua::EN::Numbers;\n\nsub nban ($seq, $n = 'e') { ($seq).map: { next if .&cardinal.contains(any($n.lc.comb)); $_ } }\n\nsub enumerate ($n, $upto) {\n    my @ban = [nban(1 .. 99, $n)],;\n    my @orders;\n    (2 .. $upto).map: -> $o {\n        given $o % 3 { # Compensate for irregulars: 11 - 19\n            when 1  { @orders.push: [flat (10**($o - 1) X* 10 .. 19).map(*.&nban($n)), |(10**$o X* 2 .. 9).map: *.&nban($n)] }\n            default { @orders.push: [flat (10**$o X* 1 .. 9).map: *.&nban($n)] }\n        }\n    }\n    ^@orders .map: -> $o {\n        @ban.push: [] and next unless +@orders[$o];\n        my @these;\n        @orders[$o].map: -> $m {\n            @these.push: $m;\n            for ^@ban -> $b {\n                next unless +@ban[$b];\n                @these.push: $_ for (flat @ban[$b]) »+» $m ;\n            }\n        }\n        @ban.push: @these;\n    }\n    @ban.unshift(0) if nban(0, $n);\n    flat @ban.map: *.flat;\n}\n\nsub count ($n, $upto) {\n    my @orders;\n    (2 .. $upto).map: -> $o {\n        given $o % 3 { # Compensate for irregulars: 11 - 19\n            when 1  { @orders.push: [flat (10**($o - 1) X* 10 .. 19).map(*.&nban($n)), |(10**$o X* 2 .. 9).map: *.&nban($n)] }\n            default { @orders.push: [flat (10**$o X* 1 .. 9).map: *.&nban($n)] }\n        }\n    }\n    my @count  = +nban(1 .. 99, $n);\n    ^@orders .map: -> $o {\n        @count.push: 0 and next unless +@orders[$o];\n        my $prev = so (@orders[$o].first( { $_ ~~ /^ '1' '0'+ $/ } ) // 0 );\n        my $sum = @count.sum;\n        my $these = +@orders[$o] * $sum + @orders[$o];\n        $these-- if $prev;\n        @count[1 + $o] += $these;\n        ++@count[$o]  if $prev;\n    }\n    ++@count[0] if nban(0, $n);\n    [\\+] @count;\n}\n\n#for < e o t tali subur tur ur cali i u > -> $n { # All of them\nfor < e t subur > -> $n { # An assortment for demonstration\n    my $upto   = 21; # 1e21\n    my @bans   = enumerate($n, 4);\n    my @counts = count($n, $upto);\n\n    # DISPLAY\n    my @k = @bans.grep: * < 1000;\n    my @j = @bans.grep: 1000 <= * <= 4000;\n    put \"\\n============= {$n}-ban: =============\\n\" ~\n        \"{$n}-ban numbers up to 1000: {+@k}\\n[{@k».&comma}]\\n\\n\" ~\n        \"{$n}-ban numbers between 1,000 & 4,000: {+@j}\\n[{@j».&comma}]\\n\" ~\n        \"\\nCounts of {$n}-ban numbers up to {cardinal 10**$upto}\"\n        ;\n\n    my $s = max (1..$upto).map: { (10**$_).&cardinal.chars };\n    @counts.unshift: @bans.first: * > 10, :k;\n    for ^$upto -> $c {\n        printf \"Up to and including %{$s}s: %s\\n\", cardinal(10**($c+1)), comma(@counts[$c]);\n    }\n}\n\n```\n\nOutput:\n\n```\n============= e-ban: =============\ne-ban numbers up to 1000: 19\n[2 4 6 30 32 34 36 40 42 44 46 50 52 54 56 60 62 64 66]\n\ne-ban numbers between 1,000 & 4,000: 21\n[2,000 2,002 2,004 2,006 2,030 2,032 2,034 2,036 2,040 2,042 2,044 2,046 2,050 2,052 2,054 2,056 2,060 2,062 2,064 2,066 4,000]\n\nCounts of e-ban numbers up to one sextillion\nUp to and including                     ten: 3\nUp to and including             one hundred: 19\nUp to and including            one thousand: 19\nUp to and including            ten thousand: 79\nUp to and including    one hundred thousand: 399\nUp to and including             one million: 399\nUp to and including             ten million: 1,599\nUp to and including     one hundred million: 7,999\nUp to and including             one billion: 7,999\nUp to and including             ten billion: 31,999\nUp to and including     one hundred billion: 159,999\nUp to and including            one trillion: 159,999\nUp to and including            ten trillion: 639,999\nUp to and including    one hundred trillion: 3,199,999\nUp to and including         one quadrillion: 3,199,999\nUp to and including         ten quadrillion: 12,799,999\nUp to and including one hundred quadrillion: 63,999,999\nUp to and including         one quintillion: 63,999,999\nUp to and including         ten quintillion: 255,999,999\nUp to and including one hundred quintillion: 1,279,999,999\nUp to and including          one sextillion: 1,279,999,999\n\n============= t-ban: =============\nt-ban numbers up to 1000: 56\n[0 1 4 5 6 7 9 11 100 101 104 105 106 107 109 111 400 401 404 405 406 407 409 411 500 501 504 505 506 507 509 511 600 601 604 605 606 607 609 611 700 701 704 705 706 707 709 711 900 901 904 905 906 907 909 911]\n\nt-ban numbers between 1,000 & 4,000: 0\n[]\n\nCounts of t-ban numbers up to one sextillion\nUp to and including                     ten: 7\nUp to and including             one hundred: 9\nUp to and including            one thousand: 56\nUp to and including            ten thousand: 56\nUp to and including    one hundred thousand: 56\nUp to and including             one million: 57\nUp to and including             ten million: 392\nUp to and including     one hundred million: 785\nUp to and including             one billion: 5,489\nUp to and including             ten billion: 38,416\nUp to and including     one hundred billion: 76,833\nUp to and including            one trillion: 537,824\nUp to and including            ten trillion: 537,824\nUp to and including    one hundred trillion: 537,824\nUp to and including         one quadrillion: 537,825\nUp to and including         ten quadrillion: 3,764,768\nUp to and including one hundred quadrillion: 7,529,537\nUp to and including         one quintillion: 52,706,752\nUp to and including         ten quintillion: 52,706,752\nUp to and including one hundred quintillion: 52,706,752\nUp to and including          one sextillion: 52,706,752\n\n============= subur-ban: =============\nsubur-ban numbers up to 1000: 35\n[1 2 5 8 9 10 11 12 15 18 19 20 21 22 25 28 29 50 51 52 55 58 59 80 81 82 85 88 89 90 91 92 95 98 99]\n\nsubur-ban numbers between 1,000 & 4,000: 0\n[]\n\nCounts of subur-ban numbers up to one sextillion\nUp to and including                     ten: 6\nUp to and including             one hundred: 35\nUp to and including            one thousand: 35\nUp to and including            ten thousand: 35\nUp to and including    one hundred thousand: 35\nUp to and including             one million: 36\nUp to and including             ten million: 216\nUp to and including     one hundred million: 2,375\nUp to and including             one billion: 2,375\nUp to and including             ten billion: 2,375\nUp to and including     one hundred billion: 2,375\nUp to and including            one trillion: 2,375\nUp to and including            ten trillion: 2,375\nUp to and including    one hundred trillion: 2,375\nUp to and including         one quadrillion: 2,375\nUp to and including         ten quadrillion: 2,375\nUp to and including one hundred quadrillion: 2,375\nUp to and including         one quintillion: 2,375\nUp to and including         ten quintillion: 2,375\nUp to and including one hundred quintillion: 2,375\nUp to and including          one sextillion: 2,375\n```\n\nNote that the limit to one sextillion is somewhat arbitrary and is just to match the task parameters.\n\nThis will quite happily count \\*-bans up to one hundred centillion. (10305) It takes longer, but still on the order of seconds, not minutes.\n\n```\nCounts of e-ban numbers up to one hundred centillion\n ...\nUp to and including one hundred centillion: 35,184,372,088,831,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999\n```"}]}
{"messages": [{"role": "user", "content": "Create a network service that sits on TCP port 12321, which accepts connections on that port, and which echoes complete lines (using a carriage-return/line-feed sequence as line separator) back to clients. No error handling is required. For the purposes of testing, it is only necessary to support connections from localhost (127.0.0.1 or perhaps ::1). Logging of connection information to standard output is recommended.\n\nThe implementation must be able to handle simultaneous connections from multiple clients. A multi-threaded or multi-process solution may be used. Each connection must be able to echo more than a single line.\n\nThe implementation must not stop responding to other clients if one client sends a partial line or stops reading responses."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n```\nmy $socket = IO::Socket::INET.new:\n    :localhost<localhost>,\n    :localport<12321>,\n    :listen;\n\nwhile $socket.accept -> $conn {\n    say \"Accepted connection\";\n    start {\n        while $conn.recv -> $stuff {\n            say \"Echoing $stuff\";\n            $conn.print($stuff);\n        }\n        $conn.close;\n    }\n}\n\n```\n\nAsync version:\n\n```\nreact {\n    whenever IO::Socket::Async.listen('0.0.0.0', 12321) -> $conn {\n        whenever $conn.Supply.lines -> $line {\n            $conn.print( \"$line\\n\" ) ;\n        }\n    }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "An **eertree** is a data structure designed for efficient processing of certain palindrome tasks, for instance counting the number of sub-palindromes in an input string.\n\nThe data structure has commonalities to both *tries* and *suffix trees*.\n  See links below.\n\nTask\n\nConstruct an eertree for the string \"eertree\", then output all sub-palindromes by traversing the tree.\n\nSee also\n\n* Wikipedia entry:   trie.\n* Wikipedia entry:   suffix tree\n* Cornell University Library, Computer Science, Data Structures and Algorithms ───► EERTREE: An Efficient Data Structure for Processing Palindromes in Strings.\n* EERTREE: An efficient data structure for processing palindromes in strings[1]"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Ring\n\n```\nmy $str = \"eertree\";\nmy @pal = ();\nmy ($strrev,$strpal);\n\nfor (1 .. $str.chars) -> $n {\n   for (1 .. $str.chars) -> $m {\n      $strrev = \"\";\n      $strpal = $str.substr($n-1, $m);\n      if ($strpal ne \"\") {\n         for ($strpal.chars ... 1) -> $p {\n            $strrev ~= $strpal.substr($p-1,1);\n         }\n         ($strpal eq $strrev) and @pal.push($strpal);\n      }\n   }\n}\n\nsay @pal.unique;\n\n```\n\nOutput:\n\n```\n(e ee eertree ertre r rtr t)\n\n```"}]}
{"messages": [{"role": "user", "content": "Egyptian division is a method of dividing integers using addition and\ndoubling that is similar to the algorithm of Ethiopian multiplication\n\n**Algorithm:**\n\nGiven two numbers where the **dividend** is to be divided by the **divisor**:\n\n1. Start the construction of a table of two columns: **`powers_of_2`**, and **`doublings`**; by a first row of a 1 (i.e. 2^0) in the first column and 1 times the divisor in the first row second column.\n2. Create the second row with columns of 2 (i.e 2^1), and 2 \\* divisor in order.\n3. Continue with successive i’th rows of 2^i and 2^i \\* divisor.\n4. Stop adding rows, and keep only those rows, where 2^i \\* divisor is less than or equal to the dividend.\n5. We now assemble two separate sums that both start as zero, called here **answer** and **accumulator**\n6. Consider each row of the table, in the *reverse* order of its construction.\n7. If the current value of the accumulator added to the doublings cell would be less than or equal to the dividend then add it to the accumulator, as well as adding the powers\\_of\\_2 cell value to the answer.\n8. When the first row has been considered as above, then the integer division of dividend by divisor is given by answer.  \n    (And the remainder is given by the absolute value of accumulator - dividend).\n\n**Example: 580 / 34**\n\n**Table creation:**\n\n:   :   :   | powers\\_of\\_2 | doublings |\n            | --- | --- |\n            | 1 | 34 |\n            | 2 | 68 |\n            | 4 | 136 |\n            | 8 | 272 |\n            | 16 | 544 |\n\n**Initialization of sums:**\n\n:   :   :   | powers\\_of\\_2 | doublings | answer | accumulator |\n            | --- | --- | --- | --- |\n            | 1 | 34 |  |  |\n            | 2 | 68 |  |  |\n            | 4 | 136 |  |  |\n            | 8 | 272 |  |  |\n            | 16 | 544 |  |  |\n            |  |  | 0 | 0 |\n\n**Considering table rows, bottom-up:**\n\nWhen a row is considered it is shown ~~crossed out~~ if it is not accumulated, or **bold** if the row causes summations.\n\n:   :   :   | powers\\_of\\_2 | doublings | answer | accumulator |\n            | --- | --- | --- | --- |\n            | 1 | 34 |  |  |\n            | 2 | 68 |  |  |\n            | 4 | 136 |  |  |\n            | 8 | 272 |  |  |\n            | **16** | **544** | 16 | 544 |\n\n:   :   :   | powers\\_of\\_2 | doublings | answer | accumulator |\n            | --- | --- | --- | --- |\n            | 1 | 34 |  |  |\n            | 2 | 68 |  |  |\n            | 4 | 136 |  |  |\n            | ~~8~~ | ~~272~~ | 16 | 544 |\n            | **16** | **544** |  |  |\n\n:   :   :   | powers\\_of\\_2 | doublings | answer | accumulator |\n            | --- | --- | --- | --- |\n            | 1 | 34 |  |  |\n            | 2 | 68 |  |  |\n            | ~~4~~ | ~~136~~ | 16 | 544 |\n            | ~~8~~ | ~~272~~ |  |  |\n            | **16** | **544** |  |  |\n\n:   :   :   | powers\\_of\\_2 | doublings | answer | accumulator |\n            | --- | --- | --- | --- |\n            | 1 | 34 |  |  |\n            | ~~2~~ | ~~68~~ | 16 | 544 |\n            | ~~4~~ | ~~136~~ |  |  |\n            | ~~8~~ | ~~272~~ |  |  |\n            | **16** | **544** |  |  |\n\n:   :   :   | powers\\_of\\_2 | doublings | answer | accumulator |\n            | --- | --- | --- | --- |\n            | **1** | **34** | 17 | 578 |\n            | ~~2~~ | ~~68~~ |  |  |\n            | ~~4~~ | ~~136~~ |  |  |\n            | ~~8~~ | ~~272~~ |  |  |\n            | **16** | **544** |  |  |\n\nAnswer\n\nSo 580 divided by 34 using the Egyptian method is **`17`** remainder (578 - 580) or **`2`**.\n\nTask\n\nThe task is to create a function that does Egyptian division. The function should  \nclosely follow the description above in using a list/array of powers of two, and  \nanother of doublings.\n\n* Functions should be clear interpretations of the algorithm.\n* Use the function to divide 580 by 34 and show the answer **here, on this page**.\n\nRelated tasks\n:   * Egyptian fractions\n    * Ethiopian multiplication\n\nReferences\n:   * Egyptian Number System"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.07\n\n### Normal version\n\nOnly works with positive real numbers, not negative or complex.\n\n```\nsub egyptian-divmod (Real $dividend is copy where * >= 0, Real $divisor where * > 0) {\n    my $accumulator = 0;\n    ([1, $divisor], { [.[0] + .[0], .[1] + .[1]] } … ^ *.[1] > $dividend)\n      .reverse.map: { $dividend -= .[1], $accumulator += .[0] if $dividend >= .[1] }\n    $accumulator, $dividend;\n}\n \n#TESTING\nfor 580,34, 578,34, 7532795332300578,235117 -> $n, $d {\n    printf \"%s divmod %s = %s remainder %s\\n\",\n        $n, $d, |egyptian-divmod( $n, $d )\n}\n\n```\n\nOutput:\n\n```\n580 divmod 34 = 17 remainder 2\n578 divmod 34 = 17 remainder 0\n7532795332300578 divmod 235117 = 32038497141 remainder 81\n```\n\n### More \"Egyptian\" version\n\nAs a preceding version was determined to be \"let's just say ... not Egyptian\" we submit an alternate which is hopefully more \"Egyptian\". Now only handles positive Integers up to 10 million, mostly due to limitations on Egyptian notation for numbers.\n\nNote: if the below is just a mass of \"unknown glyph\" boxes, try installing Googles free Noto Sans Egyptian Hieroglyphs font.\n\nThis is intended to be humorous and should not be regarded as good (or even sane) programming practice. That being said, 𓂽 & 𓂻 really are the ancient Egyptian symbols for addition and subtraction, and the Egyptian number notation is as accurate as possible. Everything else owes more to whimsy than rigor.\n\n```\nmy (\\𓄤, \\𓄊, \\𓎆, \\𓄰) = (0, 1, 10, 10e7);\nsub infix:<𓂽> { $^𓃠 + $^𓃟 }\nsub infix:<𓂻> { $^𓃲 - $^𓆊 }\nsub infix:<𓈝> { $^𓃕 < $^𓃢 }\nsub 𓁶 (Int \\𓆉) {\n    my \\𓁢 = [«'' 𓏺 𓏻 𓏼 𓏽 𓏾 𓏿 𓐀 𓐁 𓐂»], [«'' 𓎆 𓎏 𓎐 𓎑 𓎊 𓎋 𓎌 𓎍 𓎎»],\n      [«'' 𓍢 𓍣 𓍤 𓍥 𓍦 𓍧 𓍨 𓍩 𓍪»], [«'' 𓆼 𓆽 𓆾 𓆿 𓇀 𓇁 𓇂 𓇃 𓇄»],\n      [«'' 𓂭 𓂮 𓂯 𓂰 𓂱 𓂲 𓂳 𓂴 𓂵»], ['𓆐' Xx ^𓎆], ['𓁨' Xx ^𓎆];\n    ([~] 𓆉.polymod( 𓎆 xx * ).map( { 𓁢[$++;$_] } ).reverse) || '𓄤'\n}\n\nsub infix:<𓅓> (Int $𓂀 is copy where 𓄤 𓂻 𓄊 𓈝 * 𓈝 𓄰, Int \\𓌳 where 𓄤 𓈝 * 𓈝 𓄰) {\n    my $𓎦 = 𓄤;\n    ([𓄊,𓌳], { [.[𓄤] 𓂽 .[𓄤], .[𓄊] 𓂽 .[𓄊]] } … ^$𓂀 𓈝 *.[𓄊])\n      .reverse.map: { $𓂀 𓂻= .[𓄊], $𓎦 𓂽= .[𓄤] if .[𓄊] 𓈝 ($𓂀 𓂽 𓄊) }\n    $𓎦, $𓂀;\n}\n\n#TESTING\nfor 580,34, 578,34, 2300578,23517 -> \\𓃾, \\𓆙 {\n    printf \"%s divmod %s = %s remainder %s =OR= %s 𓅓 %s = %s remainder %s\\n\",\n        𓃾, 𓆙, |(𓃾 𓅓 𓆙), (𓃾, 𓆙, |(𓃾 𓅓 𓆙))».&𓁶;\n}\n\n```\n\nOutput:\n\n```\n580 divmod 34 = 17 remainder 2 =OR= 𓍦𓎍 𓅓 𓎐𓏽 = 𓎆𓐀 remainder 𓏻\n578 divmod 34 = 17 remainder 0 =OR= 𓍦𓎌𓐁 𓅓 𓎐𓏽 = 𓎆𓐀 remainder 𓄤\n2300578 divmod 23517 = 97 remainder 19429 =OR= 𓁨𓁨𓆐𓆐𓆐𓍦𓎌𓐁 𓅓 𓂮𓆾𓍦𓎆𓐀 = 𓎎𓐀 remainder 𓂭𓇄𓍥𓎏𓐂\n```"}]}
{"messages": [{"role": "user", "content": "An *Eisenstein integer* is a non-unit Gaussian integer a + bω where ω(1+ω) = -1, and a and b are integers.\n\nω is generally chosen as a cube root of unity: \n\nω\n=\n\n−\n1\n+\ni\n\n\n3\n2\n=\n\ne\n\ni\n2\nπ\n\n/\n3\n{\\displaystyle {\\displaystyle {\\displaystyle \\omega ={\\frac {-1+i{\\sqrt {3}}}{2}}=e^{i2\\pi /3}}}}\n\nAs with a Gaussian integer, any Eisenstein integer is either a unit (an integer with a multiplicative inverse [±1, ±ω, ±(ω^-1)]),\na prime (a number p such that if p divides xy, then p necessarily divides either x or y), or composite (a product of primes).\n\nAn Eisenstein integer a + bω is a prime if either it is a product of a unit and an integer prime p such that p % 3 == 2 or norm(a + bω) is an integer prime.\n\nEisenstein numbers can be generated by choosing any a and b such that a and b are integers. To allow generation in a relatively fixed order, such numbers can be ordered by their 2-norm or *norm*:\n\n```\n    norm(eisenstein integer(a, b)) = |a + bω|² = \n  \n    \n      \n        \n          \n            \n              a\n              \n                2\n              \n            \n            −\n            a\n            b\n            +\n            \n              b\n              \n                2\n              \n            \n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle a^{2}-ab+b^{2}}}\n  \n\n\n```\n\nTask\n\n* Find, and show here as their complex number values, the first **100** (by norm order) Eisenstein primes nearest 0.\n\nStretch\n\n* Plot in the complex plane at least the first 2000 such numbers (again, as found with norm closest to 0).\n\nSee also\n\n* [Wikipedia entry for Eisenstein\\_integer] * [Observable entry on Eisenstein primes]"}, {"role": "assistant", "content": "```\nmy \\ω = exp 2i × π/3;\n\nsub norm    (@p) { @p[0]² - @p[0]×@p[1] + @p[1]² }\nsub display (@p) { (@p[0] + ω×@p[1]).reals».fmt('%+8.4f').join ~ 'i' }\n\nmy @E = gather (-10..10 X -10..10).map: -> (\\a,\\b) {\n    take (a,b) if 0 == a|b || a == b ?? (.is-prime and 2 == $_ mod 3 given (a,b)».abs.max) !! norm((a,b)).is-prime\n}\n\n(@E.sort: *.&norm).head(100).map(*.&display).batch(4).join(\"\\n\").say;\n\n```\n\nOutput:\n\n```\n -1.5000 -0.8660i  -0.0000 -1.7321i  -1.5000 +0.8660i  +1.5000 -0.8660i\n +0.0000 +1.7321i  +1.5000 +0.8660i  -1.0000 -1.7321i  -2.0000 +0.0000i\n +1.0000 -1.7321i  -1.0000 +1.7321i  +2.0000 +0.0000i  +1.0000 +1.7321i\n -2.0000 -1.7321i  -2.5000 -0.8660i  -0.5000 -2.5981i  -2.5000 +0.8660i\n +0.5000 -2.5981i  -2.0000 +1.7321i  +2.0000 -1.7321i  -0.5000 +2.5981i\n +2.5000 -0.8660i  +0.5000 +2.5981i  +2.5000 +0.8660i  +2.0000 +1.7321i\n -2.5000 -2.5981i  -3.5000 -0.8660i  -1.0000 -3.4641i  -3.5000 +0.8660i\n +1.0000 -3.4641i  -2.5000 +2.5981i  +2.5000 -2.5981i  -1.0000 +3.4641i\n +3.5000 -0.8660i  +1.0000 +3.4641i  +3.5000 +0.8660i  +2.5000 +2.5981i\n -3.5000 -2.5981i  -4.0000 -1.7321i  -0.5000 -4.3301i  -4.0000 +1.7321i\n +0.5000 -4.3301i  -3.5000 +2.5981i  +3.5000 -2.5981i  -0.5000 +4.3301i\n +4.0000 -1.7321i  +0.5000 +4.3301i  +4.0000 +1.7321i  +3.5000 +2.5981i\n -2.5000 -4.3301i  -5.0000 +0.0000i  +2.5000 -4.3301i  -2.5000 +4.3301i\n +5.0000 +0.0000i  +2.5000 +4.3301i  -3.5000 -4.3301i  -5.5000 -0.8660i\n -2.0000 -5.1962i  -5.5000 +0.8660i  +2.0000 -5.1962i  -3.5000 +4.3301i\n +3.5000 -4.3301i  -2.0000 +5.1962i  +5.5000 -0.8660i  +2.0000 +5.1962i\n +5.5000 +0.8660i  +3.5000 +4.3301i  -5.0000 -3.4641i  -5.5000 -2.5981i\n -0.5000 -6.0622i  -5.5000 +2.5981i  +0.5000 -6.0622i  -5.0000 +3.4641i\n +5.0000 -3.4641i  -0.5000 +6.0622i  +5.5000 -2.5981i  +0.5000 +6.0622i\n +5.5000 +2.5981i  +5.0000 +3.4641i  -4.0000 -5.1962i  -6.5000 -0.8660i\n -2.5000 -6.0622i  -6.5000 +0.8660i  +2.5000 -6.0622i  -4.0000 +5.1962i\n +4.0000 -5.1962i  -2.5000 +6.0622i  +6.5000 -0.8660i  +2.5000 +6.0622i\n +6.5000 +0.8660i  +4.0000 +5.1962i  -6.5000 -4.3301i  -7.0000 -3.4641i\n -0.5000 -7.7942i  -7.0000 +3.4641i  +0.5000 -7.7942i  -6.5000 +4.3301i\n +6.5000 -4.3301i  -0.5000 +7.7942i  +7.0000 -3.4641i  +0.5000 +7.7942i\n\n```"}]}
{"messages": [{"role": "user", "content": "The sequence is from the natural numbers and is defined by:\n\n* `a(1) = 1`;\n* `a(2) = Start = 2`;\n* for n > 2, `a(n)` shares at least one prime factor with `a(n-1)` and is the *smallest* such natural number *not already used*.\n\nThe sequence is called the EKG sequence (after its visual similarity to an electrocardiogram when graphed).\n\nVariants of the sequence can be generated starting 1, N where N is any natural number larger than one. For the purposes of this task let us call:\n\n* The sequence described above , starting `1, 2, ...` the `EKG(2)` sequence;\n* the sequence starting `1, 3, ...` the `EKG(3)` sequence;\n* ... the sequence starting `1, N, ...` the `EKG(N)` sequence.\n\nConvergence\n\nIf an algorithm that keeps track of the minimum amount of numbers and their corresponding prime factors used to generate the next term is used, then this may be known as the generators essential **state**. Two EKG generators with differing starts can converge to produce the same sequence after initial differences.  \n`EKG(N1)` and `EKG(N2)` are said to to have converged at and after generation `a(c)` if `state_of(EKG(N1).a(c)) == state_of(EKG(N2).a(c))`.\n\nTask\n\n1. Calculate and show here the first 10 members of `EKG(2)`.\n2. Calculate and show here the first 10 members of `EKG(5)`.\n3. Calculate and show here the first 10 members of `EKG(7)`.\n4. Calculate and show here the first 10 members of `EKG(9)`.\n5. Calculate and show here the first 10 members of `EKG(10)`.\n6. Calculate and show here at which term `EKG(5)` and `EKG(7)` converge   (**stretch goal**).\n\nRelated Tasks\n\n1. Greatest common divisor\n2. Sieve of Eratosthenes\n3. Yellowstone sequence\n\nReference\n\n* The EKG Sequence and the Tree of Numbers. (Video)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo Star version 2018.04.1\n\n```\nsub infix:<shares-divisors-with> { ($^a gcd $^b) > 1 }\n\nsub next-EKG ( *@s ) {\n    return first {\n        @s ∌ $_  and  @s.tail shares-divisors-with $_\n    }, 2..*;\n}\n\nsub EKG ( Int $start ) {  1, $start, &next-EKG … *  }\n\nsub converge-at ( @ints ) {\n    my @ekgs = @ints.map: &EKG;\n\n    return (2 .. *).first: -> $i {\n        [==]  @ekgs.map(     *.[$i]     ) and\n        [===] @ekgs.map( *.head($i).Set )\n    }\n}\n\nsay \"EKG($_): \", .&EKG.head(10) for 2, 5, 7, 9, 10;\n\nfor [5, 7], [2, 5, 7, 9, 10] -> @ints {\n    say \"EKGs of (@ints[]) converge at term {$_+1}\" with converge-at(@ints);\n}\n\n```\n\nOutput:\n\n```\nEKG(2): (1 2 4 6 3 9 12 8 10 5)\nEKG(5): (1 5 10 2 4 6 3 9 12 8)\nEKG(7): (1 7 14 2 4 6 3 9 12 8)\nEKG(9): (1 9 3 6 2 4 8 10 5 15)\nEKG(10): (1 10 2 4 6 3 9 12 8 14)\nEKGs of (5 7) converge at term 21\nEKGs of (2 5 7 9 10) converge at term 45\n\n```"}]}
{"messages": [{"role": "user", "content": "This task is similar to:\n\n:   :   * Matrix multiplication\n        * Matrix transposition\n\nTask\n\nImplement basic element-wise matrix-matrix and scalar-matrix operations, which can be referred to in other, higher-order tasks.\n\nImplement:\n\n:   :   :   * addition\n            * subtraction\n            * multiplication\n            * division\n            * exponentiation\n\nExtend the task if necessary to include additional basic operations, which should not require their own specialised task."}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku already implements this and other metaoperators as higher-order functions (cross, zip, reduce, triangle, etc.) that are usually accessed through a meta-operator syntactic sugar that is productive over all appropriate operators, including user-defined ones. In this case, a dwimmy element-wise operator (generically known as a \"hyper\") is indicated by surrounding the operator with double angle quotes. Hypers dwim on the pointy end with cyclic APL semantics as necessary. You can turn the quote the other way to suppress dwimmery on that end. In this case we could have used »op» instead of «op» since the short side is always on the right.\n\n```\nmy @a =\n    [1,2,3],\n    [4,5,6],\n    [7,8,9];\n\nsub msay(@x) {\n    say .map( { ($_%1) ?? $_.nude.join('/') !! $_ } ).join(' ') for @x;\n    say '';\n}\n\nmsay @a «+» @a;\nmsay @a «-» @a;\nmsay @a «*» @a;\nmsay @a «/» @a;\nmsay @a «+» [1,2,3];\nmsay @a «-» [1,2,3];\nmsay @a «*» [1,2,3];\nmsay @a «/» [1,2,3];\nmsay @a «+» 2;\nmsay @a «-» 2;\nmsay @a «*» 2;\nmsay @a «/» 2;\n\n# In addition to calling the underlying higher-order functions directly, it's possible to name a function.\n\nsub infix:<M+> (\\l,\\r) { l <<+>> r }\n\nmsay @a M+ @a;\nmsay @a M+ [1,2,3];\nmsay @a M+ 2;\n\n```\n\nOutput:\n\n```\n 2 4 6\n 8 10 12\n 14 16 18\n\n 0 0 0\n 0 0 0\n 0 0 0\n\n 1 4 9\n 16 25 36\n 49 64 81\n\n 1 1 1\n 1 1 1\n 1 1 1\n\n 2 3 4\n 6 7 8\n 10 11 12\n\n 0 1 2\n 2 3 4\n 4 5 6\n\n 1 2 3\n 8 10 12\n 21 24 27\n\n 1 2 3\n 2 5/2 3\n 7/3 8/3 3\n\n 3 4 5\n 6 7 8\n 9 10 11\n\n -1 0 1\n 2 3 4\n 5 6 7\n\n 2 4 6\n 8 10 12\n 14 16 18\n\n 1/2 1 3/2\n 2 5/2 3\n 7/2 4 9/2\n\n 2 4 6\n 8 10 12\n 14 16 18\n\n 2 3 4\n 6 7 8\n 10 11 12\n\n 3 4 5\n 6 7 8\n 9 10 11\n```"}]}
{"messages": [{"role": "user", "content": "An **elementary cellular automaton** is a one-dimensional cellular automaton where there are two possible states (labeled 0 and 1) and the rule to determine the state of a cell in the next generation depends only on the current state of the cell and its two immediate neighbors. Those three values can be encoded with three bits.\n\nThe rules of evolution are then encoded with eight bits indicating the outcome of each of the eight possibilities 111, 110, 101, 100, 011, 010, 001 and 000 in this order. Thus for instance the rule 13 means that a state is updated to 1 only in the cases 011, 010 and 000, since 13 in binary is 0b00001101.\n\nTask\n\nCreate a subroutine, program or function that allows to create and visualize the evolution of any of the 256 possible elementary cellular automaton of arbitrary space length and for any given initial state. You can demonstrate your solution with any automaton of your choice.\n\nThe space state should *wrap*: this means that the left-most cell should be considered as the right neighbor of the right-most cell, and reciprocally.\n\nThis task is basically a generalization of one-dimensional cellular automata.\n\nRelated tasks\n\n* One-dimensional cellular automata\n\nSee also\n\n* Cellular automata (natureofcode.com)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUsing the Automaton class defined at One-dimensional\\_cellular\\_automata#Raku:\n\n```\nclass Automaton {\n    has $.rule;\n    has @.cells;\n    has @.code = $!rule.fmt('%08b').flip.comb».Int;\n \n    method gist { \"|{ @!cells.map({+$_ ?? '#' !! ' '}).join }|\" }\n \n    method succ {\n        self.new: :$!rule, :@!code, :cells( \n            @!code[\n                    4 «*« @!cells.rotate(-1)\n                »+« 2 «*« @!cells\n                »+«       @!cells.rotate(1)\n            ]\n        )\n    }\n}\n\nmy @padding = 0 xx 10;\n\nmy Automaton $a .= new:\n    :rule(30),\n    :cells(flat @padding, 1, @padding);\n\nsay $a++ for ^10;\n\n```\n\nOutput:\n\n```\n|          #          |\n|         ###         |\n|        ##  #        |\n|       ## ####       |\n|      ##  #   #      |\n|     ## #### ###     |\n|    ##  #    #  #    |\n|   ## ####  ######   |\n|  ##  #   ###     #  |\n| ## #### ##  #   ### |\n\n```"}]}
{"messages": [{"role": "user", "content": "The purpose of this task is to create a version of an Elementary cellular automaton whose number of cells is only limited by the memory size of the computer.\n\nTo be precise, consider the state of the automaton to be made of an infinite number of cells, but with a bounded support. In other words, to describe the state of the automaton, you need a finite number of adjacent cells, along with their individual state, and you then consider that the individual state of each of all other cells is the negation of the closest individual cell among the previously defined finite number of cells.\n\nExamples:\n\n```\n1        ->   ..., 0, 0,      1,      0, 0, ...\n0, 1     ->   ..., 1, 1,   0, 1,      0, 0, ...\n1, 0, 1  ->   ..., 0, 0,   1, 0, 1,   0, 0, ...\n\n```\n\nMore complex methods can be imagined, provided it is possible to somehow encode the infinite sections. But for this task we will stick to this simple version."}, {"role": "assistant", "content": "(formerly Perl 6)\nThis version, while it is *capable* of working with infinite length cellular automata, makes the assumption that any cells which have not been explicitly examined are in a 'null' state, neither '0' or '1'. Further it makes the assumption that a null cell, on being examined, initially contains nothing (░). Otherwise it would take infinite time to calculate every row and would be exceptionally boring to watch.\n\nBased heavily on the code from the One-dimensional cellular automata task. Example uses rule 90 (Sierpinski triangle).\n\n```\nclass Automaton {\n    has $.rule;\n    has @.cells;\n    has @.code = $!rule.fmt('%08b').flip.comb».Int;\n\n    method gist { @!cells.map({+$_ ?? '▲' !! '░'}).join }\n\n    method succ {\n        self.new: :$!rule, :@!code, :cells(\n            ' ',\n            |@!code[\n                    4 «*« @!cells.rotate(-1)\n                »+« 2 «*« @!cells\n                »+«       @!cells.rotate(1)\n            ],\n            ' '\n        )\n    }\n}\n\nmy Automaton $a .= new: :rule(90), :cells(flat '010'.comb);\n\n# display the first 20 rows\nsay $a++ for ^20;\n\n# then calculate the other infinite number of rows, (may take a while)\n$a++ for ^Inf;\n\n```\n\nOutput:\n\n```\n░▲░\n░▲░▲░\n░▲░░░▲░\n░▲░▲░▲░▲░\n░▲░░░░░░░▲░\n░▲░▲░░░░░▲░▲░\n░▲░░░▲░░░▲░░░▲░\n░▲░▲░▲░▲░▲░▲░▲░▲░\n░▲░░░░░░░░░░░░░░░▲░\n░▲░▲░░░░░░░░░░░░░▲░▲░\n░▲░░░▲░░░░░░░░░░░▲░░░▲░\n░▲░▲░▲░▲░░░░░░░░░▲░▲░▲░▲░\n░▲░░░░░░░▲░░░░░░░▲░░░░░░░▲░\n░▲░▲░░░░░▲░▲░░░░░▲░▲░░░░░▲░▲░\n░▲░░░▲░░░▲░░░▲░░░▲░░░▲░░░▲░░░▲░\n░▲░▲░▲░▲░▲░▲░▲░▲░▲░▲░▲░▲░▲░▲░▲░▲░\n░▲░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▲░\n░▲░▲░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▲░▲░\n░▲░░░▲░░░░░░░░░░░░░░░░░░░░░░░░░░░▲░░░▲░\n░▲░▲░▲░▲░░░░░░░░░░░░░░░░░░░░░░░░░▲░▲░▲░▲░\n^C\n\n```"}]}
{"messages": [{"role": "user", "content": "Rule 30 is considered to be chaotic enough to generate good pseudo-random numbers. As a matter of fact, for a long time rule 30 was used by the Mathematica software for its default random number generator.\n\nSteven Wolfram's recommendation for random number generation from rule 30 consists in extracting successive bits in a fixed position in the array of cells, as the automaton changes state.\n\nThe purpose of this task is to demonstrate this. With the code written in the parent task, which you don't need to re-write here, show the ten first bytes that emerge from this recommendation. To be precise, you will start with a state of all cells but one equal to zero, and you'll follow the evolution of the particular cell whose state was initially one. Then you'll regroup those bits by packets of eight, reconstituting bytes with the first bit being the most significant.\n\nYou can pick which ever length you want for the initial array but it should be visible in the code so that your output can be reproduced with an other language.\n\nFor extra-credits, you will make this algorithm run as fast as possible in your language, for instance with an extensive use of bitwise logic.\n\nReference\n\n* Cellular automata: Is Rule 30 random? (PDF)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nclass Automaton {\n    has $.rule;\n    has @.cells handles <AT-POS>;\n    has @.code = $!rule.fmt('%08b').flip.comb».Int;\n \n    method gist { \"|{ @!cells.map({+$_ ?? '#' !! ' '}).join }|\" }\n \n    method succ {\n        self.new: :$!rule, :@!code, :cells( \n            @!code[\n                    4 «*« @!cells.rotate(-1)\n                »+« 2 «*« @!cells\n                »+«       @!cells.rotate(1)\n            ]\n        )\n    }\n}\n\nmy Automaton $a .= new: :rule(30), :cells( flat 1, 0 xx 100 );\n\nsay :2[$a++[0] xx 8] xx 10;\n\n```\n\nOutput:\n\n```\n220 197 147 174 117 97 149 171 240 241\n```"}]}
{"messages": [{"role": "user", "content": "Elliptic curves   are sometimes used in   cryptography   as a way to perform   digital signatures.\n\nThe purpose of this task is to implement a simplified (without modular arithmetic) version of the elliptic curve arithmetic which is required by the   elliptic curve DSA   protocol.\n\nIn a nutshell, an elliptic curve is a bi-dimensional curve defined by the following relation between the **x** and **y** coordinates of any point on the curve:\n\n:   :   :   :   y\n\n                2\n                =\n\n                x\n\n                3\n                +\n                a\n                x\n                +\n                b\n                {\\displaystyle {\\displaystyle y^{2}=x^{3}+ax+b}}\n\n**a** and **b** are arbitrary parameters that define the specific curve which is used.\n\nFor this particular task, we'll use the following parameters:\n\n:   :   :   :   a=0**,**   b=7\n\nThe most interesting thing about elliptic curves is the fact that it is possible to define a   group   structure on it.\n\nTo do so we define an   internal composition   rule with an additive notation **+**,   such that for any three distinct points **P**, **Q** and **R** on the curve, whenever these points are aligned, we have:\n\n:   :   :   :   P + Q + R = 0\n\nHere   **0**   (zero)   is the *infinity point*,   for which the **x** and **y** values are not defined.   It's basically the same kind of point which defines the horizon in   projective geometry.\n\nWe'll also assume here that this infinity point is unique and defines the   neutral element   of the addition.\n\nThis was not the definition of the addition, but only its desired property.   For a more accurate definition, we proceed as such:\n\nGiven any three aligned points **P**, **Q** and **R**,   we define the sum   **S = P + Q**   as the point (possibly the infinity point) such that   **S**, **R**   and the infinity point are aligned.\n\nConsidering the symmetry of the curve around the x-axis, it's easy to convince oneself that two points **S** and **R** can be aligned with the infinity point if and only if **S** and **R** are symmetric of one another towards the x-axis   (because in that case there is no other candidate than the infinity point to complete the alignment triplet).\n\n**S** is thus defined as the symmetric of **R** towards the **x** axis.\n\nThe task consists in defining the addition which, for any two points of the curve, returns the sum of these two points.   You will pick two random points on the curve, compute their sum and show that the symmetric of the sum is aligned with the two initial points.\n\nYou will use the **a** and **b** parameters of secp256k1, i.e. respectively zero and seven.\n\n*Hint*:   You might need to define a \"doubling\" function, that returns **P+P** for any given point **P**.\n\n*Extra credit*:   define the full elliptic curve arithmetic (still not modular, though) by defining a \"multiply\" function that returns,\n  \nfor any point **P** and integer **n**,   the point **P + P + ... + P**     (**n** times)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmodule EC {\n  our ($A, $B) = (0, 7);\n\n  our class Point {\n    has ($.x, $.y);\n    multi method new(\n        $x, $y where $y**2 == $x**3 + $A*$x + $B\n        ) { samewith :$x, :$y }\n    multi method gist { \"EC Point at x=$.x, y=$.y\" }\n    multi method gist(::?CLASS:U:) { 'Point at horizon' }\n  }\n\n  multi prefix:<->(Point $p) is export { Point.new: x => $p.x, y => -$p.y }\n  multi prefix:<->(Point:U) is export { Point }\n  multi infix:<->(Point $a, Point $b) is export { $a + -$b }\n\n  multi infix:<+>(Point:U $, Point $p) is export { $p }\n  multi infix:<+>(Point $p, Point:U) is export { $p }\n\n  multi infix:<*>(Point $u, Int $n) is export { $n * $u }\n  multi infix:<*>(Int $n, Point:U) is export { Point }\n  multi infix:<*>(0, Point) is export { Point }\n  multi infix:<*>(1, Point $p) is export { $p }\n  multi infix:<*>(2, Point $p) is export {\n    my $l = (3*$p.x**2 + $A) / (2 *$p.y);\n    my $y = $l*($p.x - my $x = $l**2 - 2*$p.x) - $p.y;\n    $p.new(:$x, :$y);\n  }\n  multi infix:<*>(Int $n where $n > 2, Point $p) is export {\n    2 * ($n div 2 * $p) + $n % 2 * $p;\n  }\n\n  multi infix:<+>(Point $p, Point $q) is export {\n    if $p.x ~~ $q.x {\n      return $p.y ~~ $q.y ?? 2 * $p !! Point;\n    }\n    else {\n      my $slope = ($q.y - $p.y) / ($q.x - $p.x);\n      my $y = $slope*($p.x - my $x = $slope**2 - $p.x - $q.x) - $p.y;\n      return $p.new(:$x, :$y);\n    }\n  }\n\n}\n\nimport EC;\n\nsay my $p = EC::Point.new: x => $_, y => sqrt(abs($_**3 + $EC::A*$_ + $EC::B)) given 1;\nsay my $q = EC::Point.new: x => $_, y => sqrt(abs($_**3 + $EC::A*$_ + $EC::B)) given 2;\nsay my $s = $p + $q;\n\nuse Test;\nis abs(($p.x - $q.x)*(-$s.y - $q.y) - ($p.y - $q.y)*($s.x - $q.x)), 0, \"S, P and Q are aligned\";\n\n```\n\nOutput:\n\n```\nEC Point at x=1, y=2.8284271247461903\nEC Point at x=2, y=3.872983346207417\nEC Point at x=-1.9089023002066448, y=0.21008487055753378\nok 1 - S, P and Q are aligned\n```"}]}
{"messages": [{"role": "user", "content": "Elliptic curves.\n\nAn elliptic curve E over ℤp (p ≥ 5) is defined by an equation of the form\n**y²= x³ + ax + b**, where a, b ∈ ℤp and the discriminant ≢ 0 (mod p),\ntogether with a special point 𝒪 called the point at infinity.\nThe set **E(ℤp)** consists of all points (x, y), with x, y ∈ ℤp,\nwhich satisfy the above defining equation, together with 𝒪.\n\nThere is a rule for adding two points on an elliptic curve to give a third point.\nThis addition operation and the set of points E(ℤp) form a group with identity 𝒪.\nIt is this group that is used in the construction of elliptic curve cryptosystems.\n\nThe addition rule — which can be explained geometrically — is summarized as follows:\n\n```\n1. P + 𝒪 = 𝒪 + P = P for all P ∈ E(ℤp).\n\n2. If P = (x, y) ∈ E(ℤp), then inverse -P = (x,-y), and P + (-P) = 𝒪.\n\n3. Let P = (xP, yP) and Q = (xQ, yQ), both ∈ E(ℤp), where P ≠ -Q.\n   Then R = P + Q = (xR, yR), where\n\n   xR = λ^2 - xP - xQ\n   yR = λ·(xP - xR) - yP,\n\n   with\n\n   λ = (yP - yQ) / (xP - xQ) if P ≠ Q,\n       (3·xP·xP + a) / 2·yP  if P = Q (point doubling).\n\n```\n\nRemark: there already is a task page requesting “a simplified (without modular arithmetic)\nversion of the elliptic curve arithmetic”.\nHere we do add modulo operations. If also the domain is changed from reals to rationals,\nthe elliptic curves are no longer continuous but break up into a finite number of distinct points.\nIn that form we use them to implement ECDSA:\n\nElliptic curve digital signature algorithm.\n\nA digital signature is the electronic analogue of a hand-written signature\nthat convinces the recipient that a message has been sent intact by the presumed sender.\nAnyone with access to the public key of the signer may verify this signature.\nChanging even a single bit of a signed message will cause the verification procedure to fail.\n\n**ECDSA key generation.** Party A does the following:  \n1. Select an elliptic curve E defined over ℤp.  \n The number of points in E(ℤp) should be divisible by a large prime r.  \n2. Select a base point G ∈ E(ℤp) of order r (which means that rG = 𝒪).  \n3. Select a random integer s in the interval [1, r - 1].  \n4. Compute W = sG.  \n The public key is (E, G, r, W), the private key is s.\n\n**ECDSA signature computation.** To sign a message m, A does the following:  \n1. Compute message representative f = H(m), using a\ncryptographic hash function.  \n Note that f can be greater than r but not longer (measuring bits).  \n2. Select a random integer u in the interval [1, r - 1].  \n3. Compute V = uG = (xV, yV) and c ≡ xV mod r  (goto (2) if c = 0).  \n4. Compute d ≡ u^-1·(f + s·c) mod r  (goto (2) if d = 0).  \n The signature for the message m is the pair of integers (c, d).\n\n**ECDSA signature verification.** To verify A's signature, B should do the following:  \n1. Obtain an authentic copy of A's public key (E, G, r, W).  \n Verify that c and d are integers in the interval [1, r - 1].  \n2. Compute f = H(m) and h ≡ d^-1 mod r.  \n3. Compute h1 ≡ f·h mod r and h2 ≡ c·h mod r.  \n4. Compute h1G + h2W = (x1, y1) and c1 ≡ x1 mod r.  \n Accept the signature if and only if c1 = c.\n\nTo be cryptographically useful, the parameter r should have at least 250 bits.\nThe basis for the security of elliptic curve cryptosystems\nis the intractability of the elliptic curve discrete logarithm problem (ECDLP) in a group of this size:\ngiven two points G, W ∈ E(ℤp), where W lies in the subgroup of order r generated by G,\ndetermine an integer k such that W = kG and 0 ≤ k < r.\n\nTask.\n\nThe task is to write a **toy version** of the ECDSA, quasi the equal of a real-world\nimplementation, but utilizing parameters that fit into standard arithmetic types.\nTo keep things simple there's no need for key export or a hash function (just a sample\nhash value and a way to tamper with it). The program should be lenient where possible\n(for example: if it accepts a composite modulus N it will either function as expected,\nor demonstrate the principle of elliptic curve factorization)\n— but strict where required (a point G that is not on E will always cause failure).  \nToy ECDSA is of course completely useless for its cryptographic purpose.\nIf this bothers you, please add a multiple-precision version.\n\nReference.\n\nElliptic curves are in the IEEE Std 1363-2000 (Standard Specifications for Public-Key Cryptography), see:\n\n7. Primitives based on the elliptic curve discrete logarithm problem (p. 27ff.)\n\n7.1 The EC setting  \n7.1.2 EC domain parameters  \n7.1.3 EC key pairs\n\n7.2 Primitives  \n7.2.7 ECSP-DSA (p. 35)  \n7.2.8 ECVP-DSA (p. 36)\n\nAnnex A. Number-theoretic background  \nA.9 Elliptic curves: overview (p. 115)  \nA.10 Elliptic curves: algorithms (p. 121)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmodule EC {\n  use FiniteField;\n\n  our class Point {\n    has ($.x, $.y);\n    submethod TWEAK { fail unless $!y**2 == $!x**3 + $*a*$!x + $*b }\n    multi method gist(::?CLASS:U:) { \"Point at Horizon\" }\n    multi method new($x, $y) { samewith :$x, :$y }\n  }\n  multi infix:<==>(Point:D $A, Point:D $B) is export { $A.x == $B.x and $A.y == $B.y }\n\n  multi prefix:<->(Point $P) returns Point is export { Point.new: $P.x, -$P.y }\n  multi infix:<+>(Point $A, Point:U) is export { $A }\n  multi infix:<+>(Point:U, Point $B) is export { $B }\n  multi infix:<+>(Point:D $A, Point:D $B) returns Point is export {\n    my $λ;\n    if $A.x == $B.x and $A.y == -$B.y { return Point }\n    elsif $A == $B {\n      return Point if $A.y == 0;\n      $λ = (3*$A.x² + $*a) / (2*$A.y);\n    }\n    else { $λ = ($A.y - $B.y) / ($A.x - $B.x); }\n\n    given $λ**2 - $A.x - $B.x {\n      return Point.new: $_, $λ*($A.x - $_) - $A.y;\n    }\n  }\n  multi infix:<*>(0, Point     ) is export { Point }\n  multi infix:<*>(1, Point   $p) is export { $p }\n  multi infix:<*>(2, Point:D $p) is export { $p + $p }\n  multi infix:<*>(Int $n, Point $p) is export { 2*(($n div 2)*$p) + ($n mod 2)*$p }\n}\n\nimport EC;\n\nmodule ECDSA {\n  use Digest::SHA256::Native;\n  our class Signature {\n    has UInt ($.c, $.d);\n    multi method new(Str $message, UInt :$private-key) {\n      my $z = :16(sha256-hex $message) % $*n;\n      loop (my $k = my $s = my $r = 0; $r == 0; ) {\n        loop ( $r = $s = 0 ; $r == 0 ; ) {\n          $r = (( $k = (1..^$*n).roll ) * $*G).x % $*n;\n        }\n        {\n          use FiniteField; my $*modulus = $*n;\n          $s = ($z + $r*$private-key) / $k;\n        }\n      }\n      samewith c => $r, d => $s;\n    }\n    multi method verify(Str $message, EC::Point :$public-key) {\n      my $z = :16(sha256-hex $message) % $*n;\n      my ($u1, $u2);\n      {\n        use FiniteField;\n        my $*modulus = $*n;\n        my $w = 1/$!d;\n        ($u1, $u2) = $z*$w, $!c*$w;\n      }\n      my $p = ($u1 * $*G) + ($u2 * $public-key);\n      die unless ($p.x mod $*n) == ($!c mod $*n);\n    }\n  }\n}\n\nmy ($*a, $*b) = 355, 671;\nmy $*modulus = my $*p = 1073741789;\n\nmy $*G = EC::Point.new: 13693, 10088;\nmy $*n = 1073807281;\n\ndie \"G is not of order n\" if $*n*$*G;\n\nmy $private-key = ^$*n .pick;\nmy $public-key = $private-key*$*G; \n\nmy $message = \"Show me the monKey\";\nmy $signature = ECDSA::Signature.new: $message, :$private-key;\n\nprintf \"The curve E is        : 𝑦² = 𝑥³ + %s 𝑥 + %s (mod %s)\\n\", $*a, $*b, $*p;\nprintf \"with generator G at   : (%s, %s)\\n\", $*G.x, $*G.y;\nprintf \"G's order is          : %d\\n\", $*n;\nprintf \"The private key is    : %d\\n\", $private-key;\nprintf \"The public key is at  : (%s, %s)\\n\", $public-key.x, $public-key.y;\nprintf \"The message is        : %s\\n\", $message;\nprintf \"The signature is      : (%s, %s)\\n\", $signature.c, $signature.d;\n\n{\n  use Test;\n\n  lives-ok {\n    $signature.verify: $message, :$public-key;\n  }, \"good signature for <$message>\";\n\n  my $altered = $message.subst(/monKey/, \"money\");\n  dies-ok {\n    $signature.verify: $altered, :$public-key\n  }, \"wrong signature for <$altered>\";\n}\n\n```\n\nOutput:\n\n```\nThe curve E is        : 𝑦² = 𝑥³ + 355 𝑥 + 671 (mod 1073741789)\nwith generator G at   : (13693, 10088)\nG's order is          : 1073807281\nThe private key is    : 405586338\nThe public key is at  : (457744420, 236326628)\nThe message is        : Show me the monKey\nThe signature is      : (839907635, 23728690)\nok 1 - good signature for <Show me the monKey>\nok 2 - wrong signature for <Show me the money>\n```"}]}
{"messages": [{"role": "user", "content": "An   *emirp*   (**prime** spelled backwards)   are primes that when reversed   (in their decimal representation)   are a different prime.\n\n(This rules out palindromic primes.)\n\nTask\n:   :   * show the first   twenty   emirps\n        * show all emirps between   7,700   and   8,000\n        * show the   10,000th   emirp\n\nIn each list, the numbers should be in order.\n\nInvoke the (same) program once per task requirement, this will show what limit is used as the upper bound for calculating surplus (regular) primes.\n\nThe specific method of how to determine if a range or if specific values are to be shown will be left to the programmer.\n\nSee also\n\n* Wikipedia, Emirp.\n* The Prime Pages, emirp.\n* Wolfram MathWorld™, Emirp.\n* The On‑Line Encyclopedia of Integer Sequences, emirps (A6567)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.10\n\nFor better performance, build the lazy list using module `Math::Primesieve`, not the built-in, then display results based on parameters passed in. The default is to display an array slice starting and stopping at the given indices. Alternately, ask for all values between two endpoints.\n\n```\nuse Math::Primesieve;\n\nsub prime-hash (Int $max) {\n    my $sieve = Math::Primesieve.new;\n    my @primes = $sieve.primes($max);\n    @primes.Set;\n}\n\nsub MAIN ($start, $stop = Nil, $display = <slice>) {\n    my $end = $stop // $start;\n    my %primes = prime-hash(100*$end);\n    my @emirps = lazy gather for 1 .. * -> $n {\n        take $n if %primes{$n} and %primes{$n.flip} and $n != $n.flip\n    }\n\n    given $display {\n        when 'slice'  { return @emirps[$start-1 .. $end-1] };\n        when 'values' {\n            my @values = gather for @emirps {\n                .take if $start < $_ < $end;\n                last if $_> $end\n            }\n            return @values\n        }\n    }\n}\n\n```\n\nOutput:\n\nRun with passed parameters: 1 20\n\n('slice' is the default. you *could* pass it in, but it isn't necessary.)\n\n```\n13 17 31 37 71 73 79 97 107 113 149 157 167 179 199 311 337 347 359 389\n```\n\nRun with passed parameters: 7700 8000 values\n\n```\n7717 7757 7817 7841 7867 7879 7901 7927 7949 7951 7963\n```\n\nRun with passed parameter: 10000\n\n```\n948349\n```"}]}
{"messages": [{"role": "user", "content": "Starting with a path to some directory, determine whether the directory is empty.\n\nAn empty directory contains no files nor subdirectories.\nWith Unix or Windows systems, every directory contains an entry for “`.`” and almost every directory contains “`..`” (except for a root directory); an empty directory contains no other entries."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub dir-is-empty ($d) { not dir $d }\n\n```\n\nThe dir function returns a lazy list of filenames, excluding \".\" and \"..\" automatically. Any boolean context (in this case the not function) will do just enough work on the lazy list to determine whether there are any elements, so we don't have to count the directory entries, or even read them all into memory, if there are more than one buffer's worth."}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate the simplest possible program that is still considered \"correct.\""}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe empty program is valid and does nothing but return a successful exit code:\n\nIt is also possible to just specify that the program is written in Raku:\n\n```\nuse v6;\n```\n\nor even:\n\n```\nv6;\n```"}]}
{"messages": [{"role": "user", "content": "Languages may have features for dealing specifically with empty strings\n(those containing no characters).\n\nTask\n:   :   * Demonstrate how to assign an empty string to a variable.\n        * Demonstrate how to check that a string is empty.\n        * Demonstrate how to check that a string is not empty.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $s = '';\nsay 'String is empty' unless $s;\nsay 'String is not empty' if $s;\n```\n\nUnlike in Perl 5, only empty strings test as false - the string \"0\" tests as true now."}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate any means your language has to prevent the modification of values, or to create objects that cannot be modified after they have been created."}, {"role": "assistant", "content": "(formerly Perl 6)\nYou can create constants in Raku with `constant`:\n\n```\nconstant $pi = 3.14159;\nconstant $msg = \"Hello World\";\n\nconstant @arr = (1, 2, 3, 4, 5);\n\n```\n\nImmutability is abstract enough that you can define an infinite constant lazily:\n\n```\nconstant fibonacci = 0, 1, *+* ... *;\n\n```\n\nVariables are considered mutable by default, but may be marked as readonly after initialization:\n\n```\nmy $pi := 3 + rand;\n\n```\n\nUnlike variables, formal parameters are considered readonly by default even if bound to a mutable container.\n\n```\nsub sum (Num $x, Num $y) {\n\t$x += $y;  # ERROR\n}\n\n# Explicitly ask for pass-by-reference semantics\nsub addto (Num $x is rw, Num $y) {\n    $x += $y;  # ok, propagated back to caller\n}\n\n# Explicitly ask for pass-by-value semantics\nsub sum (Num $x is copy, Num $y) {\n    $x += $y;  # ok, but NOT propagated back to caller\n    $x;\n}\n\n```\n\nA number of built-in types are considered immutable value types, including:\n\n```\nStr         String (finite sequence of Unicode characters)\nInt         Integer (allows Inf/NaN, arbitrary precision, etc.)\nNum         Number (approximate Real, generally via floating point)\nRat         Rational (exact Real, limited denominator)\nFatRat      Rational (unlimited precision in both parts)\nComplex     Complex number\nBool        Boolean\nException   Exception\nBlock       Executable objects that have lexical scopes\nSeq         A list of values (can be generated lazily)\nRange       A pair of Ordered endpoints\nSet         Unordered collection of values that allows no duplicates\nBag         Unordered collection of values that allows duplicates\nEnum        An immutable Pair\nMap         A mapping of Enums with no duplicate keys\nSignature   Function parameters (left-hand side of a binding)\nCapture     Function call arguments (right-hand side of a binding)\nBlob        An undifferentiated mass of ints, an immutable Buf\nInstant     A point on the continuous atomic timeline\nDuration    The difference between two Instants\n```\n\nThese values, though objects, can't mutate; they may only be \"changed\" by modifying a mutable container holding one of them to hold a different value instead. (In the abstract, that is. In the interests of efficiency, a string or list implementation would be allowed to cheat as long as it doesn't get caught cheating.) Some of these types have corresponding \"unboxed\" native representations, where the container itself must carry the type information since the value can't. In this case, it's still the container that might be\nconsidered mutable as an lvalue location, not the value stored in that location.\n\nBy default, object attributes are not modifiable from outside a class, though this is usually viewed more as encapsulation than as mutability control."}]}
{"messages": [{"role": "user", "content": "The Engel expansion of a positive real number x is the unique non-decreasing sequence of positive integers ***{ a1, a2, a3 ... }*** such that\n\n```\n    x = 1 / a1 + 1 / a1a2  + 1 / a1a2a3 ...\n\n```\n\nIn other words, each term is the reciprocal of the cumulative product of the expansion and *x* is the sum of those terms.\n\nRational numbers have a finite Engel expansion, while irrational numbers have an infinite Engel expansion.\n\nTiny amounts of imprecision can cause wild variation from actual values as the (reciprocal) terms grow smaller. It can be quite challenging to maintain precision in later terms.\n\nTask\n\n* Write routines (functions, procedures, whatever it may be called in your language) to convert a rational number to an Engel expansion representation and from an Engle expansion to a rational number.\n* Demonstrate converting some rational numbers to an Engel expansion and back.\n\nTest it with at least the following rational approximations of:\n\n* 𝜋 - 3.14159265358979\n* 𝑒 - 2.71828182845904\n* √2 - 1.414213562373095\n\nStretch\n\n* If your language supports high precision rational numbers, do the same with at least:\n\n* 𝜋 - 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211\n* 𝑒 - 2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852516642743\n* √2 - 1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727350138462309122970249248360558507372126441214970999358314132226659275055927558\n\nThere almost definitely *will* be some imprecision in the later terms. Feel free to limit the display of the expansion to the first 30 terms.\n\nSee also\n\n* Wikipedia: Engel expansion * OEIS:A006784 - Engel expansion of Pi * OEIS:A028310 - Engel expansion of 𝑒 * OEIS:A028254 - Engel expansion of sqrt(2)"}, {"role": "assistant", "content": "```\nsub to-engel ($rat is copy) { do while $rat { my $a = ceiling 1 / $rat; $rat = $rat × $a - 1; $a } }\n\nsub from-engel (@expanded) { sum [\\×] @expanded.map: { FatRat.new: 1, $_ } }\n\nfor #  low precision 𝜋, 𝑒, √2 and 1.5 to a power\n    3.14159265358979, 2.71828182845904, 1.414213562373095, 1.5 ** 5,\n\n    # high precision 𝜋, 𝑒, and √2 and 1.5 to a power\n    3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211.FatRat,\n\n    2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852516642743.FatRat,\n\n    1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727350138462309122970249248360558507372126441214970999358314132226659275055927558.FatRat,\n\n    1.5 ** 8\n  -> $rat {\n    say \"Rational number: $rat\";\n    my @expanded = $rat.&to-engel;\n    put \"Engel expansion: \" ~ @expanded.head(30);\n    say \" Converted back: \" ~ @expanded.&from-engel;\n    put '';\n}\n\n```\n\nOutput:\n\n```\nRational number: 3.14159265358979\nEngel expansion: 1 1 1 8 8 17 19 300 1991 2768 4442 4830 10560 37132 107315 244141 651042 1953125\n Converted back: 3.14159265358979\n\nRational number: 2.71828182845904\nEngel expansion: 1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 17 82 144 321 2289 9041 21083 474060 887785 976563 1953125\n Converted back: 2.71828182845904\n\nRational number: 1.414213562373095\nEngel expansion: 1 3 5 5 16 18 78 102 120 144 260 968 18531 46065 63005 65105 78125\n Converted back: 1.414213562373095\n\nRational number: 7.59375\nEngel expansion: 1 1 1 1 1 1 1 2 6 8\n Converted back: 7.59375\n\nRational number: 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211\nEngel expansion: 1 1 1 8 8 17 19 300 1991 2492 7236 10586 34588 63403 70637 1236467 5417668 5515697 5633167 7458122 9637848 9805775 41840855 58408380 213130873 424342175 2366457522 4109464489 21846713216 27803071890\n Converted back: 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211\n\nRational number: 2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852516642743\nEngel expansion: 1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29\n Converted back: 2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852516642743\n\nRational number: 1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727350138462309122970249248360558507372126441214970999358314132226659275055927558\nEngel expansion: 1 3 5 5 16 18 78 102 120 144 251 363 1402 31169 88630 184655 259252 298770 4196070 38538874 616984563 1975413035 5345718057 27843871197 54516286513 334398528974 445879679626 495957494386 2450869042061 2629541150527\n Converted back: 1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727350138462309122970249248360558507372126441214970999358314132226659275055927558\n\nRational number: 25.628906\nEngel expansion: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 4 32\n Converted back: 25.628906\n```"}]}
{"messages": [{"role": "user", "content": "Certain numbers, when spelled out in their English cardinal representation, are anagrams of other numbers.\n\nSome are very obvious: **sixty-seven <=> seventy-six**\n\nOthers are a little more subtle: **one hundred twelve <=> two hundred eleven**\n\nTask\n\n* Find and display the first thirty numbers that are a member of English cardinal anagrams, starting from **zero**.\n* Find and display the **count** of English cardinal anagrams from **zero** to **one thousand**.\n* Find and display the **largest group(s)** of English cardinal anagrams from **zero** to **one thousand**.\n\nStretch\n\n* Find and display the **count** of English cardinal anagrams from **zero** to **ten thousand**, restricted to numbers within those bounds. *(Ignore anagrams of numbers outside those bounds. **E.G. 1010 <=> 10001**)*\n* Find and display the **largest group(s)** of English cardinal anagrams from **zero** to **ten thousand**.\n\nSee also\n\n* OEIS::A169936 - Numbers whose name in English is an anagram of the name of another number * Related task: Number names"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\nuse List::Allmax;\n\nfor 1_000, 10_000 {\n    my %eca; # English cardinal anagrams\n    (^$_).map: { %eca{.&cardinal.comb.sort.join}.push: $_ }\n\n    once say \"\\nFirst 30 English cardinal anagrams:\\n \" ~\n    (sort flat %eca.grep(+*.value > 1)».value.map: *.flat)[^30]\\\n    .batch(10)».fmt(\"%3d\").join: \"\\n \";\n\n    say \"\\nCount of English cardinal anagrams up to {.&comma}: \" ~\n        +%eca.grep(+*.value > 1)».value.map: *.flat;\n\n    say \"\\nLargest group(s) of English cardinal anagrams up to {.&comma}:\\n [\" ~\n        %eca.&all-max( :by(+*.value) )».value.sort.join(\"]\\n [\") ~ ']'\n}\n\n```\n\nOutput:\n\n```\nFirst 30 English cardinal anagrams:\n  67  69  76  79  96  97 102 103 104 105\n 106 107 108 109 112 122 123 124 125 126\n 127 128 129 132 133 134 135 136 137 138\n\nCount of English cardinal anagrams up to 1,000: 317\n\nLargest group(s) of English cardinal anagrams up to 1,000:\n [679 697 769 796 967 976]\n\nCount of English cardinal anagrams up to 10,000: 2534\n\nLargest group(s) of English cardinal anagrams up to 10,000:\n [1679 1697 1769 1796 1967 1976 6179 6197 6791 6971 7169 7196 7691 7961 9167 9176 9671 9761]\n [2679 2697 2769 2796 2967 2976 6279 6297 6792 6972 7269 7296 7692 7962 9267 9276 9672 9762]\n [3679 3697 3769 3796 3967 3976 6379 6397 6793 6973 7369 7396 7693 7963 9367 9376 9673 9763]\n [4679 4697 4769 4796 4967 4976 6479 6497 6794 6974 7469 7496 7694 7964 9467 9476 9674 9764]\n [5679 5697 5769 5796 5967 5976 6579 6597 6795 6975 7569 7596 7695 7965 9567 9576 9675 9765]\n [6798 6879 6897 6978 7698 7869 7896 7968 8679 8697 8769 8796 8967 8976 9678 9768 9867 9876]\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCalculate the Shannon entropy   H   of a given input string.\n\nGiven the discrete random variable \n\nX\n{\\displaystyle {\\displaystyle X}}\n that is a string of \n\nN\n{\\displaystyle {\\displaystyle N}}\n \"symbols\" (total characters) consisting of \n\nn\n{\\displaystyle {\\displaystyle n}}\n different characters (n=2 for binary), the Shannon entropy of X in **bits/symbol** is :\n\n:   H\n\n    2\n    (\n    X\n    )\n    =\n    −\n\n    ∑\n\n    i\n    =\n    1\n\n    n\n\n    c\n    o\n    u\n    n\n\n    t\n\n    i\n    N\n\n    log\n\n    2\n    ⁡\n\n    (\n\n    c\n    o\n    u\n    n\n\n    t\n\n    i\n    N\n    )\n    {\\displaystyle {\\displaystyle H\\_{2}(X)=-\\sum \\_{i=1}^{n}{\\frac {count\\_{i}}{N}}\\log \\_{2}\\left({\\frac {count\\_{i}}{N}}\\right)}}\n\nwhere \n\nc\no\nu\nn\n\nt\n\ni\n{\\displaystyle {\\displaystyle count\\_{i}}}\n is the count of character \n\nn\n\ni\n{\\displaystyle {\\displaystyle n\\_{i}}}\n.\n\nFor this task, use X=\"1223334444\" as an example. The result should be 1.84644... bits/symbol. This assumes X was a random variable, which may not be the case, or it may depend on the observer.\n\nThis coding problem calculates the \"specific\" or \"intensive\" entropy that finds its parallel in physics with \"specific entropy\" S0 which is entropy per kg or per mole, not like physical entropy S and therefore not the \"information\" content of a file. It comes from Boltzmann's H-theorem where \n\nS\n=\n\nk\n\nB\nN\nH\n{\\displaystyle {\\displaystyle S=k\\_{B}NH}}\n where N=number of molecules. Boltzmann's H is the same equation as Shannon's H, and it gives the specific entropy H on a \"per molecule\" basis.\n\nThe \"total\", \"absolute\", or \"extensive\" information entropy is\n\n:   S\n    =\n\n    H\n\n    2\n    N\n    {\\displaystyle {\\displaystyle S=H\\_{2}N}}\n     bits\n\nThis is not the entropy being coded here, but it is the closest to physical entropy and a measure of the information content of a string. But it does not look for any patterns that might be available for compression, so it is a very restricted, basic, and certain measure of \"information\". Every binary file with an equal number of 1's and 0's will have S=N bits. All hex files with equal symbol frequencies will have \n\nS\n=\nN\n\nlog\n\n2\n⁡\n(\n16\n)\n{\\displaystyle {\\displaystyle S=N\\log \\_{2}(16)}}\n bits of entropy. The total entropy in bits of the example above is S= 10\\*18.4644 = 18.4644 bits.\n\nThe H function does not look for any patterns in data or check if X was a random variable. For example, X=000000111111 gives the same calculated entropy in all senses as Y=010011100101. For most purposes it is usually more relevant to divide the gzip length by the length of the original data to get an informal measure of how much \"order\" was in the data.\n\nTwo other \"entropies\" are useful:\n\nNormalized specific entropy:\n\n:   H\n\n    n\n    =\n\n    H\n\n    2\n    ∗\n    log\n    ⁡\n    (\n    2\n    )\n\n    log\n    ⁡\n    (\n    n\n    )\n    {\\displaystyle {\\displaystyle H\\_{n}={\\frac {H\\_{2}\\*\\log(2)}{\\log(n)}}}}\n\nwhich varies from 0 to 1 and it has units of \"entropy/symbol\" or just 1/symbol. For this example, Hn<\\sub>= 0.923.\n\nNormalized total (extensive) entropy:\n\n:   S\n\n    n\n    =\n\n    H\n\n    2\n    N\n    ∗\n    log\n    ⁡\n    (\n    2\n    )\n\n    log\n    ⁡\n    (\n    n\n    )\n    {\\displaystyle {\\displaystyle S\\_{n}={\\frac {H\\_{2}N\\*\\log(2)}{\\log(n)}}}}\n\nwhich varies from 0 to N and does not have units. It is simply the \"entropy\", but it needs to be called \"total normalized extensive entropy\" so that it is not confused with Shannon's (specific) entropy or physical entropy. For this example, Sn<\\sub>= 9.23.\n\nShannon himself is the reason his \"entropy/symbol\" H function is very confusingly called \"entropy\". That's like calling a function that returns a speed a \"meter\". See section 1.7 of his classic A Mathematical Theory of Communication and search on \"per symbol\" and \"units\" to see he always stated his entropy H has units of \"bits/symbol\" or \"entropy/symbol\" or \"information/symbol\". So it is legitimate to say entropy NH is \"information\".\n\nIn keeping with Landauer's limit, the physics entropy generated from erasing N bits is \n\nS\n=\n\nH\n\n2\nN\n\nk\n\nB\nln\n⁡\n(\n2\n)\n{\\displaystyle {\\displaystyle S=H\\_{2}Nk\\_{B}\\ln(2)}}\n if the bit storage device is perfectly efficient. This can be solved for H2\\*N to (arguably) get the number of bits of information that a physical entropy represents.\n\nRelated tasks\n:   * Fibonacci\\_word\n    * Entropy/Narcissist"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-09\n\n```\nsub entropy(@a) {\n    [+] map -> \\p { p * -log p }, bag(@a).values »/» +@a;\n}\n\nsay log(2) R/ entropy '1223334444'.comb;\n\n```\n\nOutput:\n\n```\n1.84643934467102\n```\n\nIn case we would like to add this function to Raku's core, here is one way it could be done:\n\n```\nuse MONKEY-TYPING;\naugment class Bag {\n    method entropy {\n\t[+] map -> \\p { - p * log p },\n\tself.values »/» +self;\n    }\n}\n\nsay '1223334444'.comb.Bag.entropy / log 2;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a computer program that computes and shows its own   entropy.\n\nRelated Tasks\n:   * Fibonacci\\_word\n    * Entropy"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.05\n\n```\nsay log(2) R/ [+] map -> \\p { p * -log p }, $_.comb.Bag.values >>/>> +$_\n    given slurp($*PROGRAM-NAME).comb\n\n```\n\nResult should be in the neighborhood of 4.9\n\nOutput:\n\n```\n4.89351613053006\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate an enumeration of constants with and without explicit values."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.01\n\n```\nenum Fruit <Apple Banana Cherry>; # Numbered 0 through 2.\n\nenum ClassicalElement (\n    Earth => 5,\n    'Air',  # gets the value 6\n    'Fire', # gets the value 7\n    Water => 10,\n);\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow how to get one of your process's environment variables.\n\nThe available variables vary by system;   some of the common ones available on Unix include:\n\n:   :   :   * PATH\n            * HOME\n            * USER"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #24 \"Seoul\"\n\nThe `%*ENV` hash maps environment variables to their values:\n\n```\nsay %*ENV<HOME>;\n\n```"}]}
{"messages": [{"role": "user", "content": "Suppose we have a sequence of prime sums, where each term **Pn** is the sum of the first **n** primes.\n\n```\nP = (2), (2 + 3), (2 + 3 + 5), (2 + 3 + 5 + 7), (2 + 3 + 5 + 7 + 11), ...\n\n```\n\n```\nP = 2, 5, 10, 17, 28, etc.\n\n```\n\nFurther; suppose we have a sequence of composite sums, where each term **Cm** is the sum of the first **m** composites.\n\n```\nC = (4), (4 + 6), (4 + 6 + 8), (4 + 6 + 8 + 9), (4 + 6 + 8 + 9 + 10), ...\n\n```\n\n```\nC = 4, 10, 18, 27, 37, etc.\n\n```\n\nNotice that the third term of **P**; **P3** (**10**) is equal to the second term of **C**; **C2** (**10**);\n\nTask\n\n* Find and display the indices (**n**, **m**) and value of at least the first 6 terms of the sequence of numbers that are both the sum of the first **n** primes and the first **m** composites.\n\nSee also\n\n* OEIS:A007504 - Sum of the first n primes * OEIS:A053767 - Sum of first n composite numbers * OEIS:A294174 - Numbers that can be expressed both as the sum of first primes and as the sum of first composites"}, {"role": "assistant", "content": "Let it run until I got bored and killed it. Time is total accumulated seconds since program start.\n\n```\nuse Lingua::EN::Numbers:ver<2.8.2+>;\n\nmy $prime-sum =     [\\+] (2..*).grep:  *.is-prime;\nmy $composite-sum = [\\+] (2..*).grep: !*.is-prime;\n\nmy $c-index = 0;\n\nfor ^∞ -> $p-index {\n    next if $prime-sum[$p-index] < $composite-sum[$c-index];\n    printf( \"%20s - %11s prime sum, %12s composite sum   %5.2f seconds\\n\",\n      $prime-sum[$p-index].&comma, ordinal-digit($p-index + 1, :u, :c),\n      ordinal-digit($c-index + 1, :u, :c), now - INIT now )\n      and next if $prime-sum[$p-index] == $composite-sum[$c-index];\n    ++$c-index;\n    redo;\n};\n\n```\n\nOutput:\n\n```\n                  10 -         3ʳᵈ prime sum,          2ⁿᵈ composite sum    0.01 seconds\n               1,988 -        33ʳᵈ prime sum,         51ˢᵗ composite sum    0.01 seconds\n              14,697 -        80ᵗʰ prime sum,        147ᵗʰ composite sum    0.02 seconds\n              83,292 -       175ᵗʰ prime sum,        361ˢᵗ composite sum    0.03 seconds\n           1,503,397 -       660ᵗʰ prime sum,      1,582ⁿᵈ composite sum    0.04 seconds\n          18,859,052 -     2,143ʳᵈ prime sum,      5,699ᵗʰ composite sum    0.08 seconds\n          93,952,013 -     4,556ᵗʰ prime sum,     12,821ˢᵗ composite sum    0.14 seconds\n      89,171,409,882 -   118,785ᵗʰ prime sum,    403,341ˢᵗ composite sum    4.23 seconds\n   9,646,383,703,961 - 1,131,142ⁿᵈ prime sum,  4,229,425ᵗʰ composite sum   76.23 seconds\n 209,456,854,921,713 - 5,012,372ⁿᵈ prime sum, 19,786,181ˢᵗ composite sum  968.26 seconds\n^C\n```"}]}
{"messages": [{"role": "user", "content": "An equilibrium index of a sequence is an index into the sequence such that the sum of elements at lower indices is equal to the sum of elements at higher indices.\n\nFor example, in a sequence   \n\nA\n{\\displaystyle {\\displaystyle A}}\n:\n\n:   :   :   :   :   A\n\n                    0\n                    =\n                    −\n                    7\n                    {\\displaystyle {\\displaystyle A\\_{0}=-7}}\n                :   A\n\n                    1\n                    =\n                    1\n                    {\\displaystyle {\\displaystyle A\\_{1}=1}}\n                :   A\n\n                    2\n                    =\n                    5\n                    {\\displaystyle {\\displaystyle A\\_{2}=5}}\n                :   A\n\n                    3\n                    =\n                    2\n                    {\\displaystyle {\\displaystyle A\\_{3}=2}}\n                :   A\n\n                    4\n                    =\n                    −\n                    4\n                    {\\displaystyle {\\displaystyle A\\_{4}=-4}}\n                :   A\n\n                    5\n                    =\n                    3\n                    {\\displaystyle {\\displaystyle A\\_{5}=3}}\n                :   A\n\n                    6\n                    =\n                    0\n                    {\\displaystyle {\\displaystyle A\\_{6}=0}}\n\n3   is an equilibrium index, because:\n\n:   :   :   :   :   A\n\n                    0\n                    +\n\n                    A\n\n                    1\n                    +\n\n                    A\n\n                    2\n                    =\n\n                    A\n\n                    4\n                    +\n\n                    A\n\n                    5\n                    +\n\n                    A\n\n                    6\n                    {\\displaystyle {\\displaystyle A\\_{0}+A\\_{1}+A\\_{2}=A\\_{4}+A\\_{5}+A\\_{6}}}\n\n6   is also an equilibrium index, because:\n\n:   :   :   :   :   A\n\n                    0\n                    +\n\n                    A\n\n                    1\n                    +\n\n                    A\n\n                    2\n                    +\n\n                    A\n\n                    3\n                    +\n\n                    A\n\n                    4\n                    +\n\n                    A\n\n                    5\n                    =\n                    0\n                    {\\displaystyle {\\displaystyle A\\_{0}+A\\_{1}+A\\_{2}+A\\_{3}+A\\_{4}+A\\_{5}=0}}\n\n(sum of zero elements is zero)\n\n7   is not an equilibrium index, because it is not a valid index of sequence \n\nA\n{\\displaystyle {\\displaystyle A}}\n.\n\nTask;\n\nWrite a function that, given a sequence, returns its equilibrium indices (if any).\n\nAssume that the sequence may be very long."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub equilibrium_index(@list) {\n    my ($left,$right) = 0, [+] @list;\n\n    gather for @list.kv -> $i, $x {\n        $right -= $x;\n        take $i if $left == $right;\n        $left += $x;\n    }\n}\n\nmy @list = -7, 1, 5, 2, -4, 3, 0;\n.say for equilibrium_index(@list).grep(/\\d/);\n\n```\n\nAnd here's an FP solution that manages to remain O(n):\n\n```\nsub equilibrium_index(@list) {\n    my @a = [\\+] @list;\n    my @b = reverse [\\+] reverse @list;\n    ^@list Zxx (@a »==« @b); \n}\n\n```\n\nThe [\\+] is a reduction that returns a list of partial results. The »==« is a vectorized equality comparison; it returns a vector of true and false. The Zxx is a zip with the list replication operator, so we return only the elements of the left list where the right list is true (which is taken to mean 1 here). And the ^@list is just shorthand for 0 ..^ @list. We could just as easily have used @list.keys there.\n\n### Single-pass solution\n\nThe task can be restated in a way that removes the \"right side\" from the calculation.\n\nC is the current element,  \nL is the sum of elements left of C,  \nR is the sum of elements right of C,  \nS is the sum of the entire list.\n\nBy definition, L + C + R == S for any choice of C, and L == R for any C that is an equilibrium point.  \nTherefore (by substituting L for R), L + C + L == S at all equilibrium points.  \nRestated, 2L + C == S.\n\n```\n# Original example, with expanded calculations:\n    0    1    2    3    4    5    6   # Index\n   -7    1    5    2   -4    3    0   # C (Value at index)\n    0   -7   -6   -1    1   -3    0   # L (Sum of left)\n   -7  -13   -7    0   -2   -3    0   # 2L+C\n\n```\n\nIf we build a hash as we walk the list, with 2L+C as hash keys, and arrays of C-indexes as hash values, we get:\n\n```\n{\n     -7 => [ 0, 2 ],\n    -13 => [ 1    ],\n      0 => [ 3, 6 ],\n     -2 => [ 4    ],\n     -3 => [ 5    ],\n}\n\n```\n\nAfter we have finished walking the list, we will have the sum (S), which we look up in the hash. Here S=0, so the equilibrium points are 3 and 6.\n\nNote: In the code below, it is more convenient to calculate 2L+C \\*after\\* L has already been incremented by C; the calculation is simply 2L-C, because each L has an extra C in it. 2(L-C)+C == 2L-C.\n\n```\nsub eq_index ( *@list ) {\n    my $sum = 0;\n\n    my %h = @list.keys.classify: {\n        $sum += @list[$_];\n        $sum * 2 - @list[$_];\n    };\n\n    return %h{$sum} // [];\n}\n\nsay eq_index < -7  1  5  2 -4  3  0 >; # 3 6\nsay eq_index <  2  4  6             >; # (no eq point)\nsay eq_index <  2  9  2             >; # 1\nsay eq_index <  1 -1  1 -1  1 -1  1 >; # 0 1 2 3 4 5 6\n\n```\n\nThe .classify method creates a hash, with its code block's return value as key. Each hash value is an Array of all the inputs that returned that key.\n\nWe could have used .pairs instead of .keys to save the cost of @list lookups, but that would change each %h value to an Array of Pairs, which would complicate the return line."}]}
{"messages": [{"role": "user", "content": "A prime p is in category 1 if the prime factors of p+1 are 2 and or 3. p is in category 2 if all the prime factors of p+1 are in category 1. p is in category g if all the prime factors of p+1 are in categories 1 to g-1.\n\nThe task is first to display the first 200 primes allocated to their category, then assign the first million primes to their category, displaying the smallest prime, the largest prime, and the count of primes allocated to each category."}, {"role": "assistant", "content": "```\nuse Prime::Factor;\nuse Lingua::EN::Numbers;\nuse Math::Primesieve;\nmy $sieve = Math::Primesieve.new;\n\nmy %cat = 2 => 1, 3 => 1;\n\nsub Erdös-Selfridge ($n) {\n    my @factors = prime-factors $n + 1;\n    my $category = max %cat{ @factors };\n    unless %cat{ @factors[*-1] } {\n        $category max= ( 1 + max %cat{ prime-factors 1 + @factors[*-1] } );\n        %cat{ @factors[*-1] } = $category;\n    }\n    $category\n}\n\nmy $upto = 200;\n\nsay \"First { cardinal $upto } primes; Erdös-Selfridge categorized:\";\n.say for sort $sieve.n-primes($upto).categorize: &Erdös-Selfridge;\n\n$upto = 1_000_000;\n\nsay \"\\nSummary of first { cardinal $upto } primes; Erdös-Selfridge categorized:\";\nprintf \"Category %2d: first: %9s  last: %10s  count: %s\\n\", ++$, |(.[0], .[*-1], .elems).map: &comma\nfor $sieve.n-primes($upto).categorize( &Erdös-Selfridge ).sort(+*.key)».value;\n\n```\n\nOutput:\n\n```\nFirst two hundred primes; Erdös-Selfridge categorized:\n1 => [2 3 5 7 11 17 23 31 47 53 71 107 127 191 383 431 647 863 971 1151]\n2 => [13 19 29 41 43 59 61 67 79 83 89 97 101 109 131 137 139 149 167 179 197 199 211 223 229 239 241 251 263 269 271 281 283 293 307 317 349 359 367 373 419 433 439 449 461 479 499 503 509 557 563 577 587 593 599 619 641 643 659 709 719 743 751 761 769 809 827 839 881 919 929 953 967 991 1019 1033 1049 1069 1087 1103 1187 1223]\n3 => [37 103 113 151 157 163 173 181 193 227 233 257 277 311 331 337 347 353 379 389 397 401 409 421 457 463 467 487 491 521 523 541 547 569 571 601 607 613 631 653 683 701 727 733 773 787 797 811 821 829 853 857 859 877 883 911 937 947 983 997 1009 1013 1031 1039 1051 1061 1063 1091 1097 1117 1123 1153 1163 1171 1181 1193 1217]\n4 => [73 313 443 617 661 673 677 691 739 757 823 887 907 941 977 1093 1109 1129 1201 1213]\n5 => [1021]\n\nSummary of first one million primes; Erdös-Selfridge categorized:\nCategory  1: first:         2  last: 10,616,831  count: 46\nCategory  2: first:        13  last: 15,482,669  count: 10,497\nCategory  3: first:        37  last: 15,485,863  count: 201,987\nCategory  4: first:        73  last: 15,485,849  count: 413,891\nCategory  5: first:     1,021  last: 15,485,837  count: 263,109\nCategory  6: first:     2,917  last: 15,485,857  count: 87,560\nCategory  7: first:    15,013  last: 15,484,631  count: 19,389\nCategory  8: first:    49,681  last: 15,485,621  count: 3,129\nCategory  9: first:   532,801  last: 15,472,811  count: 363\nCategory 10: first: 1,065,601  last: 15,472,321  count: 28\nCategory 11: first: 8,524,807  last:  8,524,807  count: 1\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nAn Erdős–Nicolas number is a positive integer which is not perfect but is equal to the sum of its first **k** divisors (arranged in ascending order and including one) for some value of **k** greater than one.\n\nExamples\n\n24 is an Erdős–Nicolas number because the sum of its first 6 divisors (1, 2, 3, 4, 6 and 8) is equal to 24 and it is not perfect because 12 is also a divisor.\n\n6 is not an Erdős–Nicolas number because it is perfect (1 + 2 + 3 = 6).\n\n48 is not an Erdős–Nicolas number because its divisors are: 1, 2, 3, 4, 6, 8, 12, 16, 24 and 48. The first seven of these add up to 36, but the first eight add up to 52 which is more than 48.\n\nTask\n\nFind and show here the first 8 Erdős–Nicolas numbers and the number of divisors needed (i.e. the value of 'k') to satisfy the definition.\n\nStretch\n\nDo the same for any further Erdős–Nicolas numbers which you have the patience for.\n\nNote\n\nAs all known Erdős–Nicolas numbers are even you may assume this to be generally true in order to quicken up the search. However, it is not obvious (to me at least) why this should necessarily be the case.\n\nReference\n\n* OEIS:A194472 - Erdős–Nicolas numbers"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\n\nsub is-Erdős-Nicolas ($n) {\n    my @divisors = $n.&proper-divisors: :s;\n    ((@divisors.sum > $n) && (my $key = ([\\+] @divisors).first: $n, :k)) ?? 1 + $key !! False\n}\n\nmy $count;\n\n(1..*).hyper(:2000batch).map( * × 2 ).map: {\n    if my $key = .&is-Erdős-Nicolas {\n        printf \"%8d == sum of its first %3d divisors\\n\", $_, $key;\n        exit if ++$count >= 8;\n    }\n}\n\n```\n\nOutput:\n\n```\n      24 == sum of its first   6 divisors\n    2016 == sum of its first  31 divisors\n    8190 == sum of its first  43 divisors\n   42336 == sum of its first  66 divisors\n   45864 == sum of its first  66 divisors\n  392448 == sum of its first  68 divisors\n  714240 == sum of its first 113 divisors\n 1571328 == sum of its first 115 divisors\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nIn mathematics, **Erdős primes** are prime numbers such that all p-k! for 1<=k!<p are composite.\n\nTask\n\nWrite a program to determine (and show here) all **Erdős primes** less than **2500**.\n\nOptionally, show the **number** of Erdős primes.\n\nStretch goal\n\nShow that the 7,875th Erdős prime is 999,721 (the highest below 1,000,000)\n\nAlso see\n:   * the OEIS entry:   A064152 Erdos primes."}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\n\nmy @factorial = 1, |[\\*] 1..*;\nmy @Erdős = ^Inf .grep: { .is-prime and none($_ «-« @factorial[^(@factorial.first: * > $_, :k)]).is-prime }\n\nput 'Erdős primes < 2500:';\nput @Erdős[^(@Erdős.first: * > 2500, :k)]».&comma;\nput \"\\nThe 7,875th Erdős prime is: \" ~ @Erdős[7874].&comma;\n\n```\n\nOutput:\n\n```\nErdős primes < 2500:\n2 101 211 367 409 419 461 557 673 709 769 937 967 1,009 1,201 1,259 1,709 1,831 1,889 2,141 2,221 2,309 2,351 2,411 2,437\n\nThe 7,875th Erdős prime is: 999,721\n```\n\nAlternately, using fewer hard coded values:\n\n```\nuse Lingua::EN::Numbers;\nuse List::Divvy;\n\nmy @factorial = 1, |[\\*] 1..*;\nmy @Erdős = ^∞ .grep: { .is-prime and none($_ «-« @factorial.&upto: $_).is-prime }\n\nput \"Erdős primes < 2500:\\n\" ~ @Erdős.&before(2500)».&comma.batch(8)».fmt(\"%5s\").join: \"\\n\";\nput \"\\nThe largest Erdős prime less than {comma 1e6.Int} is {comma .[*-1]} in {.&ordinal-digit} position.\"\n  given @Erdős.&before(1e6);\n\n```\n\nOutput:\n\n```\nErdős primes < 2500:\n    2   101   211   367   409   419   461   557\n  673   709   769   937   967 1,009 1,201 1,259\n1,709 1,831 1,889 2,141 2,221 2,309 2,351 2,411\n2,437\n\nThe largest Erdős prime less than 1,000,000 is 999,721 in 7875th position.\n```"}]}
{"messages": [{"role": "user", "content": "Description\n\nA positive integer **k** is said to be an Erdős–Woods number if it has the following property: there exists a positive integer **a** such that in the sequence (a, a + 1, …, a + k) of consecutive integers, each of the elements has a non-trivial common factor with one of the endpoints. In other words, **k** is an Erdős–Woods number if there exists a positive integer **a** such that for each integer **i** between 0 and k, at least one of the greatest common divisors gcd(a, a + i) or gcd(a + i, a + k) is greater than 1.\n\nIt can be shown that there are infinitely many such numbers. Moreover, if **k** is an E-W number for some integer **a**, then one can find an infinite number of other **a'**s using the formula **a(jq + 1)** where:\n\n* **q** is the product of all odd prime factors of **a + k**; and\n* **j** is any positive integer.\n\nExample\n\n16 is an E-W number (and also the first) for which the smallest value of **a** is 2184. This is because in the sequence 2184 to 2200 inclusive, the prime factors of the endpoints are:\n\n* 2³ x 3 x 7 x 13 = 2184\n* 2³ x 5² x 11 = 2200\n\nand, if you check all the numbers between them, you will find that they all have a prime factor in common with at least one of the endpoints (2189 is divisible by 11, 2191 by 7, 2197 by 13 and the rest by either 2, 3, or 5).\n\nTask\n\nCompute and show here the first **20** E-W numbers together with their corresponding smallest value of **a**. If your language doesn't support arbitrary precision arithmetic, just compute and show as many as you can.\n\nExtra credit\n\nDo the same for the **next 20** E-W numbers.\n\nNote\n\nAlthough all the E-W numbers relevant to this task are even, odd examples do exist the first one being **k** = 903.\n\nReferences\n\n* OEIS sequence A059756: Erdős–Woods numbers.\n* OEIS sequence A059757: Smallest values of a for a given E-W number k.\n* Planet Math: Erdős–Woods numbers."}, {"role": "assistant", "content": "**Translation of**: Wren\n\n**Translation of**: Julia\n\n```\n# 20220308 Raku programming solution\n\nsub ew (\\n) {\n\n   my @primes = (^n).grep: *.is-prime;  \n\n   # rosettacode.org/wiki/Horner%27s_rule_for_polynomial_evaluation#Raku\n   my @divs = (^n).map: -> \\p { ([o] map { p%%$_.Int + 2 * * }, @primes)(0) }\n\n   my @partitions = [ 0, 0, 2**@primes.elems - 1 ] , ;\n\n   sub ort(\\x) { (@divs[x] +| @divs[n -x]).base(2).flip.index(1) } \n\n   for ((n^...1).sort: *.&ort).reverse {\n      my \\newPartitions = @ = (); \n      my (\\factors,\\otherFactors) = @divs[$_, n-$_];\n\n      for @partitions -> \\p {\n         my (\\setA, \\setB, \\rPrimes) = p[0..2];\n\n         if (factors +& setA) or (otherFactors +& setB) {\n            newPartitions.push: p and next \n         } \n         for (factors +& rPrimes).base(2).flip.comb.kv -> \\k,\\v {\n            if (v == 1) {\n               my \\w = 1 +< k;   \n               newPartitions.push: [ setA +^ w, setB, rPrimes +^ w ]\n            }\n         }\n         for (otherFactors +& rPrimes).base(2).flip.comb.kv -> \\k,\\v {\n            if (v == 1) {\n               my \\w = 1 +< k; \n               newPartitions.push: [ setA, setB +^ w, rPrimes +^ w ]\n            }\n         }\n      }\n      @partitions = newPartitions\n   }\n\n   my \\result = $ = -1;\n   for @partitions -> \\p {\n      my ($px,$py,$x,$y) = p[0],p[1],1,1;\n      for @primes -> $p {\n         $px % 2 and $x *= $p;\n         $py % 2 and $y *= $p;\n         ($px,$py) >>div=>> 2\n      }\n      my \\newresult = ((n * expmod($x, -1, $y)) % $y) * $x - n;\n      result = result == -1 ?? newresult !! min(result, newresult)\n   }\n   return result \n}\n\nsay \"The first 20 Erdős–Woods numbers and their minimum interval start values are:\";\nfor (16..116) { if (my $ew = ew $_) > 0 { printf \"%3d -> %d\\n\",$_,$ew } } ;\n\n```\n\nOutput:\n\nSame as Wren example."}]}
{"messages": [{"role": "user", "content": "An **esthetic number** is a positive integer where every adjacent digit differs from its neighbour by 1.\n\nE.G.\n\n:   * **12** is an esthetic number. One and two differ by 1.\n\n:   * **5654** is an esthetic number. Each digit is exactly 1 away from its neighbour.\n\n:   * **890** is **not** an esthetic number. Nine and zero differ by 9.\n\nThese examples are nominally in base 10 but the concept extends easily to numbers in other bases. Traditionally, single digit numbers *are* included in esthetic numbers; zero may or may not be. For our purposes, for this task, do not include zero (0) as an esthetic number. Do not include numbers with leading zeros.\n\nEsthetic numbers are also sometimes referred to as stepping numbers.\n\nTask\n\n:   * Write a routine (function, procedure, whatever) to find esthetic numbers in a given base.\n\n:   * Use that routine to find esthetic numbers in bases **2** through **16** and display, here on this page, the esthectic numbers from index **(base × 4)** through index **(base × 6)**, inclusive. (E.G. for base 2: 8th through 12th, for base 6: 24th through 36th, etc.)\n\n:   * Find and display, here on this page, the **base 10** esthetic numbers with a magnitude between **1000** and **9999**.\n\n:   * Stretch: Find and display, here on this page, the **base 10** esthetic numbers with a magnitude between **1.0e8** and **1.3e8**.\n\nRelated task\n\n* numbers with equal rises and falls\n\nSee also\n:   * OEIS A033075 - Positive numbers n such that all pairs of consecutive decimal digits differ by 1 * Numbers Aplenty - Esthetic numbers * Geeks for Geeks - Stepping numbers"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.02\n\n```\nuse Lingua::EN::Numbers;\n\nsub esthetic($base = 10) {\n    my @s = ^$base .map: -> \\s {\n        ((s - 1).base($base) if s > 0), ((s + 1).base($base) if s < $base - 1)\n    }\n\n    flat [ (1 .. $base - 1)».base($base) ],\n    { [ flat .map: { $_ xx * Z~ flat @s[.comb.tail.parse-base($base)] } ] } … *\n}\n\nfor 2 .. 16 -> $b {\n    put \"\\n{(4 × $b).&ordinal-digit} through {(6 × $b).&ordinal-digit} esthetic numbers in base $b\";\n    put esthetic($b)[(4 × $b - 1) .. (6 × $b - 1)]».fmt('%3s').batch(16).join: \"\\n\"\n}\n\nmy @e10 = esthetic;\nput \"\\nBase 10 esthetic numbers between 1,000 and 9,999:\";\nput @e10.&between(1000, 9999).batch(20).join: \"\\n\";\n\nput \"\\nBase 10 esthetic numbers between {1e8.Int.&comma} and {1.3e8.Int.&comma}:\";\nput @e10.&between(1e8.Int, 1.3e8.Int).batch(9).join: \"\\n\";\n\nsub between (@array, Int $lo, Int $hi) {\n    my $top = @array.first: * > $hi, :k;\n    @array[^$top].grep: * > $lo\n}\n\n```\n\nOutput:\n\n```\n8th through 12th esthetic numbers in base 2\n10101010 101010101 1010101010 10101010101 101010101010\n\n12th through 18th esthetic numbers in base 3\n1210 1212 2101 2121 10101 10121 12101\n\n16th through 24th esthetic numbers in base 4\n323 1010 1012 1210 1212 1232 2101 2121 2123\n\n20th through 30th esthetic numbers in base 5\n323 343 432 434 1010 1012 1210 1212 1232 1234 2101\n\n24th through 36th esthetic numbers in base 6\n343 345 432 434 454 543 545 1010 1012 1210 1212 1232 1234\n\n28th through 42nd esthetic numbers in base 7\n345 432 434 454 456 543 545 565 654 656 1010 1012 1210 1212 1232\n\n32nd through 48th esthetic numbers in base 8\n432 434 454 456 543 545 565 567 654 656 676 765 767 1010 1012 1210\n1212\n\n36th through 54th esthetic numbers in base 9\n434 454 456 543 545 565 567 654 656 676 678 765 767 787 876 878\n1010 1012 1210\n\n40th through 60th esthetic numbers in base 10\n454 456 543 545 565 567 654 656 676 678 765 767 787 789 876 878\n898 987 989 1010 1012\n\n44th through 66th esthetic numbers in base 11\n456 543 545 565 567 654 656 676 678 765 767 787 789 876 878 898\n89A 987 989 9A9 A98 A9A 1010\n\n48th through 72nd esthetic numbers in base 12\n543 545 565 567 654 656 676 678 765 767 787 789 876 878 898 89A\n987 989 9A9 9AB A98 A9A ABA BA9 BAB\n\n52nd through 78th esthetic numbers in base 13\n545 565 567 654 656 676 678 765 767 787 789 876 878 898 89A 987\n989 9A9 9AB A98 A9A ABA ABC BA9 BAB BCB CBA\n\n56th through 84th esthetic numbers in base 14\n565 567 654 656 676 678 765 767 787 789 876 878 898 89A 987 989\n9A9 9AB A98 A9A ABA ABC BA9 BAB BCB BCD CBA CBC CDC\n\n60th through 90th esthetic numbers in base 15\n567 654 656 676 678 765 767 787 789 876 878 898 89A 987 989 9A9\n9AB A98 A9A ABA ABC BA9 BAB BCB BCD CBA CBC CDC CDE DCB DCD\n\n64th through 96th esthetic numbers in base 16\n654 656 676 678 765 767 787 789 876 878 898 89A 987 989 9A9 9AB\nA98 A9A ABA ABC BA9 BAB BCB BCD CBA CBC CDC CDE DCB DCD DED DEF\nEDC\n\nBase 10 esthetic numbers between 1,000 and 9,999:\n1010 1012 1210 1212 1232 1234 2101 2121 2123 2321 2323 2343 2345 3210 3212 3232 3234 3432 3434 3454\n3456 4321 4323 4343 4345 4543 4545 4565 4567 5432 5434 5454 5456 5654 5656 5676 5678 6543 6545 6565\n6567 6765 6767 6787 6789 7654 7656 7676 7678 7876 7878 7898 8765 8767 8787 8789 8987 8989 9876 9878\n9898\n\nBase 10 esthetic numbers between 100,000,000 and 130,000,000:\n101010101 101010121 101010123 101012101 101012121 101012123 101012321 101012323 101012343\n101012345 101210101 101210121 101210123 101212101 101212121 101212123 101212321 101212323\n101212343 101212345 101232101 101232121 101232123 101232321 101232323 101232343 101232345\n101234321 101234323 101234343 101234345 101234543 101234545 101234565 101234567 121010101\n121010121 121010123 121012101 121012121 121012123 121012321 121012323 121012343 121012345\n121210101 121210121 121210123 121212101 121212121 121212123 121212321 121212323 121212343\n121212345 121232101 121232121 121232123 121232321 121232323 121232343 121232345 121234321\n121234323 121234343 121234345 121234543 121234545 121234565 121234567 123210101 123210121\n123210123 123212101 123212121 123212123 123212321 123212323 123212343 123212345 123232101\n123232121 123232123 123232321 123232323 123232343 123232345 123234321 123234323 123234343\n123234345 123234543 123234545 123234565 123234567 123432101 123432121 123432123 123432321\n123432323 123432343 123432345 123434321 123434323 123434343 123434345 123434543 123434545\n123434565 123434567 123454321 123454323 123454343 123454345 123454543 123454545 123454565\n123454567 123456543 123456545 123456565 123456567 123456765 123456767 123456787 123456789\n```"}]}
{"messages": [{"role": "user", "content": "Ethiopian multiplication is a method of multiplying integers using only addition, doubling, and halving.\n\n**Method:**\n\n1. Take two numbers to be multiplied and write them down at the top of two columns.\n2. In the left-hand column repeatedly halve the last number, discarding any remainders, and write the result below the last in the same column, until you write a value of 1.\n3. In the right-hand column repeatedly double the last number and write the result below. stop when you add a result in the same row as where the left hand column shows 1.\n4. Examine the table produced and discard any row where the value in the left column is even.\n5. Sum the values in the right-hand column that remain to produce the result of multiplying the original two numbers together\n\n**For example:**   17 × 34\n\n```\n       17    34\n\n```\n\nHalving the first column:\n\n```\n       17    34\n        8\n        4\n        2\n        1\n\n```\n\nDoubling the second column:\n\n```\n       17    34\n        8    68\n        4   136 \n        2   272\n        1   544\n\n```\n\nStrike-out rows whose first cell is even:\n\n```\n       17    34\n        8    68 \n        4   136 \n        2   272 \n        1   544\n\n```\n\nSum the remaining numbers in the right-hand column:\n\n```\n       17    34\n        8    -- \n        4   --- \n        2   --- \n        1   544\n           ====\n            578\n\n```\n\nSo 17 multiplied by 34, by the Ethiopian method is 578.\n\nTask\n\nThe task is to **define three named functions**/methods/procedures/subroutines:\n\n1. one to **halve an integer**,\n2. one to **double an integer**, and\n3. one to **state if an integer is even**.\n\nUse these functions to **create a function that does Ethiopian multiplication**.\n\nRelated tasks\n\n* Egyptian division\n\nReferences\n\n* Ethiopian multiplication explained (BBC Video clip)\n* A Night Of Numbers - Go Forth And Multiply (Video)\n* Russian Peasant Multiplication\n* Programming Praxis: Russian Peasant Multiplication"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub halve  (Int $n is rw)    { $n div= 2 }\nsub double (Int $n is rw)    { $n *= 2 }\nsub even   (Int $n --> Bool) { $n %% 2 }\n\nsub ethiopic-mult (Int $a is copy, Int $b is copy --> Int) {\n    my Int $r = 0;\n    while $a {\n\teven $a or $r += $b;\n\thalve $a;\n\tdouble $b;\n    }\n    return $r;\n}\n\nsay ethiopic-mult(17,34);\n```\n\nOutput:\n\n```\n578\n\n```\n\nMore succinctly using implicit typing, primed lambdas, and an infinite loop:\n\n```\nsub ethiopic-mult {\n    my &halve  = * div= 2;\n    my &double = * *= 2;\n    my &even   = * %% 2;\n\n    my ($a,$b) = @_;\n    my $r;\n    loop {\n        even  $a or $r += $b;\n        halve $a or return $r;\n        double $b;\n    }\n}\n\nsay ethiopic-mult(17,34);\n```\n\nMore succinctly still, using a pure functional approach (reductions, mappings, lazy infinite sequences):\n\n```\nsub halve  { $^n div 2 }\nsub double { $^n * 2   }\nsub even   { $^n %% 2  }\n\nsub ethiopic-mult ($a, $b) {\n    [+] ($b, &double ... *)\n        Z*\n        ($a, &halve ... 0).map: { not even $^n }\n}\n\nsay ethiopic-mult(17,34);\n```\n\n(same output)"}]}
{"messages": [{"role": "user", "content": "Definition\n\nThe Euclid–Mullin sequence is an infinite sequence of distinct prime numbers, in which each element is the least prime factor of one plus the product of all earlier elements.\n\nThe first element is usually assumed to be 2. So the second element is : (2) + 1 = 3 and the third element is : (2 x 3) + 1 = 7 as this is prime.\n\nAlthough intermingled with smaller elements, the sequence can produce very large elements quite quickly and only the first 51 have been computed at the time of writing.\n\nTask\n\nCompute and show here the first **16** elements of the sequence or, if your language does not support arbitrary precision arithmetic, as many as you can.\n\nStretch goal\n\nCompute the next **11** elements of the sequence.\n\nReference\n\nOEIS sequence A000945"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\n\nmy @Euclid-Mullin = 2, { state $i = 1; (1 + [×] @Euclid-Mullin[^$i++]).&prime-factors.min } … *;\n\nput 'First sixteen: ', @Euclid-Mullin[^16];\n\n```\n\nOutput:\n\n```\nFirst sixteen: 2 3 7 43 13 53 5 6221671 38709183810571 139 2801 11 17 5471 52662739 23003\n```"}]}
{"messages": [{"role": "user", "content": "The **Euclidean rhythm** was proposed by Godfried Toussaint in 2004 and is described in a 2005 paper \"The Euclidean Algorithm Generates Traditional Musical Rhythms\".[1] It generates many forms of rhythm in music around the world. The program takes 2 integers *(m, n)* and outputs a binary string with *m* ones and *(n-m)* zeros.\n\nAs an example, here is how it runs on (5, 13):\n\n* Write 5 ones followed by (13-5) zeros, into 13 groups of 1-digit each:\n  + 1 1 1 1 1 | 0 0 0 0 0 0 0 0\n* Repeatedly append substitute the second group into the first group:\n  + 1 1 1 1 1 | 0 0 0 0 0 0 0 0\n  + 10 10 10 10 10 | 0 0 0\n  + 100 100 100 10 10 |\n* If the first group consists of elements of the same form, then output. Otherwise, divide the first group into two groups of the two forms, and repeat the process:\n  + 100 100 100 10 10 |\n  + 100 100 100 | 10 10\n  + 10010 10010 100 |\n* At this point, we can continue the algorithm until only one form remains, but notice that one of the groups has only one element [100], so the algorithm can actually terminate right here and output the concatenation 1001010010100."}, {"role": "assistant", "content": "**Translation of**: Perl\n\n```\n# 20240208 Raku programming solution\n\nsay sub ($k is copy, $n is copy) {\n   my @s = [ [1] xx $k ].append: [0] xx ($n - $k); \n   my $z = my $d = $n - $k;\n   ($k, $n) = ($d, $k).minmax.bounds;\n\n   while $z > 0 || $k > 1 {\n      ^$k .map: { @s[$_].append: @s.splice(*-1) } \n      ($z, $d) = ($z, $n) X- $k;\n      ($k, $n) = ($d, $k).minmax.bounds;\n   }\n   return [~] @s>>.List.flat;\n}(5, 13);\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Euler's method numerically approximates solutions of first-order ordinary differential equations (ODEs) with a given initial value.   It is an explicit method for solving initial value problems (IVPs), as described in the wikipedia page.\n\nThe ODE has to be provided in the following form:\n\n:   :   :   d\n            y\n            (\n            t\n            )\n\n            d\n            t\n            =\n            f\n            (\n            t\n            ,\n            y\n            (\n            t\n            )\n            )\n            {\\displaystyle {\\displaystyle {\\frac {dy(t)}{dt}}=f(t,y(t))}}\n\nwith an initial value\n\n:   :   :   y\n            (\n\n            t\n\n            0\n            )\n            =\n\n            y\n\n            0\n            {\\displaystyle {\\displaystyle y(t\\_{0})=y\\_{0}}}\n\nTo get a numeric solution, we replace the derivative on the   LHS   with a finite difference approximation:\n\n:   :   :   d\n            y\n            (\n            t\n            )\n\n            d\n            t\n            ≈\n\n            y\n            (\n            t\n            +\n            h\n            )\n            −\n            y\n            (\n            t\n            )\n            h\n            {\\displaystyle {\\displaystyle {\\frac {dy(t)}{dt}}\\approx {\\frac {y(t+h)-y(t)}{h}}}}\n\nthen solve for \n\ny\n(\nt\n+\nh\n)\n{\\displaystyle {\\displaystyle y(t+h)}}\n:\n\n:   :   :   y\n            (\n            t\n            +\n            h\n            )\n            ≈\n            y\n            (\n            t\n            )\n            +\n            h\n\n            d\n            y\n            (\n            t\n            )\n\n            d\n            t\n            {\\displaystyle {\\displaystyle y(t+h)\\approx y(t)+h\\,{\\frac {dy(t)}{dt}}}}\n\nwhich is the same as\n\n:   :   :   y\n            (\n            t\n            +\n            h\n            )\n            ≈\n            y\n            (\n            t\n            )\n            +\n            h\n\n            f\n            (\n            t\n            ,\n            y\n            (\n            t\n            )\n            )\n            {\\displaystyle {\\displaystyle y(t+h)\\approx y(t)+h\\,f(t,y(t))}}\n\nThe iterative solution rule is then:\n\n:   :   :   y\n\n            n\n            +\n            1\n            =\n\n            y\n\n            n\n            +\n            h\n\n            f\n            (\n\n            t\n\n            n\n            ,\n\n            y\n\n            n\n            )\n            {\\displaystyle {\\displaystyle y\\_{n+1}=y\\_{n}+h\\,f(t\\_{n},y\\_{n})}}\n\nwhere   \n\nh\n{\\displaystyle {\\displaystyle h}}\n   is the step size, the most relevant parameter for accuracy of the solution.   A smaller step size increases accuracy but also the computation cost, so it has always has to be hand-picked according to the problem at hand.\n\n**Example: Newton's Cooling Law**\n\nNewton's cooling law describes how an object of initial temperature   \n\nT\n(\n\nt\n\n0\n)\n=\n\nT\n\n0\n{\\displaystyle {\\displaystyle T(t\\_{0})=T\\_{0}}}\n   cools down in an environment of temperature   \n\nT\n\nR\n{\\displaystyle {\\displaystyle T\\_{R}}}\n:\n\n:   :   :   d\n            T\n            (\n            t\n            )\n\n            d\n            t\n            =\n            −\n            k\n\n            Δ\n            T\n            {\\displaystyle {\\displaystyle {\\frac {dT(t)}{dt}}=-k\\,\\Delta T}}\n\nor\n\n:   :   :   d\n            T\n            (\n            t\n            )\n\n            d\n            t\n            =\n            −\n            k\n\n            (\n            T\n            (\n            t\n            )\n            −\n\n            T\n\n            R\n            )\n            {\\displaystyle {\\displaystyle {\\frac {dT(t)}{dt}}=-k\\,(T(t)-T\\_{R})}}\n\nIt says that the cooling rate   \n\nd\nT\n(\nt\n)\n\nd\nt\n{\\displaystyle {\\displaystyle {\\frac {dT(t)}{dt}}}}\n   of the object is proportional to the current temperature difference   \n\nΔ\nT\n=\n(\nT\n(\nt\n)\n−\n\nT\n\nR\n)\n{\\displaystyle {\\displaystyle \\Delta T=(T(t)-T\\_{R})}}\n   to the surrounding environment.\n\nThe analytical solution, which we will compare to the numerical approximation, is\n\n:   :   :   T\n            (\n            t\n            )\n            =\n\n            T\n\n            R\n            +\n            (\n\n            T\n\n            0\n            −\n\n            T\n\n            R\n            )\n\n\n            e\n\n            −\n            k\n            t\n            {\\displaystyle {\\displaystyle T(t)=T\\_{R}+(T\\_{0}-T\\_{R})\\;e^{-kt}}}\n\nTask\n\nImplement a routine of Euler's method and then to use it to solve the given example of Newton's cooling law with it for three different step sizes of:\n\n:   :   :   * 2 s\n            * 5 s       and\n            * 10 s\n\nand to compare with the analytical solution.\n\nInitial values\n:   :   :   * initial temperature   \n\n              T\n\n              0\n              {\\displaystyle {\\displaystyle T\\_{0}}}\n                 shall be   100 °C\n            * room temperature   \n\n              T\n\n              R\n              {\\displaystyle {\\displaystyle T\\_{R}}}\n                 shall be   20 °C\n            * cooling constant     \n\n              k\n              {\\displaystyle {\\displaystyle k}}\n                   shall be   0.07\n            * time interval to calculate shall be from   0 s   ──►   100 s\n\nA reference solution (Common Lisp) can be seen below.   We see that bigger step sizes lead to reduced approximation accuracy."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub euler ( &f, $y0, $a, $b, $h ) {\n    my $y = $y0;\n    my @t_y;\n    for $a, * + $h ... * > $b -> $t {\n        @t_y[$t] = $y;\n        $y += $h × f( $t, $y );\n    }\n    @t_y\n}\n\nconstant COOLING_RATE = 0.07;\nconstant AMBIENT_TEMP =   20;\nconstant INITIAL_TEMP =  100;\nconstant INITIAL_TIME =    0;\nconstant FINAL_TIME   =  100;\n\nsub f ( $time, $temp ) {\n    -COOLING_RATE × ( $temp - AMBIENT_TEMP )\n}\n\nmy @e;\n@e[$_] = euler( &f, INITIAL_TEMP, INITIAL_TIME, FINAL_TIME, $_ ) for 2, 5, 10;\n\nsay 'Time Analytic   Step2   Step5  Step10     Err2     Err5    Err10';\n\nfor INITIAL_TIME, * + 10 ... * >= FINAL_TIME -> $t {\n\n    my $exact = AMBIENT_TEMP + (INITIAL_TEMP - AMBIENT_TEMP)\n                              × (-COOLING_RATE × $t).exp;\n\n    my $err = sub { @^a.map: { 100 × ($_ - $exact).abs / $exact } }\n\n    my ( $a, $b, $c ) = map { @e[$_][$t] }, 2, 5, 10;\n\n    say $t.fmt('%4d '), ( $exact, $a, $b, $c )».fmt(' %7.3f'),\n                            $err([$a, $b, $c])».fmt(' %7.3f%%');\n}\n\n```\n\nOutput:\n\n```\nTime Analytic   Step2   Step5  Step10     Err2     Err5    Err10\n   0  100.000 100.000 100.000 100.000   0.000%   0.000%   0.000%\n  10   59.727  57.634  53.800  44.000   3.504%   9.923%  26.331%\n  20   39.728  37.704  34.281  27.200   5.094%  13.711%  31.534%\n  30   29.797  28.328  26.034  22.160   4.927%  12.629%  25.629%\n  40   24.865  23.918  22.549  20.648   3.808%   9.313%  16.959%\n  50   22.416  21.843  21.077  20.194   2.555%   5.972%   9.910%\n  60   21.200  20.867  20.455  20.058   1.569%   3.512%   5.384%\n  70   20.596  20.408  20.192  20.017   0.912%   1.959%   2.808%\n  80   20.296  20.192  20.081  20.005   0.512%   1.057%   1.432%\n  90   20.147  20.090  20.034  20.002   0.281%   0.559%   0.721%\n 100   20.073  20.042  20.014  20.000   0.152%   0.291%   0.361%\n```"}]}
{"messages": [{"role": "user", "content": "Task.\n\nCompute the Euler constant 0.5772...\n\nDiscovered by Leonhard Euler around 1730, it is the most ubiquitous mathematical constant after pi and e, but appears more arcane than these.\n\nDenoted gamma (*γ*), it measures the amount by which the partial sums of the harmonic series (the simplest diverging series) differ from the logarithmic function (its approximating integral): lim n → ∞ (1 + 1/2 + 1/3 + … + 1/n − log(n)).\n\nThe definition of *γ* converges too slowly to be numerically useful, but in 1735 Euler himself applied his recently discovered summation formula to compute ‘the notable number’ accurate to 15 places. For a single-precision implementation this is still the most economic algorithm.\n\nIn 1961, the young Donald Knuth used Euler's method to evaluate *γ* to 1271 places. Knuth found that the computation of the Bernoulli numbers required in the Euler-Maclaurin formula was the most time-consuming part of the procedure.\n\nThe next year Dura Sweeney computed 3566 places, using a formula based on the expansion of the exponential integral which didn't need Bernoulli numbers. It's a bit-hungry method though: *2d* digits of working precision obtain *d* correct places only.\n\nThis was remedied in 1988 by David Bailey; meanwhile Richard Brent and Ed McMillan had published an even more efficient algorithm based on Bessel function identities and found 30100 places in 20 hours time.\n\nNowadays the old records have far been exceeded: over 6·1011 decimal places are already known. These massive computations suggest that *γ* is neither rational nor algebraic, but this is yet to be proven.\n\nReferences.\n\n[1]\nGourdon and Sebah, The Euler constant *γ*. (for all formulas)\n\n[2]\nEuler's original journal article translated from the latin (p. 9)"}, {"role": "assistant", "content": "```\n# 20211124 Raku programming solution \n\nsub gamma (\\N where N > 1) { # Vacca series https://w.wiki/4ybp\n                             # convert terms to FatRat for arbitrary precision\n   return  (1/2 - 1/3) + [+] (2..N).race.map: -> \\n {\n\n      my ($power, $sign, $term) = 2**n, -1;\n\n      for ($power..^2*$power) { $term += ($sign = -$sign) / $_ }\n\n      n*$term\n   }\n}\n\nsay gamma 23 ;\n\n```\n\nOutput:\n\n```\n0.5772149198434515\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Euler's\\_identity. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn mathematics, *Euler's identity* is the equality:\n\n```\n               ei\n  \n    \n      \n        \n          \n            π\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\pi }}\n  \n + 1 = 0\n\n```\n\nwhere\n\n```\n   e is Euler's number, the base of natural logarithms,\n   i is the imaginary unit, which satisfies i2 = −1, and\n   \n  \n    \n      \n        \n          \n            π\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\pi }}\n  \n is pi, the ratio of the circumference of a circle to its diameter.\n\n```\n\nEuler's identity is often cited as an example of deep mathematical beauty. Three of the basic arithmetic operations occur exactly once each: addition, multiplication, and exponentiation. The identity also links five fundamental mathematical constants:\n\n```\n   The number 0.\n   The number 1.\n   The number \n  \n    \n      \n        \n          \n            π\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\pi }}\n  \n (\n  \n    \n      \n        \n          \n            π\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\pi }}\n  \n = 3.14159+),\n   The number e (e = 2.71828+), which occurs widely in mathematical analysis.\n   The number i, the imaginary unit of the complex numbers.\n\n```\n\nTask\n\nShow in your language that Euler's identity is true. As much as possible and practical, mimic the Euler's identity equation.\n\nMost languages are limited to IEEE 754 floating point calculations so will have some error in the calculation.\n\nIf that is the case, or there is some other limitation, show\nthat ei\n\nπ\n{\\displaystyle {\\displaystyle \\pi }} + 1 is *approximately* equal to zero and\nshow the amount of error in the calculation.\n\nIf your language is capable of symbolic calculations, show\nthat ei\n\nπ\n{\\displaystyle {\\displaystyle \\pi }} + 1 is *exactly* equal to zero for bonus kudos points."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nImplementing an \"invisible times\" operator (Unicode character (U+2062)) to more closely emulate the layout. Alas, Raku does not do symbolic calculations at this time and is limited to IEEE 754 floating point for transcendental and irrational number calculations.\n\ne, i and π are all available as built-in constants in Raku.\n\n```\nsub infix:<⁢> is tighter(&infix:<**>) { $^a * $^b };\n\nsay 'e**i⁢π + 1 ≅ 0 : ', e**i⁢π + 1 ≅ 0;\nsay 'Error: ', e**i⁢π + 1;\n\n```\n\nOutput:\n\n```\ne**i⁢π + 1 ≅ 0 : True\nError: 0+1.2246467991473532e-16i\n```"}]}
{"messages": [{"role": "user", "content": "There is a conjecture in mathematics that held for over two hundred years before it was disproved by the finding of a counterexample in 1966 by Lander and Parkin.\n\nThis conjecture is called Euler's sum of powers conjecture and can be stated as such:\n\n:   At least k positive kth powers are required to sum to a kth power, except for the trivial case of one kth power: yk = yk.\n\nIn 1966, Leon J. Lander and Thomas R. Parkin used a brute-force search on a CDC 6600 computer restricting numbers to those less than 250.\n\nThe task consists in writing a program to search for an integer solution of \n\nx\n\n0\n\n5\n+\n\nx\n\n1\n\n5\n+\n\nx\n\n2\n\n5\n+\n\nx\n\n3\n\n5\n=\n\ny\n\n5\n{\\displaystyle {\\displaystyle x\\_{0}^{5}+x\\_{1}^{5}+x\\_{2}^{5}+x\\_{3}^{5}=y^{5}}}\n where all \n\nx\n\ni\n{\\displaystyle {\\displaystyle x\\_{i}}}\n and \n\ny\n{\\displaystyle {\\displaystyle y}}\n are distinct integers between 0 and 250 (exclusive). Show an answer here.\n\nRelated tasks are:\n\n* Pythagorean quadruples.\n* Pythagorean triples."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n```\nconstant MAX = 250;\n\nmy  %po5{Int};\nmy %sum2{Int};\n\nfor 1..MAX -> \\i {\n    %po5{i⁵} = i;\n    for 1..MAX -> \\j {\n        %sum2{i⁵ + j⁵} = i, j;\n    }\n}\n\n%po5.keys.sort.race.map: -> \\p {\n    for %sum2.keys.sort -> \\s {\n        if p > s and %sum2{p - s} {\n            say ((sort |%sum2{s},|%sum2{p - s}) X~ '⁵').join(' + '), \" = %po5{p}\", \"⁵\" and exit\n        }\n    }\n}\n\n```\n\nOutput:\n\n```\n27⁵ + 84⁵ + 110⁵ + 133⁵ = 144⁵\n```"}]}
{"messages": [{"role": "user", "content": "This programming task, is to calculate ANY binomial coefficient.\n\nHowever, it has to be able to output   \n\n(\n\n5\n3\n\n)\n{\\displaystyle {\\displaystyle {\\binom {5}{3}}}}\n,   which is   **10**.\n\nThis formula is recommended:\n\n:   :   (\n\n        n\n        k\n\n        )\n        =\n\n        n\n        !\n\n        (\n        n\n        −\n        k\n        )\n        !\n        k\n        !\n        =\n\n        n\n        (\n        n\n        −\n        1\n        )\n        (\n        n\n        −\n        2\n        )\n        …\n        (\n        n\n        −\n        k\n        +\n        1\n        )\n\n        k\n        (\n        k\n        −\n        1\n        )\n        (\n        k\n        −\n        2\n        )\n        …\n        1\n        {\\displaystyle {\\displaystyle {\\binom {n}{k}}={\\frac {n!}{(n-k)!k!}}={\\frac {n(n-1)(n-2)\\ldots (n-k+1)}{k(k-1)(k-2)\\ldots 1}}}}\n\n**See Also:**\n\n* Combinations and permutations\n* Pascal's triangle\n\n:   :   :   :   The number of samples of size k from n objects.\n                  \n                  \n                With   combinations and permutations   generation tasks.\n\n                |  | Order Unimportant | Order Important |\n                | --- | --- | --- |\n                | Without replacement | (  n k  )  =  n  C  k =    n ( n − 1 ) … ( n − k + 1 )  k ( k − 1 ) … 1 {\\displaystyle {\\displaystyle {\\binom {n}{k}}=^{n}\\operatorname {C} \\_{k}={\\frac {n(n-1)\\ldots (n-k+1)}{k(k-1)\\dots 1}}}} | n  P  k = n ⋅ ( n − 1 ) ⋅ ( n − 2 ) ⋯ ( n − k + 1 ) {\\displaystyle {\\displaystyle ^{n}\\operatorname {P} \\_{k}=n\\cdot (n-1)\\cdot (n-2)\\cdots (n-k+1)}} |\n                | Task: Combinations | Task: Permutations |\n                | With replacement | (   n + k − 1 k  )  =  n + k − 1  C  k =    ( n + k − 1 ) !  ( n − 1 ) ! k ! {\\displaystyle {\\displaystyle {\\binom {n+k-1}{k}}=^{n+k-1}\\operatorname {C} \\_{k}={(n+k-1)! \\over (n-1)!k!}}} | n  k {\\displaystyle {\\displaystyle n^{k}}} |\n                | Task: Combinations with repetitions | Task: Permutations with repetitions |"}, {"role": "assistant", "content": "(formerly Perl 6)\nFor a start, you can get the length of the corresponding list of combinations:\n\n```\nsay combinations(5, 3).elems;\n\n```\n\nOutput:\n\n```\n10\n```\n\nThis method is efficient, as Raku will not actually compute each element of the list, since it actually uses an iterator with a defined count-only method. Such method performs computations in a way similar to the following infix operator:\n\n```\nsub infix:<choose> { [*] ($^n ... 0) Z/ 1 .. $^p }\nsay 5 choose 3;\n```\n\nA possible optimization would use a symmetry property of the binomial coefficient:\n\n```\nsub infix:<choose> { [*] ($^n ... 0) Z/ 1 .. min($n - $^p, $p) }\n```\n\nOne drawback of this method is that it returns a Rat, not an Int. So we actually may want to enforce the conversion:\n\n```\nsub infix:<choose> { ([*] ($^n ... 0) Z/ 1 .. min($n - $^p, $p)).Int }\n```\n\nAnd *this* is exactly what the count-only method does."}]}
{"messages": [{"role": "user", "content": "In 1742, Goldbach and Euler corresponded about what is now known as the Goldbach Conjecture: that all even integers greater than 2 can be written as the sum of two primes.\n  \nIn 2000, Henry Dubner proposed a stronger conjecture: that every even integer greater than 4208 can be written as the sum of two twin primes.\n  \n  \nAt the time the Goldbach conjecture was made, 1 was considered a prime number - this is not so now. So, the Goldbach conjecture was originally that all even natural numbers could be written as the sum of two primes.\n\nTask\n\n* Find and display the positive even integers that cannot be expressed as the sum of two twin primes, up to a limit of 5,000.\n\n:   :   E.g.: The first 3 twin primes are 3, 5 and 7, so 6 (3+3), 8 (5+3) and 10 (5+5 or 7+3) can be formed but 2 and 4 cannot.\n\n* Show the numbers that cannot be formed by summing two twin primes when 1 is treated as a prime (and so a twin prime).\n\nNote\n\n* For the purposes of this task, twin prime refers to a prime that is 2 more or less than another prime, not the pair of primes.\n\nStretch\n\n* Verify that there no more such numbers up to 10,000 or more, as you like (note it has been verified up to at least 10^9).\n\nSee also\n\n* Wikipedia: Dubner's conjecture * Wikipedia: Goldbach's conjecture * OEIS:A007534 - Even numbers that are not the sum of a pair of twin primes. * Twin primes"}, {"role": "assistant", "content": "```\nmy $threshold = 10000;\n\nmy @twins = unique flat (3..$threshold).grep(&is-prime).map: { $_, $_+2 if ($_+2).is-prime };\nmy @sums;\n\nmap {++@sums[$_]}, (@twins X+ @twins);\ndisplay 'Non twin prime sums:', @sums;\n\nmap {++@sums[$_]}, flat 2, (1 X+ @twins);\ndisplay \"\\nNon twin prime sums (including 1):\", @sums;\n\nsub display ($msg, @p) {\n    put \"$msg\\n\" ~ @p[^$threshold].kv.map(-> $k, $v { $k if ($k %% 2) && !$v })\\\n    .skip(1).batch(10)».fmt(\"%4d\").join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\nNon twin prime sums:\n   2    4   94   96   98  400  402  404  514  516\n 518  784  786  788  904  906  908 1114 1116 1118\n1144 1146 1148 1264 1266 1268 1354 1356 1358 3244\n3246 3248 4204 4206 4208\n\nNon twin prime sums (including 1):\n  94   96   98  400  402  404  514  516  518  784\n 786  788  904  906  908 1114 1116 1118 1144 1146\n1148 1264 1266 1268 1354 1356 1358 3244 3246 3248\n4204 4206 4208\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nTest whether an integer is even or odd.\n\nThere is more than one way to solve this task:\n\n* Use the even and odd predicates, if the language provides them.\n* Check the least significant digit. With binary integers, *i bitwise-and 1* equals 0 iff *i* is even, or equals 1 iff *i* is odd.\n* Divide *i* by 2. The remainder equals 0 iff *i* is even. The remainder equals +1 or -1 iff *i* is odd.\n* Use modular congruences:\n  + *i* ≡ 0 (mod 2) iff *i* is even.\n  + *i* ≡ 1 (mod 2) iff *i* is odd."}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku doesn't have a built-in for this, but with subsets it's easy to define a predicate for it.\n\n```\nsubset Even of Int where * %% 2;\nsubset Odd of Int where * % 2;\n\nsay 1 ~~ Even; # false\nsay 1 ~~ Odd;  # true\nsay 1.5 ~~ Odd # false ( 1.5 is not an Int )\n```"}]}
{"messages": [{"role": "user", "content": "**Event** is a synchronization object. An event has two states *signaled* and *reset*. A task may await for the event to enter the desired state, usually the *signaled* state. It is released once the state is entered. Releasing waiting tasks is called *event notification*. Programmatically controlled events can be set by a task into one of its states.\n\nIn concurrent programming event also refers to a notification that some state has been reached through an asynchronous activity. The source of the event can be:\n\n* *internal*, from another task, programmatically;\n* *external*, from the hardware, such as user input, timer, etc. Signaling an event from the hardware is accomplished by means of hardware interrupts.\n\nEvent is a low-level synchronization mechanism. It neither identify the state that caused it signaled, nor the source of, nor who is the subject of notification. Events augmented by data and/or publisher-subscriber schemes are often referred as **messages**, **signals** etc.\n\nIn the context of general programming **event-driven architecture** refers to a design that deploy events in order to synchronize tasks with the asynchronous activities they must be aware of. The opposite approach is **polling** sometimes called **busy waiting**, when the synchronization is achieved by an explicit periodic querying the state of the activity. As the name suggests busy waiting consumes system resources even when the external activity does not change its state.\n\nEvent-driven architectures are widely used in GUI design and SCADA systems. They are flexible and have relatively short response times. At the same time event-driven architectures suffer to the problems related to their unpredictability. They face race condition, deadlocking, live locks and priority inversion. For this reason real-time systems tend to polling schemes, trading performance for predictability in the worst case scenario.\n\n# Variants of events\n\n## Manual-reset event\n\nThis event changes its state by an explicit request of a task. I.e. once signaled it remains in this state until it will be explicitly reset.\n\n## Pulse event\n\nA pulse event when signaled releases all tasks awaiting it and then is automatically reset.\n\n# Sample implementations / APIs\n\nShow how a manual-reset event can be implemented in the language or else use an API to a library that provides events. Write a program that waits 1s and then signals the event to a task waiting for the event."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Go\n\n```\nnote now, \" program start\";\nmy $event = Channel.new;\n\nmy $todo = start {\n    note now, \" task start\";\n    $event.receive;\n    note now, \" event reset by task\";\n}\n\nnote now, \" program sleeping\";\nsleep 1;\nnote now, \" program signaling event\";\n$event.send(0);\nawait $todo;\n\n```\n\nOutput:\n\n```\nInstant:1403880984.089974 program start\nInstant:1403880984.095400 program sleeping\nInstant:1403880984.095491 task start\nInstant:1403880985.099381 program signaling event\nInstant:1403880985.109395 event reset by task\n```\n\nSee also Handle\\_a\\_signal#Raku for an example of using Supplies to do reactive programming based on events (Unix signals in this case)."}]}
{"messages": [{"role": "user", "content": "Starting with:\n\n* The `target` string: `\"METHINKS IT IS LIKE A WEASEL\"`.\n* An array of random characters chosen from the set of upper-case letters together with the space, and of the same length as the target string. (Call it the `parent`).\n* A `fitness` function that computes the ‘closeness’ of its argument to the target string.\n* A `mutate` function that given a string and a mutation rate returns a copy of the string, with some characters probably mutated.\n* While the `parent` is not yet the `target`:\n\n:   * copy the `parent` C times, each time allowing some random probability that another character might be substituted using `mutate`.\n    * Assess the `fitness` of the parent and all the copies to the `target` and make the most fit string the new `parent`, discarding the others.\n    * repeat until the parent converges, (hopefully), to the target.\n\nSee also\n\n* Wikipedia entry:   Weasel algorithm.\n* Wikipedia entry:   Evolutionary algorithm.\n\nNote: to aid comparison, try and ensure the variables and functions mentioned in the task description appear in solutions\n\nA cursory examination of a few of the solutions reveals that the instructions have not been followed rigorously in some solutions. Specifically,\n\n* While the `parent` is not yet the `target`:\n\n:   * copy the `parent` C times, each time allowing some random probability that another character might be substituted using `mutate`.\n\nNote that some of the the solutions given retain characters in the mutated string that are *correct* in the target string. However, the instruction above does not state to retain any of the characters while performing the mutation. Although some may believe to do so is implied from the use of \"converges\"\n\n```\n(:* repeat until the parent converges, (hopefully), to the target.\n\n```\n\nStrictly speaking, the new parent should be selected from the new pool of mutations, and then the new parent used to generate the next set of mutations with parent characters getting retained only by *not* being mutated. It then becomes possible that the new set of mutations has no member that is fitter than the parent!\n\nAs illustration of this error, the code for 8th has the following remark.\n\n```\nCreate a new string based on the TOS, changing randomly any characters which\ndon't already match the target:\n\n```\n\n*NOTE:* this has been changed, the 8th version is completely random now\n\nClearly, this algo will be applying the mutation function only to the parent characters that don't match to the target characters!\n\nTo ensure that the new parent is never less fit than the prior parent, both the parent and all of the latest mutations are subjected to the fitness test to select the next parent."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2022-07-09\n\n```\nconstant target = \"METHINKS IT IS LIKE A WEASEL\";\nconstant @alphabet = flat 'A'..'Z',' ';\nconstant C = 10;\n\nsub mutate(Str $string, Real $mutate-chance where 0 ≤ * < 1) {\n  $string.subst: /<?{ rand < $mutate-chance }> . /, @alphabet.pick, :global\n}\nsub fitness(Str $string) { [+] $string.comb Zeq target.comb }\n\nprintf \"\\r%6d: '%s'\", $++, $_ for\n  @alphabet.roll(target.chars).join,\n  { max :by(&fitness), mutate($_, .001) xx C } ... target;\nprint \"\\n\";\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven 5 lists of ints:\n  \nlist[1] = [9,3,3,3,2,1,7,8,5]\n  \nlist[2] = [5,2,9,3,3,7,8,4,1]\n  \nlist[3] = [1,4,3,6,7,3,8,3,2]\n  \nlist[4] = [1,2,3,4,5,6,7,8,9]\n  \nlist[5] = [4,6,8,7,2,3,3,3,1]\n  \n  \nFor each list, print 'true' if the list contains exactly three '3's that form a consecutive subsequence, otherwise print 'false'.\nThat is, print false unless there is exactly one run of three '3's and there is no other occurrence of a '3'."}, {"role": "assistant", "content": "Generalized\n\n```\nfor 1 .. 4 -> $n {\n\n    say \"\\nExactly $n {$n}s, and they are consecutive:\";\n\n    say .gist, ' ', lc (.Bag{$n} == $n) && ( so .rotor($n=>-($n - 1)).grep: *.all == $n ) for\n    [9,3,3,3,2,1,7,8,5],\n    [5,2,9,3,3,7,8,4,1],\n    [1,4,3,6,7,3,8,3,2],\n    [1,2,3,4,5,6,7,8,9],\n    [4,6,8,7,2,3,3,3,1],\n    [3,3,3,1,2,4,5,1,3],\n    [0,3,3,3,3,7,2,2,6],\n    [3,3,3,3,3,4,4,4,4]\n}\n\n```\n\nOutput:\n\n```\nExactly 1 1s, and they are consecutive:\n[9 3 3 3 2 1 7 8 5] true\n[5 2 9 3 3 7 8 4 1] true\n[1 4 3 6 7 3 8 3 2] true\n[1 2 3 4 5 6 7 8 9] true\n[4 6 8 7 2 3 3 3 1] true\n[3 3 3 1 2 4 5 1 3] false\n[0 3 3 3 3 7 2 2 6] false\n[3 3 3 3 3 4 4 4 4] false\n\nExactly 2 2s, and they are consecutive:\n[9 3 3 3 2 1 7 8 5] false\n[5 2 9 3 3 7 8 4 1] false\n[1 4 3 6 7 3 8 3 2] false\n[1 2 3 4 5 6 7 8 9] false\n[4 6 8 7 2 3 3 3 1] false\n[3 3 3 1 2 4 5 1 3] false\n[0 3 3 3 3 7 2 2 6] true\n[3 3 3 3 3 4 4 4 4] false\n\nExactly 3 3s, and they are consecutive:\n[9 3 3 3 2 1 7 8 5] true\n[5 2 9 3 3 7 8 4 1] false\n[1 4 3 6 7 3 8 3 2] false\n[1 2 3 4 5 6 7 8 9] false\n[4 6 8 7 2 3 3 3 1] true\n[3 3 3 1 2 4 5 1 3] false\n[0 3 3 3 3 7 2 2 6] false\n[3 3 3 3 3 4 4 4 4] false\n\nExactly 4 4s, and they are consecutive:\n[9 3 3 3 2 1 7 8 5] false\n[5 2 9 3 3 7 8 4 1] false\n[1 4 3 6 7 3 8 3 2] false\n[1 2 3 4 5 6 7 8 9] false\n[4 6 8 7 2 3 3 3 1] false\n[3 3 3 1 2 4 5 1 3] false\n[0 3 3 3 3 7 2 2 6] false\n[3 3 3 3 3 4 4 4 4] true\n```"}]}
{"messages": [{"role": "user", "content": "This task is to give an example of an exception handling routine\nand to \"throw\" a new exception.\n\nRelated task\n\n* Exceptions Through Nested Calls"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-10\n\nThe Raku equivalent to Perl 5's eval {...} is try {...}. A try block by default has a CATCH block that handles all fatal exceptions by ignoring them. If you define a CATCH block within the try, it replaces the default CATCH. It also makes the try keyword redundant, because any block can function as a try block if you put a CATCH block within it. The inside of a CATCH functions as a switch statement on the current exception.\n\n```\ntry {\n    die \"Help I'm dieing!\";\n    CATCH {\n        when X::AdHoc { note .Str.uc; say \"Cough, Cough, Aiee!!\" }\n        default { note \"Unexpected exception, $_!\" }\n    }\n}\n\nsay \"Yay. I'm alive.\";\n\ndie \"I'm dead.\";\n\nsay \"Arrgh.\";\n\nCATCH {\n    default { note \"No you're not.\"; say $_.Str; }\n}\n```\n\n```\nHELP I'M DIEING!\nCough, Cough, Aiee!!\nYay. I'm alive.\nNo you're not.\nI'm dead.\n\n```\n\nRake comes with phasers, that are called when certain conditions in the life of a program, routine or block are met. CATCH is one of them and works nicely together with LEAVE that is called even if an exception would force the current block to be left immediately. It's a nice place to put your cleanup code.\n\n```\nsub f(){\n        ENTER { note '1) f has been entered' }\n        LEAVE { note '2) f has been left' }\n        say '3) here be dragons';\n        die '4) that happend to be deadly';\n}\n\nf();\nsay '5) am I alive?';\n\nCATCH {\n        when X::AdHoc { note q{6) no, I'm dead}; }\n}\n```\n\n```\n1) f has been entered\n3) here be dragons\n6) no, I'm dead\n2) f has been left\n```"}]}
{"messages": [{"role": "user", "content": "Show how to create a user-defined exception   and   show how to catch an exception raised from several nested calls away.\n\n:   1. Create two user-defined exceptions,   **U0**   and   **U1**.\n    2. Have function   **foo**   call function   **bar**   twice.\n    3. Have function   **bar**   call function   **baz**.\n    4. Arrange for function   **baz**   to raise, or throw exception   **U0**   on its first call, then exception   **U1**   on its second.\n    5. Function   **foo**   should catch only exception   **U0**,   not   **U1**.\n\nShow/describe what happens when the program is run."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nsub foo() {\n    for 0..1 -> $i {\n        bar $i;\n        CATCH {\n            when /U0/ { say \"Function foo caught exception U0\" }\n        }\n    }\n}\n\nsub bar($i) { baz $i }\n\nsub baz($i) { die \"U$i\" }\n\nfoo;\n\n```\n\nOutput:\n\n```\nFunction foo caught exception U0\nU1\n  in sub baz at catch:12\n  in sub bar at catch:10\n  in sub foo at catch:4\n  in block  at catch:14\n```"}]}
{"messages": [{"role": "user", "content": "The general idea behind an executable library is to create a library\nthat when used as a library does one thing;\nbut has the ability to be run directly via command line.\nThus the API comes with a CLI in the very same source code file.\n\n**Task detail**\n\n* Create a library/module/dll/shared object/... for a programming language that contains a function/method called hailstone that is a function taking a positive integer and returns the Hailstone sequence for that number.\n\n* The library, when executed directly should satisfy the remaining requirements of the Hailstone sequence task:\n\n:   :   2. Use the routine to show that the hailstone sequence for the number 27 has 112 elements starting with 27, 82, 41, 124 and ending with 8, 4, 2, 1\n    :   3. Show the number less than 100,000 which has the longest hailstone sequence together with that sequence's length.\n\n* Create a second executable to calculate the following:\n  + Use the library's hailstone function, in the standard manner, (or document how this use deviates from standard use of a library), together with extra code in this executable, to find the hailstone length returned most often for 1 ≤ n < 100,000.\n\n* Explain any extra setup/run steps needed to complete the task.\n\n**Notes:**\n\n* It is assumed that for a language that overwhelmingly ships in a compiled form, such as C, the library must also be an executable and the compiled user of that library is to do so without changing the compiled library. I.e. the compile tool-chain is assumed *not* to be present in the runtime environment.\n* Interpreters are present in the runtime environment."}, {"role": "assistant", "content": "(formerly Perl 6)\nThe library can be written as a module:\n\n```\nmodule Hailstone {\n    our sub hailstone($n) is export {\n\t$n, { $_ %% 2 ?? $_ div 2 !! $_ * 3 + 1 } ... 1\n    }\n}\n\nsub MAIN {\n    say \"hailstone(27) = {.[^4]} [...] {.[*-4 .. *-1]}\" given Hailstone::hailstone 27;\n}\n\n```\n\nIt can be run with:\n\n```\n$ raku Hailstone.rakumod\n\n```\n\nOutput:\n\n```\nhailstone(27) = 27 82 41 124 [...] 8 4 2 1\n```\n\nIt can then be used with a program such as:\n\n```\nuse Hailstone;\nmy %score;\n(1 .. 100_000).race.map: { %score{hailstone($_).elems}++ };\nsay \"Most common length is {.key}, occurring {.value} times.\" given max :by(*.value), %score;\n\n```\n\nCalled with a command line as:\n\n```\n$ RAKULIB=. raku test-hailstone.raku\n```\n\nThe environment variable RAKULIB might be necessary if the file Hailstone.rakumod is not in the standard library path for Raku."}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Markov\\_algorithm. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nCreate an interpreter for a Markov Algorithm.\n\nRules have the syntax:\n\n```\n<ruleset> ::= ((<comment> | <rule>) <newline>+)*\n<comment> ::= # {<any character>}\n<rule> ::= <pattern> <whitespace> -> <whitespace> [.] <replacement>\n<whitespace> ::= (<tab> | <space>) [<whitespace>]\n\n```\n\nThere is one rule per line.\n\nIf there is a   **.**   (period)   present before the   **<replacement>**,   then this is a terminating rule in which case the interpreter must halt execution.\n\nA ruleset consists of a sequence of rules, with optional comments.\n\nRulesets\n\nUse the following tests on entries:\n\nRuleset 1\n\n```\n# This rules file is extracted from Wikipedia:\n# http://en.wikipedia.org/wiki/Markov_Algorithm\nA -> apple\nB -> bag\nS -> shop\nT -> the\nthe shop -> my brother\na never used -> .terminating rule\n\n```\n\nSample text of:\n\n:   `I bought a B of As from T S.`\n\nShould generate the output:\n\n:   `I bought a bag of apples from my brother.`\n\nRuleset 2\n\nA test of the terminating rule\n\n```\n# Slightly modified from the rules on Wikipedia\nA -> apple\nB -> bag\nS -> .shop\nT -> the\nthe shop -> my brother\na never used -> .terminating rule\n```\n\nSample text of:\n\n:   `I bought a B of As from T S.`\n\nShould generate:\n\n:   `I bought a bag of apples from T shop.`\n\nRuleset 3\n\nThis tests for correct substitution order and may trap simple regexp based replacement routines if special regexp characters are not escaped.\n\n```\n# BNF Syntax testing rules\nA -> apple\nWWWW -> with\nBgage -> ->.*\nB -> bag\n->.* -> money\nW -> WW\nS -> .shop\nT -> the\nthe shop -> my brother\na never used -> .terminating rule\n\n```\n\nSample text of:\n\n:   `I bought a B of As W my Bgage from T S.`\n\nShould generate:\n\n:   `I bought a bag of apples with my money from T shop.`\n\nRuleset 4\n\nThis tests for correct order of scanning of rules, and may trap replacement routines that scan in the wrong order.   It implements a general unary multiplication engine.   (Note that the input expression must be placed within underscores in this implementation.)\n\n```\n### Unary Multiplication Engine, for testing Markov Algorithm implementations\n### By Donal Fellows.\n# Unary addition engine\n_+1 -> _1+\n1+1 -> 11+\n# Pass for converting from the splitting of multiplication into ordinary\n# addition\n1! -> !1\n,! -> !+\n_! -> _\n# Unary multiplication by duplicating left side, right side times\n1*1 -> x,@y\n1x -> xX\nX, -> 1,1\nX1 -> 1X\n_x -> _X\n,x -> ,X\ny1 -> 1y\ny_ -> _\n# Next phase of applying\n1@1 -> x,@y\n1@_ -> @_\n,@_ -> !_\n++ -> +\n# Termination cleanup for addition\n_1 -> 1\n1+_ -> 1\n_+_ -> \n\n```\n\nSample text of:\n\n:   `_1111*11111_`\n\nshould generate the output:\n\n:   `11111111111111111111`\n\nRuleset 5\n\nA simple Turing machine,\nimplementing a three-state busy beaver.\n\nThe tape consists of **0**s and **1**s,   the states are **A**, **B**, **C** and **H** (for **H**alt), and the head position is indicated by writing the state letter before the character where the head is.\nAll parts of the initial tape the machine operates on have to be given in the input.\n\nBesides demonstrating that the Markov algorithm is Turing-complete, it also made me catch a bug in the C++ implementation which wasn't caught by the first four rulesets.\n\n```\n# Turing machine: three-state busy beaver\n#\n# state A, symbol 0 => write 1, move right, new state B\nA0 -> 1B\n# state A, symbol 1 => write 1, move left, new state C\n0A1 -> C01\n1A1 -> C11\n# state B, symbol 0 => write 1, move left, new state A\n0B0 -> A01\n1B0 -> A11\n# state B, symbol 1 => write 1, move right, new state B\nB1 -> 1B\n# state C, symbol 0 => write 1, move left, new state B\n0C0 -> B01\n1C0 -> B11\n# state C, symbol 1 => write 1, move left, halt\n0C1 -> H01\n1C1 -> H11\n\n```\n\nThis ruleset should turn\n\n:   `000000A000000`\n\ninto\n\n:   `00011H1111000`"}, {"role": "assistant", "content": "(formerly Perl 6)\nRun this without arguments and it will scan the cwd for rules.\\* files and their corresponding test.\\*.\n\nRun it with two filenames or one filename and some text to run a rulefile on the file contents or the given text.\n\nAdd --verbose to see the replacements step-by-step.\n\n```\ngrammar Markov {\n    token TOP {\n        ^ [^^ [<rule> | <comment>] $$ [\\n|$]]* $\n        { make $<rule>>>.ast }\n    }\n    token comment {\n        <before ^^> '#' \\N*\n        { make Nil }\n    }\n    token ws {\n        [' '|\\t]*\n    }\n    rule rule {\n        <before ^^>$<pattern>=[\\N+?] '->'\n        $<terminal>=[\\.]?$<replacement>=[\\N*]\n        { make {:pattern($<pattern>.Str),\n                :replacement($<replacement>.Str),\n                :terminal($<terminal>.Str eq \".\")} }\n    }\n}\n \nsub run(:$ruleset, :$start_value, :$verbose?) {\n    my $value = $start_value;\n    my @rules = Markov.parse($ruleset).ast.list;\n    loop {\n        my $beginning = $value;\n        for @rules {\n            my $prev = $value;\n            $value = $value.subst(.<pattern>, .<replacement>);\n            say $value if $verbose && $value ne $prev;\n            return $value if .<terminal>;\n            last if $value ne $prev;\n        }\n        last if $value eq $beginning;\n    }\n    return $value;\n}\n \nmulti sub MAIN(Bool :$verbose?) {\n    my @rulefiles = dir.grep(/rules.+/).sort;\n    for @rulefiles -> $rulefile {\n        my $testfile = $rulefile.subst(\"rules\", \"test\");\n        my $start_value = (try slurp($testfile).trim-trailing)\n                          // prompt(\"please give a start value: \");\n \n        my $ruleset = slurp($rulefile);\n        say $start_value;\n        say run(:$ruleset, :$start_value, :$verbose);\n        say '';\n    }\n}\n \nmulti sub MAIN(Str $rulefile where *.IO.f, Str $input where *.IO.f, Bool :$verbose?) {\n    my $ruleset = slurp($rulefile);\n    my $start_value = slurp($input).trim-trailing;\n    say \"starting with: $start_value\";\n    say run(:$ruleset, :$start_value, :$verbose);\n}\n \nmulti sub MAIN(Str $rulefile where *.IO.f, *@pieces, Bool :$verbose?) {\n    my $ruleset = slurp($rulefile);\n    my $start_value = @pieces.join(\" \");\n    say \"starting with: $start_value\";\n    say run(:$ruleset, :$start_value, :$verbose);\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nRun either the   **ls**   system command   (**dir**   on Windows),   or the   **pause**   system command.\n\nRelated task\n\n* Get system command output"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nrun \"ls\" orelse .die; # output to stdout\n\nmy @ls = qx/ls/;    # output to variable\n\nmy $cmd = 'ls';\n@ls = qqx/$cmd/;  # same thing with interpolation\n```"}]}
{"messages": [{"role": "user", "content": "RCBF is a set of Brainf\\*\\*\\* compilers and interpreters written for Rosetta Code in a variety of languages.\n\nBelow are links to each of the versions of RCBF.\n\nAn implementation need only properly implement the following instructions:\n\n| Command | Description |\n| --- | --- |\n| `>` | Move the pointer to the right |\n| `<` | Move the pointer to the left |\n| `+` | Increment the memory cell under the pointer |\n| `-` | Decrement the memory cell under the pointer |\n| `.` | Output the character signified by the cell at the pointer |\n| `,` | Input a character and store it in the cell at the pointer |\n| `[` | Jump past the matching `]` if the cell under the pointer is 0 |\n| `]` | Jump back to the matching `[` if the cell under the pointer is nonzero |\n\nAny cell size is allowed,   EOF   (End-O-File)   support is optional, as is whether you have bounded or unbounded memory."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nSee Execute\\_Brain\\*\\*\\*\\*/Raku."}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a Computer/zero Assembly emulator. You may consider this webpage as a reference implementation. Output the results of the sample programs \"2+2\" and \"7\\*8\" found there.\n\n:   * The virtual machine \"bytecode\" needs to be able to modify itself (or at least act as though it can) while the virtual machine is running, to be consistent with the reference implementation.\n    * For output, it is sufficient to have the implementation of the `STP` opcode return the accumulator to your actual language, and then use your standard printing routines to output it.\n\nBonus Points\n:   Run all 5 sample programs at the aforementioned website and output their results."}, {"role": "assistant", "content": "Didn't bother implementing an assembler or disassembler.\n\n```\nmy (@mem, $ip, $acc); # memory, instruction pointer, accumulator\n\nsub load (@program) {\n    die \"memory exceeded\" if +@program > 32;\n    $ip = 0;\n    $acc = 0;\n    @mem = @program »%» 256;\n}\n\nsub execute (*@program) {\n    load @program;\n    loop {\n        my $reg = @mem[$ip];\n        quietly my ($inst, $data) = $reg +> 5 +& 7, $reg +& 31;\n        given $inst {\n            when 0 { #`{ NOP } }\n            when 1 { #`{ LDA } $acc = @mem[$data] }\n            when 2 { #`{ STA } @mem[$data] = $acc }\n            when 3 { #`{ ADD } $acc += @mem[$data] }\n            when 4 { #`{ SUB } $acc -= @mem[$data] }\n            when 5 { #`{ BRZ } $ip = $data - 1 unless $acc }\n            when 6 { #`{ JMP } $ip = $data - 1 }\n            when 7 { #`{ STP } last }\n            default { die 'Invalid instruction' }\n        }\n        ++$ip;\n        last if $ip == 32;\n    }\n    $acc\n}\n\nsay \"2 + 2 = \" ~ execute 35,100,224,2,2;\nsay \"7 x 8 = \" ~ execute 44,106,76,43,141,75,168,192,44,224,8,7,0,1;\nsay \"Fibonacci: \" ~\nexecute 46,79,109,78,47,77,48,145,171,80,192,46,224,1,1,0,8,1;\nsay \"Linked list: \" ~\nexecute 45,111,69,112,71,0,78,0,171,79,192,46,\n224,32,0,28,1,0,0,0,6,0,2,26,5,20,3,30,1,22,4,24;\nsay \"Prisoners dilemma: \" ~\nexecute 0,0,224,0,35,157,178,35,93,174,33,127,65,194,\n32,127,64,194,35,93,33,126,99,65,32,126,99,64,194,0,1,3;\n\n```\n\nOutput:\n\n```\n2 + 2 = 4\n7 x 8 = 56\nFibonacci: 55\nLinked list: 6\nPrisoners dilemma: 0\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a **CopyPasta Language** interpreter or compiler. These are the commands used by CopyPasta Language:\n\n| Command | Description |\n| --- | --- |\n| `Copy` | Copy the text of the following line to the clipboard |\n| `CopyFile` | Copy the text of the file cited in the following line to the clipboard or in the case where the next line is TheF\\*ckingCode copies the code to the clipboard |\n| `Duplicate` | Duplicate the text in the clipboard as many times as the following line specifies |\n| `Pasta!` | Display the clipboard and stop the program |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub CopyPasta ($code) {\n    my @code = $code.split(\"\\n\")>>.trim.grep: *.so;\n    return \"Program never ends!\" unless grep { $_ eq 'Pasta!' }, @code;\n\n    my @cb;\n    my $PC = 0;\n    loop {\n        given @code[$PC] {\n            when 'Copy'      {        @cb.push: @code[++$PC] }\n            when 'CopyFile'  { $PC++; @cb.push: @code[$PC] eq 'TheF*ckingCode' ?? @code !! slurp @code[$PC] }\n            when 'Duplicate' {        @cb = (flat @cb) xx @code[++$PC] }\n            when 'Pasta!'    { return @cb }\n            default          { return \"Does not compute: @code[$PC]\" }\n        }\n        $PC++;\n    }\n}\n\nspurt 'pasta.txt', \"I'm the pasta.txt file.\";\n\n(say $_ for .&CopyPasta; say '')\n    for\n    \"Copy \\nRosetta Code\\n\\tDuplicate\\n2\\n\\nPasta!\\nLa Vista\",\n    \"CopyFile\\npasta.txt\\nDuplicate\\n1\\nPasta!\",\n    \"Copy\\nInvalid\\n Duplicate\\n1\\n\\nGoto\\n3\\nPasta!\",\n    \"CopyFile\\nTheF*ckingCode\\nDuplicate\\n2\\nPasta!\",\n    \"Copy\\nRosetta Code\\nDuplicate\\n2\\n\\nPasta\";\n\nunlink 'pasta.txt';\n\n```\n\nOutput:\n\n```\nRosetta Code\nRosetta Code\n\nI'm the pasta.txt file.\n\nDoes not compute: Goto\n\nCopyFile TheF*ckingCode Duplicate 2 Pasta!\nCopyFile TheF*ckingCode Duplicate 2 Pasta!\n\nProgram never ends!\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a    **HQ9+**    interpreter or compiler."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-10\n\nThe spec is kind of vague about how to do error handling... and whether white space is significant... and how the accumulator should be accessed... and pretty much everything else too.\n\n```\nclass HQ9Interpreter {\n    has @!code;\n    has $!accumulator;\n    has $!pointer;\n \n    method run ($code) {\n        @!code = $code.comb;\n        $!accumulator = 0;\n        $!pointer = 0;\n        while $!pointer < @!code {\n            given @!code[$!pointer].lc {\n                when 'h' { say 'Hello world!' }\n                when 'q' { say @!code }\n                when '9' { bob(99) }\n                when '+' { $!accumulator++ }\n                default  { note \"Syntax error: Unknown command \\\"{@!code[$!pointer]}\\\"\" }\n            }\n\t    $!pointer++;\n        }\n    }\n    sub bob ($beer is copy) {\n        sub what  { \"{$beer??$beer!!'No more'} bottle{$beer-1??'s'!!''} of beer\" };\n        sub where { 'on the wall' };\n        sub drink { $beer--; \"Take one down, pass it around,\" }\n        while $beer {\n            .say for \"&what() &where(),\", \"&what()!\",\n                     \"&drink()\", \"&what() &where()!\", ''\n        }\n    }\n}\n\n# Feed it a command string:\n\nmy $hq9 = HQ9Interpreter.new;\n$hq9.run(\"hHq+++Qq\");\nsay '';\n$hq9.run(\"Jhq.k+hQ\");\n\n```\n\nOutput:\n\n```\nHello world!\nHello world!\nhHq+++Qq\nhHq+++Qq\nhHq+++Qq\n\nSyntax error: Unknown command \"J\"\nHello world!\nJhq.k+hQ\nSyntax error: Unknown command \".\"\nSyntax error: Unknown command \"k\"\nHello world!\nJhq.k+hQ\n\n```\n\nOr start a REPL (Read Execute Print Loop) and interact at the command line:\n\n```\nmy $hq9 = HQ9Interpreter.new;\nwhile 1 {\n    my $in = prompt('HQ9+>').chomp;\n    last unless $in.chars;\n    $hq9.run($in)\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "**RCSNUSP** is a set of SNUSP compilers and interpreters written for Rosetta Code in a variety of languages. Below are links to each of the versions of RCSNUSP.\n\nAn implementation need only properly implement the Core SNUSP instructions ('$', '\\', '/', '+', '-', '<', '>', ',', '.', '!', and '?'). Modular SNUSP ('#', '@') and Bloated SNUSP (':', ';', '%', and '&') are also allowed, but not required. Any extra characters that you implement should be noted in the description of your implementation. Any cell size is allowed, EOF support is optional, as is whether you have bounded or unbounded memory."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.02\n\nImplementation of modular SNUSP.\n\n```\nclass SNUSP {\n\n    has @!inst-pointer;\n    has @!call-stack;\n    has @!direction;\n    has @!memory;\n    has $!mem-pointer;\n\n    method run ($code) {\n        init();\n        my @code = pad( |$code.lines );\n        for @code.kv -> $r, @l {\n           my $index = @l.grep( /'$'/, :k );\n           if $index {\n               @!inst-pointer = $r, $index;\n               last\n           }\n        }\n\n        loop {\n            my $instruction = @code[@!inst-pointer[0]; @!inst-pointer[1]];\n            given $instruction {\n                when '>'  { $!mem-pointer++ }\n                when '<'  { $!mem-pointer-- }\n                when '+'  { @!memory[$!mem-pointer]++ }\n                when '-'  { @!memory[$!mem-pointer]-- }\n                when '.'  { print @!memory[$!mem-pointer].chr }\n                when ','  { @!memory[$!mem-pointer] = $*IN.getc.ord }\n                when '/'  { @!direction = @!direction.reverse «*» -1 }\n                when '\\\\' { @!direction = @!direction.reverse }\n                when '!'  { nexti() }\n                when '?'  { nexti() unless @!memory[$!mem-pointer] }\n                when '@'  { @!call-stack.push: @!inst-pointer.Array }\n                when '#'  {\n                    last unless +@!call-stack;\n                    @!inst-pointer = |@!call-stack.pop;\n                    nexti();\n                }\n            }\n            nexti();\n            last if @!inst-pointer[0] > +@code or\n                    @!inst-pointer[1] > +@code[0];\n        }\n\n        sub init () {\n            @!inst-pointer = 0, 0;\n            @!direction    = 0, 1;\n            $!mem-pointer  = 0;\n            @!memory       = ()\n        }\n\n        sub nexti () { @!inst-pointer Z+= @!direction }\n\n        sub pad ( *@lines ) {\n            my $max = max @lines».chars;\n            my @pad = @lines.map: $max - *.chars;\n            map -> $i { flat @lines[$i].comb, ' ' xx @pad[$i] }, ^@lines;\n        }\n    }\n}\n\n# TESTING\nmy $hw = q:to/END/;\n    /++++!/===========?\\>++.>+.+++++++..+++\\\n    \\+++\\ | /+>+++++++>/ /++++++++++<<.++>./\n    $+++/ | \\+++++++++>\\ \\+++++.>.+++.-----\\\n          \\==-<<<<+>+++/ /=.>.+>.--------.-/\n    END\n\nmy $snusp = SNUSP.new;\n$snusp.run($hw)\n\n```\n\nOutput:\n\n```\nHello World!\n```"}]}
{"messages": [{"role": "user", "content": "Some integers (greater than 1), have the property that the digital sum of that integer raised to some integer power greater than 1, is equal to the original integer.\n\nE.G.\n\n:   |  |  |\n    | --- | --- |\n    | **92 == 81** | **8 + 1 == 9** |\n\nSome integers have this property using more than one exponent.\n\n:   |  |  |\n    | --- | --- |\n    | **183 == 5832** | **5 + 8 + 3 + 2 == 18** |\n    | **186 == 34012224** | **3 + 4 + 0 + 1 + 2 + 2 + 2 + 4 == 18** |\n    | **187 == 612220032** | **6 + 1 + 2 + 2 + 2 + 0 + 0 + 3 + 2 == 18** |\n\n*Note: **every** integer has an exponential digital sum equal to the original integer when using an exponent of 1. And, 0 and 1 raised to any power will have a digital sum of 0 and 1 respectively.*\n\nTask\n\n* Find and show the first twenty integers (with their exponents), that satisfy this condition.\n* Find and show at least the first ten integers with their exponents, that satisfy this condition in three or more ways."}, {"role": "assistant", "content": "Implement a lazy generator. Made some assumptions about search limits. May be poor assumptions, but haven't been able to find any counterexamples. (Edit: and some were bad.)\n\n```\nmy @expsum = lazy (2..*).hyper.map( -> $Int {\n    my atomicint $miss = 0;\n    (2..$Int).map( -> $exp {\n        if (my $sum = ($Int ** $exp).comb.sum) > $Int { last if ++⚛$miss > 20 }\n        $sum == $Int ?? \"$Int^$exp\" !! Empty;\n    }) || Empty;\n});\n\nsay \"First twenty-five integers that are equal to the digital sum of that integer raised to some power:\";\nput .join(', ') for @expsum[^25];\nsay \"\\nFirst thirty that satisfy that condition in three or more ways:\";\nput .join(', ') for @expsum.grep({.elems≥3})[^30];\n\n```\n\nOutput:\n\n```\nFirst twenty-five integers that are equal to the digital sum of that integer raised to some power:\n7^4\n8^3\n9^2\n17^3\n18^3, 18^6, 18^7\n20^13\n22^4\n25^4\n26^3\n27^3, 27^7\n28^4, 28^5\n31^7\n34^7\n35^5\n36^4, 36^5\n40^13\n43^7\n45^6\n46^5, 46^8\n53^7\n54^6, 54^8, 54^9\n58^7\n63^8\n64^6\n68^7\n\nFirst thirty that satisfy that condition in three or more ways:\n18^3, 18^6, 18^7\n54^6, 54^8, 54^9\n90^19, 90^20, 90^21, 90^22, 90^28\n107^11, 107^13, 107^15\n181^16, 181^18, 181^19, 181^20\n360^45, 360^46, 360^49, 360^51\n370^48, 370^54, 370^57, 370^59\n388^32, 388^35, 388^36\n523^39, 523^42, 523^44, 523^45\n603^44, 603^47, 603^54\n667^48, 667^54, 667^58\n793^57, 793^60, 793^64\n1062^72, 1062^77, 1062^81\n1134^78, 1134^80, 1134^82, 1134^86\n1359^92, 1359^98, 1359^102\n1827^121, 1827^126, 1827^131\n1828^123, 1828^127, 1828^132\n2116^140, 2116^143, 2116^147\n2330^213, 2330^215, 2330^229\n2430^217, 2430^222, 2430^223, 2430^229, 2430^230\n2557^161, 2557^166, 2557^174\n2610^228, 2610^244, 2610^246\n2656^170, 2656^172, 2656^176\n2700^406, 2700^414, 2700^420, 2700^427\n2871^177, 2871^189, 2871^190\n2934^191, 2934^193, 2934^195\n3077^187, 3077^193, 3077^199\n3222^189, 3222^202, 3222^210\n3231^203, 3231^207, 3231^209\n3448^215, 3448^221, 3448^227\n```"}]}
{"messages": [{"role": "user", "content": "Most programming languages have a built-in implementation of exponentiation.\n\nTask\n\nRe-implement integer exponentiation for both   intint   and   floatint   as both a procedure,   and an operator (if your language supports operator definition).\n\nIf the language supports operator (or procedure) overloading, then an overloaded form should be provided for both   intint   and   floatint   variants.\n\nRelated tasks\n\n* Exponentiation order\n* arbitrary-precision integers (included)\n* Exponentiation with infix operators in (or operating on) the base"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2023.09\n\n```\nproto pow (Real, Int --> Real) {*}\nmulti pow (0,     0)         { fail '0**0 is undefined' }\nmulti pow ($base, UInt $exp) { [*] $base xx $exp }\nmulti pow ($base, $exp)  { 1 / samewith $base, -$exp }\n\nmulti infix:<**> (Real $a, Int $b) { pow $a, $b }\n\n# Testing\n\nsay pow .75, -5;\nsay .75 ** -5;\n\n```"}]}
{"messages": [{"role": "user", "content": "This task will demonstrate the order of exponentiation   (**xy**)    when there are multiple exponents.\n\n(Many programming languages,   especially those with extended─precision integer arithmetic,   usually support one of  `**`, `^`, `↑`  or some such for exponentiation.)\n\nTask requirements\n\nShow the result of a language's evaluation of multiple exponentiation (either as an integer or floating point).\n\nIf your language's exponentiation operator is not one of the usual ones, please comment on how to recognize it.\n\nUsing whatever operator or syntax your language supports (if any), show the results in three lines (with identification):\n\n:   :   :   :   * 5\\*\\*3\\*\\*2\n                * (5\\*\\*3)\\*\\*2\n                * 5\\*\\*(3\\*\\*2)\n\nIf there are other methods (or formats) of multiple exponentiations, show them as well.\n\nSee also\n\n* MathWorld entry:   exponentiation\n\nRelated tasks\n\n* exponentiation operator\n* arbitrary-precision integers (included)\n* Exponentiation with infix operators in (or operating on) the base"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.08\n\nNote that the reduction forms automatically go right-to-left because the base operator is right-associative. Most other operators are left-associative and would automatically reduce left-to-right instead.\n\n```\nuse MONKEY-SEE-NO-EVAL;\nsub demo($x) { say \"  $x\\t───► \", EVAL $x }\n\ndemo '5**3**2';      # show ** is right associative\ndemo '(5**3)**2';\ndemo '5**(3**2)';\n\ndemo '[**] 5,3,2';   # reduction form, show only final result\ndemo '[\\**] 5,3,2';  # triangle reduction, show growing results\n\n# Unicode postfix exponents are supported as well:\n\ndemo '(5³)²';\ndemo '5³²';\n\n```\n\nOutput:\n\n```\n  5**3**2\t───► 1953125\n  (5**3)**2\t───► 15625\n  5**(3**2)\t───► 1953125\n  [**] 5,3,2\t───► 1953125\n  [\\**] 5,3,2\t───► 2 9 1953125\n  (5³)²\t───► 15625\n  5³²\t───► 23283064365386962890625\n\n```\n\nThe Unicode exponent form without parentheses ends up raising to the 32nd power. Nor are you even allowed to parenthesize it the other way: 5(³²) would be a syntax error. Despite all that, for programs that do a lot of squaring or cubing, the postfix forms can enhance both readability and concision."}]}
{"messages": [{"role": "user", "content": "(Many programming languages,   especially those with extended─precision integer arithmetic,   usually\nsupport one of  `**`, `^`, `↑`  or some such for exponentiation.)\n\nSome languages treat/honor infix operators when performing exponentiation   (raising\nnumbers to some power by the language's exponentiation operator,   if the computer\nprogramming language has one).\n\nOther programming languages may make use of the   **POW**   or some other BIF\n  (**B**uilt─**I**n **F**function),   or some other library service.\n\nIf your language's exponentiation operator is not one of the usual ones, please comment on how to recognize it.\n\nThis task will deal with the case where there is some form of an   *infix operator*   operating\nin   (or operating on)   the base.\n\nExample\n\nA negative five raised to the 3rd power could be specified as:\n\n```\n   -5  ** 3          or as\n  -(5) ** 3          or as\n  (-5) ** 3          or as something else\n\n```\n\n(Not all computer programming languages have an exponential operator and/or support these syntax expression(s).\n\nTask\n:   * compute and display exponentiation with a possible infix operator, whether specified and/or implied/inferred.\n    * Raise the following numbers   (integer or real):\n\n    :   :   * -5     and\n            * +5\n\n    * to the following powers:\n\n    :   :   * 2nd     and\n            * 3rd\n\n    * using the following expressions   (if applicable in your language):\n\n    :   :   * -x\\*\\*p\n            * -(x)\\*\\*p\n            * (-x)\\*\\*p\n            * -(x\\*\\*p)\n\n    * Show here (on this page) the four (or more) types of symbolic expressions for each number and power.\n\nTry to present the results in the same format/manner as the other programming entries to make any differences apparent.\n\nThe variables may be of any type(s) that is/are applicable in your language.\n\nRelated tasks\n\n* Exponentiation order\n* Exponentiation operator\n* Arbitrary-precision integers (included)\n* Parsing/RPN to infix conversion\n* Operator precedence\n\nReferences\n\n* Wikipedia: Order of operations in Programming languages"}, {"role": "assistant", "content": "In Raku by default, infix exponentiation binds tighter than unary negation. It is trivial however to define your own infix operators with whatever precedence level meets the needs of your program.\n\nA slight departure from the task specs. Use `1 + {expression}` rather than just `{expression}` to better demonstrate the relative precedence levels. Where `{expression}` is one of:\n\n* `-x{exponential operator}p`\n* `-(x){exponential operator}p`\n* `((-x){exponential operator}p)`\n* `-(x{exponential operator}p)`\n\nAlso add a different grouping: `(1 + -x){exponential operator}p`\n\n```\nsub infix:<↑> is looser(&prefix:<->) { $^a ** $^b }\nsub infix:<∧> is looser(&infix:<->)  { $^a ** $^b }\n\nfor\n   ('Default precedence: infix exponentiation is tighter (higher) precedence than unary negation.',\n     '1 + -$x**$p',   {1 + -$^a**$^b},   '1 + (-$x)**$p', {1 + (-$^a)**$^b},  '1 + (-($x)**$p)', {1 + (-($^a)**$^b)},\n     '(1 + -$x)**$p', {(1 + -$^a)**$^b}, '1 + -($x**$p)', {1 + -($^a**$^b)}),\n\n   (\"\\nEasily modified: custom loose infix exponentiation is looser (lower) precedence than unary negation.\",\n     '1 + -$x↑$p ',   {1 + -$^a↑$^b},    '1 + (-$x)↑$p ', {1 + (-$^a)↑$^b},   '1 + (-($x)↑$p) ', {1 + (-($^a)↑$^b)},\n     '(1 + -$x)↑$p ', {(1 + -$^a)↑$^b},  '1 + -($x↑$p) ', {1 + -($^a↑$^b)}),\n\n   (\"\\nEven more so: custom looser infix exponentiation is looser (lower) precedence than infix subtraction.\",\n     '1 + -$x∧$p ',   {1 + -$^a∧$^b},    '1 + (-$x)∧$p ', {1 + (-$^a)∧$^b},   '1 + (-($x)∧$p) ', {1 + (-($^a)∧$^b)},\n     '(1 + -$x)∧$p ', {(1 + -$^a)∧$^b},  '1 + -($x∧$p) ', {1 + -($^a∧$^b)})\n-> $case {\n    my ($title, @operations) = $case<>;\n    say $title;\n    for -5, 5 X 2, 3 -> ($x, $p) {\n        printf \"x = %2d  p = %d\", $x, $p;\n        for @operations -> $label, &code { print \" │ $label = \" ~ $x.&code($p).fmt('%4d') }\n        say ''\n    }\n}\n\n```\n\nOutput:\n\n```\nDefault precedence: infix exponentiation is tighter (higher) precedence than unary negation.\nx = -5  p = 2 │ 1 + -$x**$p =  -24 │ 1 + (-$x)**$p =   26 │ 1 + (-($x)**$p) =  -24 │ (1 + -$x)**$p =   36 │ 1 + -($x**$p) =  -24\nx = -5  p = 3 │ 1 + -$x**$p =  126 │ 1 + (-$x)**$p =  126 │ 1 + (-($x)**$p) =  126 │ (1 + -$x)**$p =  216 │ 1 + -($x**$p) =  126\nx =  5  p = 2 │ 1 + -$x**$p =  -24 │ 1 + (-$x)**$p =   26 │ 1 + (-($x)**$p) =  -24 │ (1 + -$x)**$p =   16 │ 1 + -($x**$p) =  -24\nx =  5  p = 3 │ 1 + -$x**$p = -124 │ 1 + (-$x)**$p = -124 │ 1 + (-($x)**$p) = -124 │ (1 + -$x)**$p =  -64 │ 1 + -($x**$p) = -124\n\nEasily modified: custom loose infix exponentiation is looser (lower) precedence than unary negation.\nx = -5  p = 2 │ 1 + -$x↑$p  =   26 │ 1 + (-$x)↑$p  =   26 │ 1 + (-($x)↑$p)  =   26 │ (1 + -$x)↑$p  =   36 │ 1 + -($x↑$p)  =  -24\nx = -5  p = 3 │ 1 + -$x↑$p  =  126 │ 1 + (-$x)↑$p  =  126 │ 1 + (-($x)↑$p)  =  126 │ (1 + -$x)↑$p  =  216 │ 1 + -($x↑$p)  =  126\nx =  5  p = 2 │ 1 + -$x↑$p  =   26 │ 1 + (-$x)↑$p  =   26 │ 1 + (-($x)↑$p)  =   26 │ (1 + -$x)↑$p  =   16 │ 1 + -($x↑$p)  =  -24\nx =  5  p = 3 │ 1 + -$x↑$p  = -124 │ 1 + (-$x)↑$p  = -124 │ 1 + (-($x)↑$p)  = -124 │ (1 + -$x)↑$p  =  -64 │ 1 + -($x↑$p)  = -124\n\nEven more so: custom looser infix exponentiation is looser (lower) precedence than infix subtraction.\nx = -5  p = 2 │ 1 + -$x∧$p  =   36 │ 1 + (-$x)∧$p  =   36 │ 1 + (-($x)∧$p)  =   26 │ (1 + -$x)∧$p  =   36 │ 1 + -($x∧$p)  =  -24\nx = -5  p = 3 │ 1 + -$x∧$p  =  216 │ 1 + (-$x)∧$p  =  216 │ 1 + (-($x)∧$p)  =  126 │ (1 + -$x)∧$p  =  216 │ 1 + -($x∧$p)  =  126\nx =  5  p = 2 │ 1 + -$x∧$p  =   16 │ 1 + (-$x)∧$p  =   16 │ 1 + (-($x)∧$p)  =   26 │ (1 + -$x)∧$p  =   16 │ 1 + -($x∧$p)  =  -24\nx =  5  p = 3 │ 1 + -$x∧$p  =  -64 │ 1 + (-$x)∧$p  =  -64 │ 1 + (-($x)∧$p)  = -124 │ (1 + -$x)∧$p  =  -64 │ 1 + -($x∧$p)  = -124\n```"}]}
{"messages": [{"role": "user", "content": "Some programming languages allow you to extend the language. While this can be done to a certain degree in most languages (e.g. by using macros), other languages go much further. Most notably in the Forth and Lisp families, programming per se is done by extending the language without any formal distinction between built-in and user-defined elements.\n\nIf your language supports it, show how to introduce a new flow control mechanism. A practical and useful example is a four-way branch:\n\nOccasionally, code must be written that depends on *two* conditions, resulting in up to four branches (depending on whether both, only the first, only the second, or none of the conditions are \"true\"). In a C-like language this could look like the following:\n\n```\n  if (condition1isTrue) {\n     if (condition2isTrue)\n        bothConditionsAreTrue();\n     else\n        firstConditionIsTrue();\n  }\n  else if (condition2isTrue)\n     secondConditionIsTrue();\n  else\n     noConditionIsTrue();\n\n```\n\nBesides being rather cluttered, the statement(s) for 'condition2isTrue' must be written down twice. If 'condition2isTrue' were a lengthy and involved expression, it would be quite unreadable, and the code generated by the compiler might be unnecessarily large.\n\nThis can be improved by introducing a new keyword **if2**. It is similar to **if**, but takes two conditional statements instead of one, and up to three 'else' statements. One proposal (in pseudo-C syntax) might be:\n\n```\n  if2 (condition1isTrue) (condition2isTrue)\n     bothConditionsAreTrue();\n  else1\n     firstConditionIsTrue();\n  else2\n     secondConditionIsTrue();\n  else\n     noConditionIsTrue();\n\n```\n\nPick the syntax which suits your language. The keywords 'else1' and 'else2' are just examples. The new conditional expression should look, nest and behave analogously to the language's built-in 'if' statement."}, {"role": "assistant", "content": "(formerly Perl 6)\nWriting the conditional blocks is no problem, since there's no distinction between built-in closures and user-defined. The if2 is currently just a function call, which requires a comma after the second condition; eventually we will be able to drop that in user-defined code, but none of our implementations can define parse actions in the statement\\_control category quite yet. (That syntax is special insofar as it's the only place Raku allows two terms in a row.) So currently it requires the comma until the implementations catch up with the spec on that subject.\n\nThis solution is hygienic in both lexical and dynamic variables; the only caveat is that the user's program must avoid the dynamic variable being used by the implementation of conditional, $\\*IF2. This does not seem like a great hardship. (The conditionals will also nest correctly since that's how dynamic variables behave.)\n\n```\nmy &if2  = -> \\a, \\b, &x { my @*IF2 = ?a,?b; x }\n\nmy &if-both    = -> &x { x if @*IF2 eq (True,True)  }\nmy &if-first   = -> &x { x if @*IF2 eq (True,False) }\nmy &if-second  = -> &x { x if @*IF2 eq (False,True) }\nmy &if-neither = -> &x { x if @*IF2 eq (False,False)}\n\nsub test ($a,$b) {\n    $_ = \"G\";          # Demo correct scoping of topic.\n    my $got = \"o\";     # Demo correct scoping of lexicals.\n    my $*got = \"t\";    # Demo correct scoping of dynamics.\n\n    if2 $a, $b, {\n        if-both { say \"$_$got$*got both\" }\n        if-first { say \"$_$got$*got first\" }\n        if-second { say \"$_$got$*got second\" }\n        if-neither { say \"$_$got$*got neither\" }\n    }\n}\n\nsay test |$_ for 1,0 X 1,0;\n\n```\n\nOutput:\n\n```\nGot both\nGot first\nGot second\nGot neither\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a generator of prime numbers, in order, that will automatically adjust to accommodate the generation of any reasonably high prime.\n\nThe routine should demonstrably rely on either:\n\n1. Being based on an open-ended counter set to count without upper limit other than system or programming language limits. In this case, explain where this counter is in the code.\n2. Being based on a limit that is extended automatically. In this case, choose a small limit that ensures the limit will be passed when generating some of the values to be asked for below.\n3. If other methods of creating an extensible prime generator are used, the algorithm's means of extensibility/lack of limits should be stated.\n\nThe routine should be used to:\n\n* Show the first twenty primes.\n* Show the primes between 100 and 150.\n* Show the *number* of primes between 7,700 and 8,000.\n* Show the 10,000th prime.\n\nShow output on this page.\n\n**Note:** You may reference code already on this site if it is written to be imported/included, then only the code necessary for import and the performance of this task need be shown. (It is also important to leave a forward link on the referenced tasks entry so that later editors know that the code is used for multiple tasks).\n\n**Note 2:** If a languages in-built prime generator is extensible or is guaranteed to generate primes up to a system limit, (231 or memory overflow for example), then this may be used as long as an explanation of the limits of the prime generator is also given. (Which may include a link to/excerpt from, language documentation).\n\n**Note 3:**The task is written so it may be useful in solving the task   Emirp primes   as well as others (depending on its efficiency).\n\nReference\n\n* Prime Numbers. Website with large count of primes."}, {"role": "assistant", "content": "(formerly Perl 6)\nBuild a lazy infinite list of primes using the Raku builtin is-prime method. ( A lazy list will not bother to calculate the values until they are actually used. ) That is the first line. If you choose to calculate the entire list, it is fairly certain that you will run out of process / system memory before you finish... (patience too probably) but there aren't really any other constraints. The is-prime builtin uses a Miller-Rabin primality test with 100 iterations, so while it is not 100% absolutely guaranteed that every number it flags as prime actually is, the chances that it is wrong are about 4-100. Much less than the chance that a cosmic ray will cause an error in your computers CPU. Everything after the first line is just display code for the various task requirements.\n\n```\nmy @primes = lazy gather for 1 .. * { .take if .is-prime }\n\nsay \"The first twenty primes:\\n   \", \"[{@primes[^20].fmt(\"%d\", ', ')}]\";\nsay \"The primes between 100 and 150:\\n   \", \"[{@primes.&between(100, 150).fmt(\"%d\", ', ')}]\";\nsay \"The number of primes between 7,700 and 8,000:\\n   \", +@primes.&between(7700, 8000);\nsay \"The 10,000th prime:\\n   \", @primes[9999];\n\nsub between (@p, $l, $u) {\n    gather for @p { .take if $l < $_ < $u; last if $_ >= $u }\n}\n\n```\n\nOutput:\n\n```\nThe first twenty primes:\n   [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]\nThe primes between 100 and 150:\n   [101, 103, 107, 109, 113, 127, 131, 137, 139, 149]\nThe number of primes between 7,700 and 8,000:\n   30\nThe 10,000th prime:\n   104729\n```"}]}
{"messages": [{"role": "user", "content": "Sort a huge file too large to fit into memory.\n\nThe algorithm consists in reading a large file to be sorted in chunks of data small enough to fit in main memory, sort each of the chunks, write them out to a temporary file, and finally combined the smaller subfiles into a single larger file.\n\nFor more info see: https://en.wikipedia.org/wiki/External\\_sorting\n\nThe sorting algorithm can be any popular sort, like quicksort.\n\nFor simplicity one can assume that the file consists of fixed length integers and that the sort function is less-than (<)."}, {"role": "assistant", "content": "(formerly Perl 6)\nBorrowing from Stream\\_Merge here. Temporary files are automatically deleted when program is done, so no explicit clean-up required.\n\n```\nuse File::Temp;\n\nsub merge_streams ( @streams ) {\n    my @s = @streams.map({ hash( STREAM => $_, HEAD => .get ) }).grep({ .<HEAD>.defined });\n\n    return gather while @s {\n        my $h = @s.min: +*.<HEAD>;\n        take $h<HEAD>;\n        $h<HEAD> := $h<STREAM>.get\n            orelse @s .= grep( { $_ !=== $h } );\n    }\n}\n\nsub store (@values) {\n    my ($filename,$filehandle) = tempfile(:prefix('external-sort.'));\n    $filehandle.say: join \"\\n\", @values.sort: +*;\n    $filename\n}\n\n# we're going to pretend that this is a long stream of input from stdin...\nmy (@chunk,@files);\nfor (<43 2 45 32 15 4 3 -9 45 66 0 42 78 123 -11 76 55 87 -2 64 92 34>) {\n    @chunk.push: $_;\n    @files.push: store(@chunk) and @chunk = () if @chunk.elems == 4; # limit of records per merge file\n}\n@files.push: store(@chunk) if @chunk;\n\nsay join ' ', merge_streams @files».&open;\n\n```\n\nOutput:\n\n```\n-11 -9 -2 0 2 3 4 15 32 34 42 43 45 45 55 64 66 76 78 87 92 123\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\n**n**   is an   *extra prime*   if   **n**   is prime and its decimal digits and sum of digits are also primes.\n\nTask\n\nShow the extra primes under   **10,000**.\n\nReference\n\nOEIS:A062088 - Primes with every digit a prime and the sum of the digits a prime.\n\nRelated tasks\n\n* Numbers with prime digits whose sum is 13\n* Smarandache prime-digital sequence\n* Category:Prime Numbers"}, {"role": "assistant", "content": "For the time being, (Doctor?), I'm going to assume that the task is really \"Sequence of primes with every digit a prime and the sum of the digits a prime\". Outputting my own take on a reasonable display of results, compact and easily doable but exercising it a bit.\n\n```\nmy @ppp = lazy flat 2, 3, 5, 7, 23, grep { .is-prime && .comb.sum.is-prime },\n               flat (2..*).map: { flat ([X~] (2, 3, 5, 7) xx $_) X~ (3, 7) };\n\nput 'Terms < 10,000: '.fmt('%34s'), @ppp[^(@ppp.first: * > 1e4, :k)];\nput '991st through 1000th: '.fmt('%34s'), @ppp[990 .. 999];\nput 'Crossing 10th order of magnitude: ', @ppp[9055..9060];\n\n```\n\nOutput:\n\n```\n                  Terms < 10,000: 2 3 5 7 23 223 227 337 353 373 557 577 733 757 773 2333 2357 2377 2557 2753 2777 3253 3257 3323 3527 3727 5233 5237 5273 5323 5527 7237 7253 7523 7723 7727\n            991st through 1000th: 25337353 25353227 25353373 25353577 25355227 25355333 25355377 25357333 25357357 25357757\nCrossing 10th order of magnitude: 777777227 777777577 777777773 2222222377 2222222573 2222225273\n```"}]}
{"messages": [{"role": "user", "content": "Filename extensions are a rudimentary but commonly used way of identifying files types.\n\nTask\n\nWrite a function or program that\n\n* takes one string argument representing the path/URL to a file\n* returns the filename extension according to the below specification, or an empty string if the filename has no extension.\n\nIf your programming language  (or standard library)  has built-in functionality for extracting a filename extension,\n  \nshow how it would be used and how exactly its behavior differs from this specification.\n\nSpecification\n\nFor the purposes of this task, a filename extension:\n\n* occurs at the very end of the filename\n* consists of a period, followed solely by one or more ASCII letters or digits (A-Z, a-z, 0-9)\n\nTest cases\n\n:   :   :   :   | Input | Output | Comment |\n                | --- | --- | --- |\n                | `http://example.com/download.tar.gz` | `.gz` |  |\n                | `CharacterModel.3DS` | `.3DS` |  |\n                | `.desktop` | `.desktop` |  |\n                | `document` |  | *empty string* |\n                | `document.txt_backup` |  | *empty string, because `_` is not a letter or number* |\n                | `/etc/pam.d/login` |  | *empty string, as the period is in the parent directory name rather than the filename* |\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe built-in `IO::Path` class has an `.extension` method:\n\n```\nsay $path.IO.extension;\n\n```\n\nContrary to this task's specification, it\n\n* doesn't include the dot in the output\n* doesn't restrict the extension to letters and numbers.\n\nHere's a custom implementation which does satisfy the task requirements:\n\n```\nsub extension (Str $path --> Str) {\n    $path.match(/:i ['.' <[a..z0..9]>+]? $ /).Str\n}\n\n# Testing:\n\nprintf \"%-35s %-11s %-12s\\n\", $_, extension($_).perl, $_.IO.extension.perl\nfor <\n    http://example.com/download.tar.gz\n    CharacterModel.3DS\n    .desktop\n    document\n    document.txt_backup\n    /etc/pam.d/login\n>;\n\n```\n\nOutput:\n\n```\nhttp://example.com/download.tar.gz  \".gz\"       \"gz\"        \nCharacterModel.3DS                  \".3DS\"      \"3DS\"       \n.desktop                            \".desktop\"  \"desktop\"   \ndocument                            \"\"          \"\"          \ndocument.txt_backup                 \"\"          \"txt_backup\"\n/etc/pam.d/login                    \"\"          \"\"\n\n```"}]}
{"messages": [{"role": "user", "content": "The IEEE floating point specification defines certain 'extreme' floating point values such as minus zero, -0.0, a value distinct from plus zero; not a number, NaN; and plus and minus infinity.\n\nThe task is to use expressions involving other 'normal' floating point values in your language to calculate these, (and maybe other), extreme floating point values in your language and assign them to variables.\n\nPrint the values of these variables if possible; and show some arithmetic with these values and variables.\n\nIf your language can directly enter these extreme floating point values then show it.\n\nSee also\n\n* What Every Computer Scientist Should Know About Floating-Point Arithmetic\n\nRelated tasks\n\n* Infinity\n* Detect division by zero\n* Literals/Floating point"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\nFloating point limits are to a large extent implementation dependent, but currently both Raku backends (MoarVM, JVM) running on a 64 bit OS have an infinity threshold of just under 1.8e308.\n\n```\nprint qq:to 'END'\npositive infinity: {1.8e308}\nnegative infinity: {-1.8e308}\nnegative zero: {0e0 * -1}\nnot a number: {0 * 1e309}\n+Inf + 2.0 = {Inf + 2}\n+Inf - 10.1 = {Inf - 10.1}\n0 * +Inf = {0 * Inf}\n+Inf + -Inf = {Inf + -Inf}\n+Inf == -Inf = {+Inf == -Inf}\n(-Inf+0i)**.5 = {(-Inf+0i)**.5}\nNaN + 1.0 = {NaN + 1.0}\nNaN + NaN = {NaN + NaN}\nNaN == NaN = {NaN == NaN}\n0.0 == -0.0 = {0e0 == -0e0}\nEND\n\n```\n\n`0e0` is used to have floating point number.\nSimply using `0.0` makes rational number that doesn't recognize `-0`.\n`qq:to` is heredoc syntax, where `qq` means\nthat variables and closures (between braces) are interpolated.\n\nOutput:\n\n```\npositive infinity: Inf\nnegative infinity: -Inf\nnegative zero: -0\nnot a number: NaN\n+Inf + 2.0 = Inf\n+Inf - 10.1 = Inf\n0 * +Inf = NaN\n+Inf + -Inf = NaN\n+Inf == -Inf = False\n(-Inf+0i)**.5 = Inf+Inf\\i\nNaN + 1.0 = NaN\nNaN + NaN = NaN\nNaN == NaN = False\n0.0 == -0.0 = True\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nWrite down the first prime number, add the next prime number and if it is prime, add it to the series and so on. These primes are called **extreme primes**.\n\nTask\n\nFind and display the first **30 extreme primes** on this page.\n\nStretch\n\nFind and display the **1,000th**, **2,000th**, **3,000th**, **4,000th** and **5,000th** extreme primes and for each one show the prime number **p** up to and including which primes need to be summed to obtain it.\n\nRelated (and near duplicate) tasks\n\n* Prime numbers p for which the sum of primes less than or equal to p is prime\n* Summarize primes\n\nReference\n\nOEIS sequence A013918"}, {"role": "assistant", "content": "So we're just gonna keep doing the same task over and over with slightly different names?\n\nPrimes equal to the sum of the first k primes for some k.\n\n```\nuse Lingua::EN::Numbers;\n\nsay $_».&comma».fmt(\"%7s\").batch(10).join: \"\\n\" for\n(([\\+] (^∞).grep: &is-prime).grep: &is-prime)[^30,999,1999,2999,3999,4999];\n\n```\n\nOutput:\n\n```\n      2       5      17      41     197     281   7,699   8,893  22,039  24,133\n 25,237  28,697  32,353  37,561  38,921  43,201  44,683  55,837  61,027  66,463\n 70,241  86,453 102,001 109,147 116,533 119,069 121,631 129,419 132,059 263,171\n1,657,620,079\n9,744,982,591\n24,984,473,177\n49,394,034,691\n82,195,983,953\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "A mesh defining a surface has uniquely numbered vertices, and named,\nsimple-polygonal faces described usually by an ordered list of edge numbers\ngoing around the face,\n\nFor example:\nExternal image of two faces  \nRough textual version without edges:\n\n```\n\n\n      1         \n                        17\n 7   A\n             B\n\n       11                     \n                  23\n\n\n```\n\n* A is the triangle (1, 11, 7), or equally (7, 11, 1), going anti-clockwise, or\n\nany of all the rotations of those ordered vertices.\n\n```\n      1         \n                        \n 7   A\n            \n\n       11\n```\n\n* B is the four-sided face (1, 17, 23, 11), or equally (23, 17, 1, 11) or any\n\nof their rotations.\n\n```\n1         \n                  17\n\n       B\n\n 11                     \n            23\n```\n\nLet's call the above the **perimeter format** as it traces around the perimeter.\n\nA second format\n\nA separate algorithm returns polygonal faces consisting of a face name and an unordered\nset of edge definitions for each face.\n\n* A single edge is described by the vertex numbers at its two ends, always in\n\nascending order.\n\n* All edges for the face are given, but in an undefined order.\n\nFor example face A could be described by the edges (1, 11), (7, 11), and (1, 7)\n(The order of each vertex number in an edge is ascending, but the order in\nwhich the edges are stated is arbitrary).\n\nSimilarly face B could be described by the edges (11, 23), (1, 17), (17, 23),\nand (1, 11) in arbitrary order of the edges.\n\nLet's call this second format the **edge format**.\n\nTask\n\n**1.** Write a routine to check if two perimeter formatted faces have the same perimeter. Use it to check if the following pairs of perimeters are the same:\n\n```\n Q: (8, 1, 3)\n R: (1, 3, 8)\n\n U: (18, 8, 14, 10, 12, 17, 19)\n V: (8, 14, 10, 12, 17, 19, 18)\n\n```\n\n**2.** Write a routine and use it to transform the following faces from edge to perimeter format.\n\n```\n E: {(1, 11), (7, 11), (1, 7)}\n F: {(11, 23), (1, 17), (17, 23), (1, 11)}\n G: {(8, 14), (17, 19), (10, 12), (10, 14), (12, 17), (8, 18), (18, 19)}\n H: {(1, 3), (9, 11), (3, 11), (1, 11)}\n\n```\n\nShow your output here."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\n```\nsub check-equivalence ($a, $b) { so $a.Bag eqv $b.Bag }\n\nsub edge-to-periphery (@a is copy) {\n    return Nil unless @a.List.Bag.values.all == 2;\n    my @b = @a.shift.flat;\n    while @a > 1 {\n        for @a.kv -> $k, $v {\n            if $v[0] == @b.tail {\n                @b.push: $v[1];\n                @a.splice($k,1);\n                last\n            }\n            elsif $v[1] == @b.tail {\n                @b.push: $v[0];\n                @a.splice($k,1);\n                last\n            }\n        }\n    }\n    @b\n}\n\nsay 'Perimeter format equality checks:';\n\nfor (8, 1, 3), (1, 3, 8),\n    (18, 8, 14, 10, 12, 17, 19), (8, 14, 10, 12, 17, 19, 18)\n  -> $a, $b {\n     say \"({$a.join: ', '})  equivalent to  ({$b.join: ', '})? \",\n         check-equivalence($a, $b)\n}\n\nsay \"\\nEdge to perimeter format translations:\";\n\nfor ((1, 11), (7, 11), (1, 7)),\n    ((11, 23), (1, 17), (17, 23), (1, 11)),\n    ((8, 14), (17, 19), (10, 12), (10, 14), (12, 17), (8, 18), (18, 19)),\n    ((1, 3), (9, 11), (3, 11), (1, 11))\n  {\n    .gist.print;\n    say \"  ==>  ({.&edge-to-periphery || 'Invalid edge format'})\";\n}\n\n```\n\nOutput:\n\n```\nPerimeter format equality checks:\n(8, 1, 3)  equivalent to  (1, 3, 8)? True\n(18, 8, 14, 10, 12, 17, 19)  equivalent to  (8, 14, 10, 12, 17, 19, 18)? True\n\nEdge to perimeter format translations:\n((1 11) (7 11) (1 7))  ==>  (1 11 7)\n((11 23) (1 17) (17 23) (1 11))  ==>  (11 23 17 1)\n((8 14) (17 19) (10 12) (10 14) (12 17) (8 18) (18 19))  ==>  (8 14 10 12 17 19 18)\n((1 3) (9 11) (3 11) (1 11))  ==>  (Invalid edge format)\n```"}]}
{"messages": [{"role": "user", "content": "Consider the list of factors (divisors) of an integer, such as 12. The factors of 12 are [1, 2, 3, 4, 6, 12]. Consider all sorted sequences of the factors of n such that each succeeding number in such a sequence is a multiple of its predecessor. So, for 6,\nwe have the factors (divisors) [1, 2, 3, 6]. The 3 unique lists of sequential multiples starting with 1 and ending with 6 that can be derived from these factors are [1, 6], [1, 2, 6], and [1, 3, 6].\n\nAnother way to see these sequences is as an set of all the ordered factorizations of a number taken so that their product is that number (excluding 1 from the sequence). So, for 6, we would have [6], [2, 3], and [3, 2]. In this description of the sequences, we are looking at the numbers needed to multiply by, in order to generate the next element in the sequences previously listed in our first definition of the sequence type, as we described it in the preceding paragraph, above.\n\nFor example, for the factorization of 6, if the first type of sequence is [1, 6], this is generated by [6] since 1 \\* 6 = 6. Similarly, the first type of sequence [1, 2, 6] is generated by the second type of sequence [2, 3] because 1 \\* 2 = 2 and 2 \\* 3 = 6. Similarly, [1, 3, 6] is generated by [3, 2] because 1 \\* 3 = 3 and 3 \\* 2 = 6.\n\nIf we count the number of such sorted sequences of multiples, or ordered factorizations, and using that count find all integers `n` for which the count of such sequences equals `n`, we have re-created the sequence of the \"factor-perfect\" numbers (OEIS 163272).\n\nBy some convention, on its OEIS page, the factor-perfect number sequence starts with 0 rather than 1. As might be expected\nwith a sequence involving factorization and combinations, finding factor-perfect numbers becomes\nmore demanding on CPU time as the numbers become large.\n\nTask\n\n* Show all 48 ordered sequences for each of the two methods for n = 48, which is the first non-trivial factor-perfect number.\n\nAccording to the paper listed below by P. Erdos, the number of these sequences is\n\n:   F\n    (\n    n\n    )\n    =\n\n    ∑\n\n    k\n    F\n    (\n\n\n    n\n\n    a\n\n    k\n    )\n    +\n    1\n    {\\displaystyle F(n)=\\sum \\_{k}F({\\frac {n}{a\\_{k}}})+1}\n\nwhere a is a list of the factors of n, including n, but excluding 1. F(n) is here the same as a function for calculating the number of different factorizations according to the second definition above except that F(1)=0 (where the number of factorizations of 1 must be 1 for it to be included in the sequence of factor-perfect numbers).\n\n* Write a program to calculate and show the first 7 numbers of the factor-perfect numbers.\n\nStretch task\n\n* Calculate and show more of the subsequent numbers in the sequence.\n\nsee also\n\n```\nOEIS A163272 (Numbers k such that k = A074206(k), the number of ordered factorizations of k)\nOEIS A074206 (Kalmár's [Kalmar's] problem: number of ordered factorizations of n.)\nOn the maximal order of numbers in the “factorisatio numerorum” problem (Klazar/Luca)\nOn Some Asymptotic Formulas in The Theory of The \"Factorisatio Numerorum\" (P. Erdos)\n\n```"}, {"role": "assistant", "content": "**Translation of**: Wren\n\n```\n# 20221029 Raku programming solution\n\nsub propdiv (\\x) {\n   my @l = 1 if x > 1;\n   for (2 .. x.sqrt.floor) -> \\d {\n      unless x % d { @l.push: d; my \\y = x div d; @l.push: y if y != d }\n   }\n   @l\n}\n\nsub moreMultiples (@toSeq, @fromSeq) {\n   my @oneMores = gather for @fromSeq -> \\j {\n      take @toSeq.clone.push(j) if j > @toSeq[*-1] and j %% @toSeq[*-1]\n   }\n   return () unless @oneMores.Bool;\n   for 0..^@oneMores {\n      @oneMores.append: moreMultiples @oneMores[$_], @fromSeq\n   }\n   @oneMores\n}\n\nsub erdosFactorCount (\\n) {\n   state %cache;\n   my ($sum,@divs) = 0, |(propdiv n)[1..*];\n   for @divs -> \\d {\n      unless %cache{my \\t = n div d}:exists { %cache{t} = erdosFactorCount(t) }\n      $sum += %cache{t}\n   }\n   ++$sum\n}\n\nmy @listing = moreMultiples [1], propdiv(48);\ngiven @listing { $_.map: *.push: 48; $_.push: [1,48] }\nsay @listing.elems,\" sequences using first definition:\";\nfor @listing.rotor(4) -> \\line { line.map: { printf \"%-20s\", $_ } ; say() }\n\nmy @listing2 = gather for (0..^+@listing) -> \\j {\n   my @seq = |@listing[j];\n   @seq.append: 48 if @seq[*-1] != 48;\n   take (1..^@seq).map: { @seq[$_] div @seq[$_-1] }\n}\nsay \"\\n{@listing2.elems} sequences using second definition:\";\nfor @listing2.rotor(4) -> \\line { line.map: { printf \"%-20s\", $_ } ; say() }\n\nsay \"\\nOEIS A163272:\";\nmy ($n,@fpns) = 4, 0,1;\nwhile (@fpns < 7) { @fpns.push($n) if erdosFactorCount($n) == $n; $n += 4 }\nsay ~@fpns;\n\n```\n\nOutput:\n\n```\n48 sequences using first definition:\n1 2 48              1 24 48             1 3 48              1 16 48             \n1 4 48              1 12 48             1 6 48              1 8 48              \n1 2 24 48           1 2 16 48           1 2 4 48            1 2 12 48           \n1 2 6 48            1 2 8 48            1 2 4 24 48         1 2 4 16 48         \n1 2 4 12 48         1 2 4 8 48          1 2 4 12 24 48      1 2 4 8 24 48       \n1 2 4 8 16 48       1 2 12 24 48        1 2 6 24 48         1 2 6 12 48         \n1 2 6 12 24 48      1 2 8 24 48         1 2 8 16 48         1 3 24 48           \n1 3 12 48           1 3 6 48            1 3 12 24 48        1 3 6 24 48         \n1 3 6 12 48         1 3 6 12 24 48      1 4 24 48           1 4 16 48           \n1 4 12 48           1 4 8 48            1 4 12 24 48        1 4 8 24 48         \n1 4 8 16 48         1 12 24 48          1 6 24 48           1 6 12 48           \n1 6 12 24 48        1 8 24 48           1 8 16 48           1 48                \n\n48 sequences using second definition:\n2 24                24 2                3 16                16 3                \n4 12                12 4                6 8                 8 6                 \n2 12 2              2 8 3               2 2 12              2 6 4               \n2 3 8               2 4 6               2 2 6 2             2 2 4 3             \n2 2 3 4             2 2 2 6             2 2 3 2 2           2 2 2 3 2           \n2 2 2 2 3           2 6 2 2             2 3 4 2             2 3 2 4             \n2 3 2 2 2           2 4 3 2             2 4 2 3             3 8 2               \n3 4 4               3 2 8               3 4 2 2             3 2 4 2             \n3 2 2 4             3 2 2 2 2           4 6 2               4 4 3               \n4 3 4               4 2 6               4 3 2 2             4 2 3 2             \n4 2 2 3             12 2 2              6 4 2               6 2 4               \n6 2 2 2             8 3 2               8 2 3               48                  \n\nOEIS A163272:\n0 1 48 1280 2496 28672 29808\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n:   * The factorial of   **0**   (zero)   is defined as being   1   (unity).\n    * The   **Factorial Function**   of a positive integer,    *n*,    is defined as the product of the sequence:\n\n```\n                 n,   n-1,   n-2,   ...   1 \n\n```\n\nTask\n\nWrite a function to return the factorial of a number.\n\nSolutions can be iterative or recursive.\n\nSupport for trapping negative    *n*    errors is optional.\n\nRelated task\n\n* Primorial numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### via User-defined Postfix Operator\n\n[\\*] is a reduction operator that multiplies all the following values together. Note that we don't need to start at 1, since the degenerate case of [\\*]() correctly returns 1, and multiplying by 1 to start off with is silly in any case.\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub postfix:<!> (Int $n) { [*] 2..$n }\nsay 5!;\n```\n\nOutput:\n\n```\n120\n```\n\n### via Memoized Constant Sequence\n\nThis approach is much more efficient for repeated use, since it automatically caches. [\\\\*] is the so-called triangular version of [\\*]. It returns the intermediate results as a list. Note that Raku allows you to define constants lazily, which is rather helpful when your constant is of infinite size...\n\n**Works with**: Rakudo version 2015.12\n\n```\nconstant fact = 1, |[\\*] 1..*;\nsay fact[5]\n```\n\nOutput:\n\n```\n120\n```"}]}
{"messages": [{"role": "user", "content": "You need a random arrangement of a deck of cards, you are sick of lame ways of doing this. This task is a super-cool way of doing this using factorial base numbers.\nThe first 25 factorial base numbers in increasing order are: 0.0.0, 0.0.1, 0.1.0, 0.1.1, 0.2.0, 0.2.1, 1.0.0, 1.0.1, 1.1.0, 1.1.1,1.2.0, 1.2.1, 2.0.0, 2.0.1, 2.1.0, 2.1.1, 2.2.0, 2.2.1, 3.0.0, 3.0.1, 3.1.0, 3.1.1, 3.2.0, 3.2.1, 1.0.0.0\nObserve that the least significant digit is base 2 the next base 3, in general an n-digit factorial base number has digits n..1 in base n+1..2.\n\nI want to produce a 1 to 1 mapping between these numbers and permutations:-\n\n```\n       0.0.0 -> 0123\n       0.0.1 -> 0132\n       0.1.0 -> 0213\n       0.1.1 -> 0231\n       0.2.0 -> 0312\n       0.2.1 -> 0321\n       1.0.0 -> 1023\n       1.0.1 -> 1032\n       1.1.0 -> 1203\n       1.1.1 -> 1230\n       1.2.0 -> 1302\n       1.2.1 -> 1320\n       2.0.0 -> 2013\n       2.0.1 -> 2031\n       2.1.0 -> 2103\n       2.1.1 -> 2130\n       2.2.0 -> 2301\n       2.2.1 -> 2310\n       3.0.0 -> 3012\n       3.0.1 -> 3021\n       3.1.0 -> 3102\n       3.1.1 -> 3120\n       3.2.0 -> 3201\n       3.2.1 -> 3210\n\n```\n\nThe following psudo-code will do this:\nStarting with m=0 and Ω, an array of elements to be permutated, for each digit g starting with the most significant digit in the factorial base number.\n\nIf g is greater than zero, rotate the elements from m to m+g in Ω (see example)\nIncrement m and repeat the first step using the next most significant digit until the factorial base number is exhausted.\nFor example: using the factorial base number 2.0.1 and Ω = 0 1 2 3 where place 0 in both is the most significant (left-most) digit/element.\n\nStep 1: m=0 g=2; Rotate places 0 through 2. 0 1 2 3 becomes 2 0 1 3\nStep 2: m=1 g=0; No action.\nStep 3: m=2 g=1; Rotate places 2 through 3. 2 0 1 3 becomes 2 0 3 1\n\nLet me work 2.0.1 and 0123\n\n```\n    step 1 n=0 g=2 Ω=2013\n    step 2 n=1 g=0 so no action\n    step 3 n=2 g=1 Ω=2031\n\n```\n\nThe task:\n\n```\n First use your function to recreate the above table.\n Secondly use your function to generate all permutaions of 11 digits, perhaps count them don't display them, compare this method with\n    methods in rc's permutations task.\n Thirdly here following are two ramdom 51 digit factorial base numbers I prepared earlier:\n   39.49.7.47.29.30.2.12.10.3.29.37.33.17.12.31.29.34.17.25.2.4.25.4.1.14.20.6.21.18.1.1.1.4.0.5.15.12.4.3.10.10.9.1.6.5.5.3.0.0.0\n   51.48.16.22.3.0.19.34.29.1.36.30.12.32.12.29.30.26.14.21.8.12.1.3.10.4.7.17.6.21.8.12.15.15.13.15.7.3.12.11.9.5.5.6.6.3.4.0.3.2.1\n   use your function to crate the corresponding permutation of the following shoe of cards:\n      A♠K♠Q♠J♠10♠9♠8♠7♠6♠5♠4♠3♠2♠A♥K♥Q♥J♥10♥9♥8♥7♥6♥5♥4♥3♥2♥A♦K♦Q♦J♦10♦9♦8♦7♦6♦5♦4♦3♦2♦A♣K♣Q♣J♣10♣9♣8♣7♣6♣5♣4♣3♣2♣\n Finally create your own 51 digit factorial base number and produce the corresponding permutation of the above shoe\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.11\n\nUsing my interpretation of the task instructions as shown on the discussion page.\n\n```\nsub postfix:<!> (Int $n) { (flat 1, [\\*] 1..*)[$n] }\n\nmulti base (Int $n is copy, 'F', $length? is copy) {\n    constant @fact = [\\*] 1 .. *;\n    my $i = $length // @fact.first: * > $n, :k;\n    my $f;\n    [ @fact[^$i].reverse.map: { ($n, $f) = $n.polymod($_); $f } ]\n}\n\nsub fpermute (@a is copy, *@f) { (^@f).map: { @a[$_ .. $_ + @f[$_]].=rotate(-1) }; @a }\n\nput \"Part 1: Generate table\";\nput $_.&base('F', 3).join('.') ~ ' -> ' ~ [0,1,2,3].&fpermute($_.&base('F', 3)).join for ^24;\n\nput \"\\nPart 2: Compare 11! to 11! \" ~ '¯\\_(ツ)_/¯';\n# This is kind of a weird request. Since we don't actually need to _generate_\n# the permutations, only _count_ them: compare count of 11! vs count of 11!\nput \"11! === 11! : {11! === 11!}\";\n\nput \"\\nPart 3: Generate the given task shuffles\";\nmy \\Ω = <A♠ K♠ Q♠ J♠ 10♠ 9♠ 8♠ 7♠ 6♠ 5♠ 4♠ 3♠ 2♠ A♥ K♥ Q♥ J♥ 10♥ 9♥ 8♥ 7♥ 6♥ 5♥ 4♥ 3♥ 2♥\n         A♦ K♦ Q♦ J♦ 10♦ 9♦ 8♦ 7♦ 6♦ 5♦ 4♦ 3♦ 2♦ A♣ K♣ Q♣ J♣ 10♣ 9♣ 8♣ 7♣ 6♣ 5♣ 4♣ 3♣ 2♣\n>;\n\nmy @books = <\n    39.49.7.47.29.30.2.12.10.3.29.37.33.17.12.31.29.34.17.25.2.4.25.4.1.14.20.6.21.18.1.1.1.4.0.5.15.12.4.3.10.10.9.1.6.5.5.3.0.0.0\n    51.48.16.22.3.0.19.34.29.1.36.30.12.32.12.29.30.26.14.21.8.12.1.3.10.4.7.17.6.21.8.12.15.15.13.15.7.3.12.11.9.5.5.6.6.3.4.0.3.2.1\n>;\n\nput \"Original deck:\";\nput Ω.join;\n\nput \"\\n$_\\n\" ~ Ω[(^Ω).&fpermute($_.split: '.')].join for @books;\n\nput \"\\nPart 4: Generate a random shuffle\";\nmy @shoe = (+Ω … 2).map: { (^$_).pick };\nput @shoe.join('.');\nput Ω[(^Ω).&fpermute(@shoe)].join;\n\nput \"\\nSeems to me it would be easier to just say: Ω.pick(*).join\";\nput Ω.pick(*).join;\n\n```\n\nOutput:\n\n```\nPart 1: Generate table\n0.0.0 -> 0123\n0.0.1 -> 0132\n0.1.0 -> 0213\n0.1.1 -> 0231\n0.2.0 -> 0312\n0.2.1 -> 0321\n1.0.0 -> 1023\n1.0.1 -> 1032\n1.1.0 -> 1203\n1.1.1 -> 1230\n1.2.0 -> 1302\n1.2.1 -> 1320\n2.0.0 -> 2013\n2.0.1 -> 2031\n2.1.0 -> 2103\n2.1.1 -> 2130\n2.2.0 -> 2301\n2.2.1 -> 2310\n3.0.0 -> 3012\n3.0.1 -> 3021\n3.1.0 -> 3102\n3.1.1 -> 3120\n3.2.0 -> 3201\n3.2.1 -> 3210\n\nPart 2: Compare 11! to 11! ¯\\_(ツ)_/¯\n11! === 11! : True\n\nPart 3: Generate the given task shuffles\nOriginal deck:\nA♠K♠Q♠J♠10♠9♠8♠7♠6♠5♠4♠3♠2♠A♥K♥Q♥J♥10♥9♥8♥7♥6♥5♥4♥3♥2♥A♦K♦Q♦J♦10♦9♦8♦7♦6♦5♦4♦3♦2♦A♣K♣Q♣J♣10♣9♣8♣7♣6♣5♣4♣3♣2♣\n\n39.49.7.47.29.30.2.12.10.3.29.37.33.17.12.31.29.34.17.25.2.4.25.4.1.14.20.6.21.18.1.1.1.4.0.5.15.12.4.3.10.10.9.1.6.5.5.3.0.0.0\nA♣3♣7♠4♣10♦8♦Q♠K♥2♠10♠4♦7♣J♣5♥10♥10♣K♣2♣3♥5♦J♠6♠Q♣5♠K♠A♦3♦Q♥8♣6♦9♠8♠4♠9♥A♠6♥5♣2♦7♥8♥9♣6♣7♦A♥J♦Q♦9♦2♥3♠J♥4♥K♦\n\n51.48.16.22.3.0.19.34.29.1.36.30.12.32.12.29.30.26.14.21.8.12.1.3.10.4.7.17.6.21.8.12.15.15.13.15.7.3.12.11.9.5.5.6.6.3.4.0.3.2.1\n2♣5♣J♥4♥J♠A♠5♥A♣6♦Q♠9♣3♦Q♥J♣10♥K♣10♣5♦7♥10♦3♠8♥10♠7♠6♥5♠K♥4♦A♥4♣2♥9♦Q♣8♣7♦6♣3♥6♠7♣2♦J♦9♥A♦Q♦8♦4♠K♦K♠3♣2♠8♠9♠\n\nPart 4: Generate a random shuffle\n47.9.46.16.28.8.36.27.29.1.9.27.1.16.21.22.28.34.30.8.19.27.18.22.3.25.15.20.12.14.8.9.11.1.4.0.3.5.4.2.2.10.8.1.6.1.2.4.1.2.1\n6♣5♠5♣10♥10♦6♠K♣9♦6♦K♠2♠5♦Q♠5♥Q♦8♦J♣2♣8♣A♥K♦9♣A♦2♦9♠4♣3♥A♣7♥2♥Q♥9♥4♥J♠4♠A♠3♠8♥J♥7♠K♥3♣10♣8♠Q♣6♥7♦7♣J♦3♦4♦10♠\n\nSeems to me it would be easier to just say: Ω.pick(*).join\n5♦3♠8♦10♦2♥7♠7♦Q♦A♠5♣8♣Q♠4♠2♦K♦5♠Q♥7♣10♠2♠K♠J♣9♣3♣4♥3♥4♦3♦Q♣2♣4♣J♦9♠A♣J♠10♣6♣9♦6♠10♥6♥9♥J♥7♥K♥A♦8♠A♥5♥8♥K♣6♦\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nA factorial prime is a prime number that is one less or one more than a factorial.\n\nIn other words a non-negative integer **n** corresponds to a factorial prime if either **n**! - 1 or **n**! + 1 is prime.\n\nExamples\n\n4 corresponds to the factorial prime 4! - 1 = 23.\n\n5 doesn't correspond to a factorial prime because neither 5! - 1 = 119 (7 x 17) nor 5! + 1 = 121 (11 x 11) are prime.\n\nTask\n\nFind and show here the first 10 factorial primes. As well as the prime itself show the factorial number **n** to which it corresponds and whether 1 is to be added or subtracted.\n\nAs 0! (by convention) and 1! are both 1, ignore the former and start counting from 1!.\n\nStretch\n\nIf your language supports arbitrary sized integers, do the same for at least the next 19 factorial primes.\n\nAs it can take a long time to demonstrate that a large number (above say 2^64) is definitely prime, you may instead use a function which shows that a number is probably prime to a reasonable degree of certainty. Most 'big integer' libraries have such a function.\n\nIf a number has more than 40 digits, do not show the full number. Show instead the first 20 and the last 20 digits and how many digits in total the number has.\n\nReference\n\n* OEIS:A088054 - Factorial primes\n\nRelated task\n\n* Sequence of primorial primes"}, {"role": "assistant", "content": "```\nsub postfix:<!> ($n) { constant @F = (1, 1, |[\\*] 2..*); @F[$n] }\nsub abr ($_) { .chars < 41 ?? $_ !! .substr(0,20) ~ '..' ~ .substr(*-20) ~ \" ({.chars} digits)\" }\n\nmy $limit;\n\nfor 1..* {\n    my \\f = .!;\n    ++$limit and printf \"%2d: %3d! - 1 = %s\\n\", $limit, $_, abr f -1 if (f -1).is-prime;\n    ++$limit and printf \"%2d: %3d! + 1 = %s\\n\", $limit, $_, abr f +1 if (f +1).is-prime;\n    exit if $limit >= 30\n}\n\n```\n\nOutput:\n\n```\n 1:   1! + 1 = 2\n 2:   2! + 1 = 3\n 3:   3! - 1 = 5\n 4:   3! + 1 = 7\n 5:   4! - 1 = 23\n 6:   6! - 1 = 719\n 7:   7! - 1 = 5039\n 8:  11! + 1 = 39916801\n 9:  12! - 1 = 479001599\n10:  14! - 1 = 87178291199\n11:  27! + 1 = 10888869450418352160768000001\n12:  30! - 1 = 265252859812191058636308479999999\n13:  32! - 1 = 263130836933693530167218012159999999\n14:  33! - 1 = 8683317618811886495518194401279999999\n15:  37! + 1 = 13763753091226345046..79581580902400000001 (44 digits)\n16:  38! - 1 = 52302261746660111176..24100074291199999999 (45 digits)\n17:  41! + 1 = 33452526613163807108..40751665152000000001 (50 digits)\n18:  73! + 1 = 44701154615126843408..03680000000000000001 (106 digits)\n19:  77! + 1 = 14518309202828586963..48000000000000000001 (114 digits)\n20:  94! - 1 = 10873661566567430802..99999999999999999999 (147 digits)\n21: 116! + 1 = 33931086844518982011..00000000000000000001 (191 digits)\n22: 154! + 1 = 30897696138473508879..00000000000000000001 (272 digits)\n23: 166! - 1 = 90036917057784373664..99999999999999999999 (298 digits)\n24: 320! + 1 = 21161033472192524829..00000000000000000001 (665 digits)\n25: 324! - 1 = 22889974601791023211..99999999999999999999 (675 digits)\n26: 340! + 1 = 51008644721037110809..00000000000000000001 (715 digits)\n27: 379! - 1 = 24840307460964707050..99999999999999999999 (815 digits)\n28: 399! + 1 = 16008630711655973815..00000000000000000001 (867 digits)\n29: 427! + 1 = 29063471769607348411..00000000000000000001 (940 digits)\n30: 469! - 1 = 67718096668149510900..99999999999999999999 (1051 digits)\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nA factorion is a natural number that equals the sum of the factorials of its digits.\n\nExample\n\n**145**   is a factorion in base **10** because:\n\n**```\n          1! + 4! + 5!   =   1 + 24 + 120   =   145 \n\n```**\n\nIt can be shown (see talk page) that no factorion in base **10** can exceed   **1,499,999**.\n\nTask\n\nWrite a program in your language to demonstrate, by calculating and printing out the factorions, that:\n\n:   * There are   **3**   factorions in base   **9**\n    * There are   **4**   factorions in base **10**\n    * There are   **5**   factorions in base **11**\n    * There are   **2**   factorions in base **12**     (up to the same upper bound as for base **10**)\n\nSee also\n:   * **Wikipedia article**\n    * **OEIS:A014080 - Factorions in base 10**\n    * **OEIS:A193163 - Factorions in base n**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\n```\nconstant @factorial = 1, |[\\*] 1..*;\n\nconstant $limit = 1500000;\n\nconstant $bases = 9 .. 12;\n\nmy @result;\n\n$bases.map: -> $base {\n\n    @result[$base] = \"\\nFactorions in base $base:\\n1 2\";\n\n    sink (1 .. $limit div $base).map: -> $i {\n        my $product = $i * $base;\n        my $partial;\n\n        for $i.polymod($base xx *) {\n            $partial += @factorial[$_];\n            last if $partial > $product\n        }\n\n        next if $partial > $product;\n\n        my $sum;\n\n        for ^$base {\n            last if ($sum = $partial + @factorial[$_]) > $product + $_;\n            @result[$base] ~= \" $sum\" and last if $sum == $product + $_\n        }\n    }\n}\n\n.say for @result[$bases];\n\n```\n\nOutput:\n\n```\nFactorions in base 9:\n1 2 41282\n\nFactorions in base 10:\n1 2 145 40585\n\nFactorions in base 11:\n1 2 26 48 40472\n\nFactorions in base 12:\n1 2\n```"}]}
{"messages": [{"role": "user", "content": "Given a finite alphabet, we can lexicographically order all strings in the alphabet. If two strings have different lengths, then pad the shorter string on the right with the smallest letter. For example, we have 01 > 001, but 01 = 010. As we see, this order is a total preorder, but not a total order, since it identifies different strings.\n\nA Lyndon word is a non-empty string that is *strictly* lower in lexicographic order than all its circular rotations. In particular, if a string is equal to a circular rotation, then it is not a Lyndon word. For example, since 0101 = 0101 (rotation by 2), it is not a Lyndon word.\n\nThe first Lyndon words on the binary alphabet {0, 1} are:\n\n:   0, 1, 01, 001, 011, 0001, 0011, 0111, 00001, 00011, 00101, 00111, 01011, 01111, ...\n\nSome basic properties:\n\n* The only Lyndon word that ends with 0 is 0.\n* **Proof.** If s0 is a Lyndon word, and s is not empty, then s0 < 0s. If s contains 1 somewhere, then s0 > 0s. Therefore s has only 0. But then s0 = 0s, contradiction.\n* The lexicographic order *is* a total order on the Lyndon words.\n* **Proof.** For, the only way for two different strings s, s' to have the same lexicographic ordering is for one of them to pad to the other. We can assume that s00...0 = s'. If that is so, then s00...0 is a Lyndon word that ends with 0, so it is just 0, and so s is a Lyndon word that is also empty, contradiction.\n\nThe Chen–Fox–Lyndon theorem states that any string is uniquely factorizable into a sequence of Lyndon words non-decreasing in lexicographic order. Duval's algorithm computes this in O(length of input) time and and O(1) space.[1] See [2] for a description of Duval's algorithm."}, {"role": "assistant", "content": "**Translation of**: Julia\n\n```\n# 20240213 Raku programming solution\n\nsub chenfoxlyndonfactorization(Str $s) {\n   my ($n, $i, @factorization) = $s.chars, 1;\n   while $i <= $n {\n      my ($j, $k) = $i X+ (1, 0);\n      while $j <= $n && substr($s, $k-1, 1) <= substr($s, $j-1, 1) {\n         substr($s, $k-1, 1) < substr($s, $j++ -1, 1) ?? ( $k = $i ) !! $k++;\n      }\n      while $i <= $k {\n         @factorization.push: substr($s, $i-1, $j-$k);\n         $i += $j - $k\n      }\n   }\n   die unless $s eq [~] @factorization;\n   return @factorization\n}\n\nmy $m = \"0\";\nfor ^7 { $m ~= $m.trans('0' => '1', '1' => '0') }\nsay chenfoxlyndonfactorization($m);\n\n```\n\nOutput:\n\nSame as Julia example.\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "A Mersenne number is a number in the form of 2P-1.\n\nIf P is prime, the Mersenne number may be a Mersenne prime\n(if P is not prime, the Mersenne number is also not prime).\n\nIn the search for Mersenne prime numbers it is advantageous to eliminate exponents by finding a small factor before starting a, potentially lengthy, Lucas-Lehmer test.\n\nThere are very efficient algorithms for determining if a number divides 2P-1 (or equivalently, if 2P mod (the number) = 1).\nSome languages already have built-in implementations of this exponent-and-mod operation (called *modPow* or similar).\n\nThe following is how to implement this *modPow* yourself:\n\nFor example, let's compute 223 mod 47.\nConvert the exponent 23 to binary, you get 10111. Starting with square = 1, repeatedly square it.\nRemove the top bit of the exponent, and if it's 1 multiply square by the base of the exponentiation (2), then compute square modulo 47.\nUse the result of the modulo from the last step as the initial value of square in the next step:\n\n```\n                  remove       optional   \n      square      top bit   multiply by 2   mod 47\n   ────────────   ───────   ─────────────   ────── \n   1*1 = 1        1  0111   1*2 = 2            2\n   2*2 = 4        0   111      no              4\n   4*4 = 16       1    11   16*2 = 32         32\n   32*32 = 1024   1     1   1024*2 = 2048     27\n   27*27 = 729    1         729*2 = 1458       1\n\n```\n\nSince 223 mod 47 = 1, 47 is a factor of 2P-1.\n(To see this, subtract 1 from both sides: 223-1 = 0 mod 47.)\nSince we've shown that 47 is a factor, 223-1 is not prime.\nFurther properties of Mersenne numbers allow us to refine the process even more.\nAny factor q of 2P-1 must be of the form 2kP+1, k being a positive integer or zero. Furthermore, q must be 1 or 7 mod 8.\nFinally any potential factor q must be prime.\nAs in other trial division algorithms, the algorithm stops when 2kP+1 > sqrt(N).\n\nThese primality tests only work on Mersenne numbers where P is prime. For example, M4=15 yields no factors using these techniques, but factors into 3 and 5, neither of which fit 2kP+1.\n\nTask\n\nUsing the above method find a factor of 2929-1 (aka M929)\n\nRelated tasks\n\n* count in factors\n* prime decomposition\n* factors of an integer\n* Sieve of Eratosthenes\n* primality by trial division\n* trial factoring of a Mersenne number\n* partition an integer X into N primes\n* sequence of primes by Trial Division\n\nSee also\n\n* Computers in 1948: 2127 - 1   \n         (Note:   This video is no longer available because the YouTube account associated with this video has been terminated.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub mtest($bits, $p) {\n    my @bits = $bits.base(2).comb;\n    loop (my $sq = 1; @bits; $sq %= $p) {\n        $sq ×= $sq;\n        $sq += $sq if 1 == @bits.shift;\n    }\n    $sq == 1;\n}\n\nfor flat 2 .. 60, 929 -> $m {\n    next unless is-prime($m);\n    my $f = 0;\n    my $x = 2**$m - 1;\n    my $q;\n    for 1..* -> $k {\n        $q = 2 × $k × $m + 1;\n        next unless $q % 8 == 1|7 or is-prime($q);\n        last if $q × $q > $x or $f = mtest($m, $q);\n    }\n\n    say $f ?? \"M$m = $x\\n\\t= $q × { $x div $q }\"\n           !! \"M$m = $x is prime\";\n}\n\n```\n\nOutput:\n\n```\nM2 = 3 is prime\nM3 = 7 is prime\nM5 = 31 is prime\nM7 = 127 is prime\nM11 = 2047\n\t= 23 × 89\nM13 = 8191 is prime\nM17 = 131071 is prime\nM19 = 524287 is prime\nM23 = 8388607\n\t= 47 × 178481\nM29 = 536870911\n\t= 233 × 2304167\nM31 = 2147483647 is prime\nM37 = 137438953471\n\t= 223 × 616318177\nM41 = 2199023255551\n\t= 13367 × 164511353\nM43 = 8796093022207\n\t= 431 × 20408568497\nM47 = 140737488355327\n\t= 2351 × 59862819377\nM53 = 9007199254740991\n\t= 6361 × 1416003655831\nM59 = 576460752303423487\n\t= 179951 × 3203431780337\nM929 = 4538015467766671944574165338592225830478699345884382504442663144885072806275648112625635725391102144133907238129251016389326737199538896813326509341743147661691195191795226666084858428449394948944821764472508048114220424520501343042471615418544488778723282182172070046459244838911\n\t= 13007 × 348890248924938259750454781163390930305120269538278042934009621348894657205785201247454118966026150852149399410259938217062100192168747352450719561908445272675574320888385228421992652298715687625495638077382028762529439880103124705348782610789919949159935587158612289264184273\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCompute the   factors   of a positive integer.\n\nThese factors are the positive integers by which the number being factored can be divided to yield a positive integer result.\n\n(Though the concepts function correctly for zero and negative integers, the set of factors of zero has countably infinite members, and the factors of negative integers can be obtained from the factors of related positive numbers without difficulty;   this task does not require handling of either of these cases).\n\nNote that every prime number has two factors:   **1**   and itself.\n\nRelated tasks\n\n* count in factors\n* prime decomposition\n* Sieve of Eratosthenes\n* primality by trial division\n* factors of a Mersenne number\n* trial factoring of a Mersenne number\n* partition an integer X into N primes\n* sequence of primes by Trial Division\n* sequence: smallest number greater than previous term with exactly n divisors"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n### Brute-force\n\nNaive, brute-force, and slow, but ok for small numbers.\n\n```\nsub factors (Int $n) { (1..$n).grep($n %% *) }\n```\n\n### Optimized\n\nIf you don't want to roll your own.\n\n```\nuse Prime::Factor;\n\nput divisors :s, 2⁹⁹ + 1;\n\nsay (now - INIT now).round(.001) ~' seconds';\n```\n\nOutput:\n\n```\n1 3 9 19 27 57 67 171 201 513 603 683 1273 1809 2049 3819 5347 6147 11457 12977 16041 18441 20857 34371 38931 45761 48123 62571 101593 116793 137283 144369 187713 304779 350379 358249 396283 411849 563139 869459 914337 1074747 1188849 1235547 1397419 2608377 2743011 3224241 3566547 3652001 4192257 6806731 7825131 9672723 10699641 10956003 12576771 14245331 20420193 23475393 26550961 32868009 37730313 42735993 61260579 69388019 79652883 98604027 111522379 128207979 183781737 208164057 238958649 244684067 270661289 334567137 384623937 624492171 716875947 734052201 811983867 954437177 1003701411 1873476513 2118925201 2202156603 2435951601 2863311531 3011104233 4648997273 6356775603 6606469809 7307854803 7471999393 8589934593 13946991819 18134306363 19070326809 22415998179 25769803779 41840975457 54402919089 57210980427 67247994537 76169784857 125522926371 141967988467 163208757267 201743983611 228509354571 425903965401 489626271801 685528063713 1277711896203 1447225912283 2056584191139 3833135688609 4341677736849 5103375585419 13025033210547 15310126756257 39075099631641 45930380268771 96964136122961 137791140806313 242099935645987 290892408368883 726299806937961 872677225106649 2178899420813883 2618031675319947 4599898777273753 6536698262441649 13799696331821259 16220695688281129 41399088995463777 48662087064843387 124197266986391331 145986261194530161 165354256046209121 308193218077341451 437958783583590483 496062768138627363 924579654232024353 1294508355899092489 1488188304415882089 2773738962696073059 3141730864877973299 3883525067697277467 4464564913247646267 5049478357768350859 8321216888088219177 9425192594633919897 11078735155096011107 11650575203091832401 15148435073305052577 24595658762082757291 28275577783901759691 33236205465288033321 34951725609275497203 45445305219915157731 73786976286248271873 84826733351705279073 86732059845239196763 95940088797598666321 99708616395864099963 136335915659745473193 210495967946824211033 221360928858744815619 260196179535717590289 287820266392795998963 299125849187592299889 338315049970479507553 631487903840472633099 664082786576234446857 780588538607152770867 863460799178387996889 884149207079080169987 1014945149911438522659 1647909137059544738497 1894463711521417899297 2341765615821458312601 2590382397535163990667 2652447621237240509961 3044835449734315567977 3448793718355783636697 4943727411178634215491 5683391134564253697891 6427985949439110643507 7957342863711721529883 9134506349202946703931 10346381155067350910091 14831182233535902646473 16798834934502523229753 19283957848317331930521 23872028591135164589649 26999560778987372043073 31039143465202052730273 44493546700607707939419 50396504803507569689259 57851873544951995791563 59237996874298371389129 65527080648759889097243 80998682336962116129219 93117430395606158190819 151189514410522709067777 173555620634855987374689 177713990622895114167387 196581241946279667291729 231069179129837503658699 242996047010886348387657 453568543231568127203331 512991654800760068818387 533141971868685342502161 589743725838839001875187 693207537389512510976097 728988141032659045162971 1125521940611669056393451 1538974964402280206455161 1599425915606056027506483 1769231177516517005625561 1808970572192153926885891 2079622612168537532928291 3376565821835007169180353 4390314403466912569515281 4616924893206840619365483 5426911716576461780657673 6238867836505612598784873 10129697465505021507541059 13170943210400737708545843 13850774679620521858096449 16280735149729385341973019 18440700012048375105418859 30389092396515064522623177 34370440871650924610831929 39512829631202213125637529 48842205449188156025919057 55322100036145125316256577 103111322614952773832495787 118538488893606639376912587 165966300108435375948769731 309333967844858321497487361 350373300228919127002958321 497898900325306127846309193 928001903534574964492462083 1051119900686757381008874963 1235526900807241132063063553 3153359702060272143026624889 3706580702421723396189190659 9460079106180816429079874667 11119742107265170188567571977 23475011115337581509198207507 33359226321795510565702715931 70425033346012744527594622521 211275100038038233582783867563 633825300114114700748351602689\n0.046 seconds\n```"}]}
{"messages": [{"role": "user", "content": "The Thue-Morse sequence is a sequence of ones and zeros that if two people\ntake turns in the given order, the first persons turn for every '0' in the\nsequence, the second for every '1'; then this is shown to give a fairer, more\nequitable sharing of resources. (Football penalty shoot-outs for example, might\nnot favour the team that goes first as much if the penalty takers take turns\naccording to the Thue-Morse sequence and took 2^n penalties)\n\nThe Thue-Morse sequence of ones-and-zeroes can be generated by:\n\n:   *\"When counting in binary, the digit sum modulo 2 is the Thue-Morse sequence\"*\n\nSharing fairly between two or more\n\nUse this method:\n\n:   *When counting base **b**, the digit sum modulo **b** is the Thue-Morse sequence of fairer sharing between **b** people.*\n\nTask\n\nCounting from zero;   using a function/method/routine to express an integer count in base **b**,\n  \nsum the digits modulo **b** to produce the next member of the Thue-Morse fairshare series for **b** people.\n\nShow the first 25 terms of the fairshare sequence:\n\n:   * For two people:\n    * For three people\n    * For five people\n    * For eleven people\n\nRelated tasks\n:   * Non-decimal radices/Convert\n    * Thue-Morse\n\nSee also\n:   * A010060, A053838, A053840: The On-Line Encyclopedia of Integer Sequences® (OEIS®)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.01\n\nAdd an extension showing the relative fairness correlation of this selection algorithm. An absolutely fair algorithm would have a correlation of 1 for each person (no person has an advantage or disadvantage due to an algorithmic artefact.) This algorithm is fair, and gets better the more iterations are done.\n\nA lower correlation factor corresponds to an advantage, higher to a disadvantage, the closer to 1 it is, the fairer the algorithm. Absolute best possible advantage correlation is 0. Absolute worst is 2.\n\n```\nsub fairshare (\\b) { ^∞ .hyper.map: { .polymod( b xx * ).sum % b } }\n\n.say for <2 3 5 11>.map: { .fmt('%2d:') ~ .&fairshare[^25]».fmt('%2d').join: ', ' }\n\nsay \"\\nRelative fairness of this method. Scaled fairness correlation. The closer to 1.0 each person\nis, the more fair the selection algorithm is. Gets better with more iterations.\";\n\nfor <2 3 5 11 39> -> $people {\n    print \"\\n$people people: \\n\";\n    for $people * 1, $people * 10, $people * 1000 -> $iterations {\n        my @fairness;\n        fairshare($people)[^$iterations].kv.map: { @fairness[$^v % $people] += $^k }\n        my $scale = @fairness.sum / @fairness;\n        my @range = @fairness.map( { $_ / $scale } );\n        printf \"After round %4d: Best advantage: %-10.8g - Worst disadvantage: %-10.8g - Spread between best and worst: %-10.8g\\n\",\n            $iterations/$people, @range.min, @range.max, @range.max - @range.min;\n    }\n}\n\n```\n\n```\n 2: 0,  1,  1,  0,  1,  0,  0,  1,  1,  0,  0,  1,  0,  1,  1,  0,  1,  0,  0,  1,  0,  1,  1,  0,  0\n 3: 0,  1,  2,  1,  2,  0,  2,  0,  1,  1,  2,  0,  2,  0,  1,  0,  1,  2,  2,  0,  1,  0,  1,  2,  1\n 5: 0,  1,  2,  3,  4,  1,  2,  3,  4,  0,  2,  3,  4,  0,  1,  3,  4,  0,  1,  2,  4,  0,  1,  2,  3\n11: 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10,  0,  2,  3,  4\n\nRelative fairness of this method. Scaled fairness correlation. The closer to 1.0 each person\nis, the more fair the selection algorithm is. Gets better with more iterations.\n\n2 people: \nAfter round    1: Best advantage: 0          - Worst disadvantage: 2          - Spread between best and worst: 2         \nAfter round   10: Best advantage: 1          - Worst disadvantage: 1          - Spread between best and worst: 0         \nAfter round 1000: Best advantage: 1          - Worst disadvantage: 1          - Spread between best and worst: 0         \n\n3 people: \nAfter round    1: Best advantage: 0          - Worst disadvantage: 2          - Spread between best and worst: 2         \nAfter round   10: Best advantage: 0.99310345 - Worst disadvantage: 1.0068966  - Spread between best and worst: 0.013793103\nAfter round 1000: Best advantage: 0.99999933 - Worst disadvantage: 1.0000007  - Spread between best and worst: 1.3337779e-06\n\n5 people: \nAfter round    1: Best advantage: 0          - Worst disadvantage: 2          - Spread between best and worst: 2         \nAfter round   10: Best advantage: 1          - Worst disadvantage: 1          - Spread between best and worst: 0         \nAfter round 1000: Best advantage: 1          - Worst disadvantage: 1          - Spread between best and worst: 0         \n\n11 people: \nAfter round    1: Best advantage: 0          - Worst disadvantage: 2          - Spread between best and worst: 2         \nAfter round   10: Best advantage: 0.99082569 - Worst disadvantage: 1.0091743  - Spread between best and worst: 0.018348624\nAfter round 1000: Best advantage: 0.99999909 - Worst disadvantage: 1.0000009  - Spread between best and worst: 1.8183471e-06\n\n39 people: \nAfter round    1: Best advantage: 0          - Worst disadvantage: 2          - Spread between best and worst: 2         \nAfter round   10: Best advantage: 0.92544987 - Worst disadvantage: 1.0745501  - Spread between best and worst: 0.14910026\nAfter round 1000: Best advantage: 0.99999103 - Worst disadvantage: 1.000009   - Spread between best and worst: 1.7949178e-05\n```"}]}
{"messages": [{"role": "user", "content": "The   Farey sequence    ***F*n**   of order   **n**   is the sequence of completely reduced fractions between   **0**   and   **1**   which, when in lowest terms, have denominators less than or equal to   **n**,   arranged in order of increasing size.\n\nThe   *Farey sequence*   is sometimes incorrectly called a   *Farey series*.\n\nEach Farey sequence:\n\n:   :   :   * starts with the value   **0**   (zero),   denoted by the fraction     \n\n              0\n              1\n              {\\displaystyle {\\displaystyle {\\frac {0}{1}}}}\n            * ends with the value   **1**   (unity),   denoted by the fraction   \n\n              1\n              1\n              {\\displaystyle {\\displaystyle {\\frac {1}{1}}}}\n              .\n\nThe Farey sequences of orders   **1**   to   **5**   are:\n\n:   :   :   :   F\n\n                1\n                =\n\n\n                0\n                1\n                ,\n\n\n                1\n                1\n                {\\displaystyle {\\displaystyle {\\bf {\\it {F}}}\\_{1}={\\frac {0}{1}},{\\frac {1}{1}}}}\n:   :   :   :   F\n\n                2\n                =\n\n\n                0\n                1\n                ,\n\n\n                1\n                2\n                ,\n\n\n                1\n                1\n                {\\displaystyle {\\displaystyle {\\bf {\\it {F}}}\\_{2}={\\frac {0}{1}},{\\frac {1}{2}},{\\frac {1}{1}}}}\n:   :   :   :   F\n\n                3\n                =\n\n\n                0\n                1\n                ,\n\n\n                1\n                3\n                ,\n\n\n                1\n                2\n                ,\n\n\n                2\n                3\n                ,\n\n\n                1\n                1\n                {\\displaystyle {\\displaystyle {\\bf {\\it {F}}}\\_{3}={\\frac {0}{1}},{\\frac {1}{3}},{\\frac {1}{2}},{\\frac {2}{3}},{\\frac {1}{1}}}}\n:   :   :   :   F\n\n                4\n                =\n\n\n                0\n                1\n                ,\n\n\n                1\n                4\n                ,\n\n\n                1\n                3\n                ,\n\n\n                1\n                2\n                ,\n\n\n                2\n                3\n                ,\n\n\n                3\n                4\n                ,\n\n\n                1\n                1\n                {\\displaystyle {\\displaystyle {\\bf {\\it {F}}}\\_{4}={\\frac {0}{1}},{\\frac {1}{4}},{\\frac {1}{3}},{\\frac {1}{2}},{\\frac {2}{3}},{\\frac {3}{4}},{\\frac {1}{1}}}}\n:   :   :   :   F\n\n                5\n                =\n\n\n                0\n                1\n                ,\n\n\n                1\n                5\n                ,\n\n\n                1\n                4\n                ,\n\n\n                1\n                3\n                ,\n\n\n                2\n                5\n                ,\n\n\n                1\n                2\n                ,\n\n\n                3\n                5\n                ,\n\n\n                2\n                3\n                ,\n\n\n                3\n                4\n                ,\n\n\n                4\n                5\n                ,\n\n\n                1\n                1\n                {\\displaystyle {\\displaystyle {\\bf {\\it {F}}}\\_{5}={\\frac {0}{1}},{\\frac {1}{5}},{\\frac {1}{4}},{\\frac {1}{3}},{\\frac {2}{5}},{\\frac {1}{2}},{\\frac {3}{5}},{\\frac {2}{3}},{\\frac {3}{4}},{\\frac {4}{5}},{\\frac {1}{1}}}}\n\nTask\n\n* Compute and show the Farey sequence for orders   **1**   through   **11**   (inclusive).\n* Compute and display the   *number*   of fractions in the Farey sequence for order   **100**   through   **1,000**   (inclusive)   by hundreds.\n* Show the fractions as    **n/d**    (using the solidus [or slash] to separate the numerator from the denominator).\n\nThe length   (the number of fractions)   of a Farey sequence asymptotically approaches:\n\n:   :   :   :   :   :   :   :   :   :   :   3 × n2   ÷   \n\n                                            π\n                                            {\\displaystyle {\\displaystyle \\pi }}\n                                            2\n\nSee also\n\n* OEIS sequence   A006842 numerators of Farey series of order 1, 2, ···\n* OEIS sequence   A006843 denominators of Farey series of order 1, 2, ···\n* OEIS sequence   A005728 number of fractions in Farey series of order n\n* MathWorld entry   Farey sequence\n* Wikipedia   entry   Farey sequence"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.10\n\n```\nsub farey ($order) {\n    my @l = 0/1, 1/1;\n    (2..$order).map: { push @l, |(1..$^d).map: { $_/$d } }\n    unique @l\n}\n\nsay \"Farey sequence order \";\n.say for (1..11).hyper(:1batch).map: { \"$_: \", .&farey.sort.map: *.nude.join('/') };\n.say for (100, 200 ... 1000).race(:1batch).map: { \"Farey sequence order $_ has \" ~ [.&farey].elems ~ ' elements.' }\n\n```\n\nOutput:\n\n```\nFarey sequence order \n1: 0/1 1/1\n2: 0/1 1/2 1/1\n3: 0/1 1/3 1/2 2/3 1/1\n4: 0/1 1/4 1/3 1/2 2/3 3/4 1/1\n5: 0/1 1/5 1/4 1/3 2/5 1/2 3/5 2/3 3/4 4/5 1/1\n6: 0/1 1/6 1/5 1/4 1/3 2/5 1/2 3/5 2/3 3/4 4/5 5/6 1/1\n7: 0/1 1/7 1/6 1/5 1/4 2/7 1/3 2/5 3/7 1/2 4/7 3/5 2/3 5/7 3/4 4/5 5/6 6/7 1/1\n8: 0/1 1/8 1/7 1/6 1/5 1/4 2/7 1/3 3/8 2/5 3/7 1/2 4/7 3/5 5/8 2/3 5/7 3/4 4/5 5/6 6/7 7/8 1/1\n9: 0/1 1/9 1/8 1/7 1/6 1/5 2/9 1/4 2/7 1/3 3/8 2/5 3/7 4/9 1/2 5/9 4/7 3/5 5/8 2/3 5/7 3/4 7/9 4/5 5/6 6/7 7/8 8/9 1/1\n10: 0/1 1/10 1/9 1/8 1/7 1/6 1/5 2/9 1/4 2/7 3/10 1/3 3/8 2/5 3/7 4/9 1/2 5/9 4/7 3/5 5/8 2/3 7/10 5/7 3/4 7/9 4/5 5/6 6/7 7/8 8/9 9/10 1/1\n11: 0/1 1/11 1/10 1/9 1/8 1/7 1/6 2/11 1/5 2/9 1/4 3/11 2/7 3/10 1/3 4/11 3/8 2/5 3/7 4/9 5/11 1/2 6/11 5/9 4/7 3/5 5/8 7/11 2/3 7/10 5/7 8/11 3/4 7/9 4/5 9/11 5/6 6/7 7/8 8/9 9/10 10/11 1/1\nFarey sequence order 100 has 3045 elements.\nFarey sequence order 200 has 12233 elements.\nFarey sequence order 300 has 27399 elements.\nFarey sequence order 400 has 48679 elements.\nFarey sequence order 500 has 76117 elements.\nFarey sequence order 600 has 109501 elements.\nFarey sequence order 700 has 149019 elements.\nFarey sequence order 800 has 194751 elements.\nFarey sequence order 900 has 246327 elements.\nFarey sequence order 1000 has 304193 elements.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCalculate the   FFT   (Fast Fourier Transform)   of an input sequence.\n\nThe most general case allows for complex numbers at the input\nand results in a sequence of equal length, again of complex numbers.\nIf you need to restrict yourself to real numbers, the output should\nbe the magnitude   (i.e.:   sqrt(re2 + im2))   of the complex result.\n\nThe classic version is the recursive Cooley–Tukey FFT. Wikipedia has pseudo-code for that.\nFurther optimizations are possible but not required."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo 2022-07\n\n|  |\n| --- |\n| This example is **in need of improvement:**  Not numerically accurate |\n\n```\nsub fft {\n    return @_ if @_ == 1;\n    my @evn = fft( @_[0, 2 ... *] );\n    my @odd = fft( @_[1, 3 ... *] ) Z*\n    map &cis, (0, -tau / @_ ... *);\n    return flat @evn »+« @odd, @evn »-« @odd;\n}\n\n.say for fft <1 1 1 1 0 0 0 0>;\n\n```\n\nOutput:\n\n```\n4+0i\n1-2.414213562373095i\n0+0i\n1-0.4142135623730949i\n0+0i\n0.9999999999999999+0.4142135623730949i\n0+0i\n0.9999999999999997+2.414213562373095i\n\n```\n\nFor the fun of it, here is a purely functional version:\n\n```\nsub fft {\n    @_ == 1 ?? @_ !!\n    fft(@_[0,2...*]) «+«\n    fft(@_[1,3...*]) «*« map &cis, (0,-τ/@_...^-τ)\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "In bioinformatics, long character strings are often encoded in a format called FASTA.\n\nA FASTA file can contain several strings, each identified by a name marked by a `>` (greater than) character at the beginning of the line.\n\nTask\n\nWrite a program that reads a FASTA file such as:\n\n```\n>Rosetta_Example_1\nTHERECANBENOSPACE\n>Rosetta_Example_2\nTHERECANBESEVERAL\nLINESBUTTHEYALLMUST\nBECONCATENATED\n\n```\n\nOutput:\n\n```\nRosetta_Example_1: THERECANBENOSPACE\nRosetta_Example_2: THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED\n\n```\n\nNote that a high-quality implementation will not hold the entire file in memory at once; real FASTA files can be multiple gigabytes in size."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\ngrammar FASTA {\n\n    rule TOP    { <entry>+ }\n    rule entry  { \\> <title> <sequence> }\n    token title { <.alnum>+ }\n    token sequence { ( <.alnum>+ )+ % \\n { make $0.join } }\n\n}\n\nFASTA.parse: q:to /§/;\n>Rosetta_Example_1\nTHERECANBENOSPACE\n>Rosetta_Example_2\nTHERECANBESEVERAL\nLINESBUTTHEYALLMUST\nBECONCATENATED\n§\n\nfor $/<entry>[] {\n    say ~.<title>, \" : \", .<sequence>.made;\n}\n\n```\n\nOutput:\n\n```\nRosetta_Example_1 : THERECANBENOSPACE\nRosetta_Example_2 : THERECANBESEVERALLINESBUTTHEYALLMUSTBECONCATENATED\n```"}]}
{"messages": [{"role": "user", "content": "In mathematics,   Faulhaber's formula,   named after Johann Faulhaber,   expresses the sum of the *p*-th powers of the first *n* positive integers as a *(p + 1)*th-degree polynomial function of n,   the coefficients involving Bernoulli numbers.\n\nTask\n\nGenerate the first 10 closed-form expressions, starting with *p = 0*.\n\nRelated tasks\n:   * Bernoulli numbers.\n    * evaluate binomial coefficients.\n\nSee also\n:   * The Wikipedia entry:   Faulhaber's formula.\n    * The Wikipedia entry:   Bernoulli numbers.\n    * The Wikipedia entry:   binomial coefficients."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.04.01\n\n```\nsub bernoulli_number($n) {\n\n    return 1/2 if $n == 1;\n    return 0/1 if $n % 2;\n\n    my @A;\n    for 0..$n -> $m {\n        @A[$m] = 1 / ($m + 1);\n        for $m, $m-1 ... 1 -> $j {\n            @A[$j - 1] = $j * (@A[$j - 1] - @A[$j]);\n        }\n    }\n\n    return @A[0];\n}\n\nsub binomial($n, $k) {\n    $k == 0 || $n == $k ?? 1 !! binomial($n-1, $k-1) + binomial($n-1, $k);\n}\n\nsub faulhaber_s_formula($p) {\n\n    my @formula = gather for 0..$p -> $j {\n        take '('\n            ~ join('/', (binomial($p+1, $j) * bernoulli_number($j)).Rat.nude)\n            ~ \")*n^{$p+1 - $j}\";\n    }\n\n    my $formula = join(' + ', @formula.grep({!m{'(0/1)*'}}));\n\n    $formula .= subst(rx{ '(1/1)*' }, '', :g);\n    $formula .= subst(rx{ '^1'» }, '', :g);\n\n    \"1/{$p+1} * ($formula)\";\n}\n\nfor 0..9 -> $p {\n    say \"f($p) = \", faulhaber_s_formula($p);\n}\n\n```\n\nOutput:\n\n```\nf(0) = 1/1 * (n)\nf(1) = 1/2 * (n^2 + n)\nf(2) = 1/3 * (n^3 + (3/2)*n^2 + (1/2)*n)\nf(3) = 1/4 * (n^4 + (2/1)*n^3 + n^2)\nf(4) = 1/5 * (n^5 + (5/2)*n^4 + (5/3)*n^3 + (-1/6)*n)\nf(5) = 1/6 * (n^6 + (3/1)*n^5 + (5/2)*n^4 + (-1/2)*n^2)\nf(6) = 1/7 * (n^7 + (7/2)*n^6 + (7/2)*n^5 + (-7/6)*n^3 + (1/6)*n)\nf(7) = 1/8 * (n^8 + (4/1)*n^7 + (14/3)*n^6 + (-7/3)*n^4 + (2/3)*n^2)\nf(8) = 1/9 * (n^9 + (9/2)*n^8 + (6/1)*n^7 + (-21/5)*n^5 + (2/1)*n^3 + (-3/10)*n)\nf(9) = 1/10 * (n^10 + (5/1)*n^9 + (15/2)*n^8 + (-7/1)*n^6 + (5/1)*n^4 + (-3/2)*n^2)\n\n```"}]}
{"messages": [{"role": "user", "content": "Named after Johann Faulhaber, the rows of Faulhaber's triangle are the coefficients of polynomials that represent sums of integer powers, which are extracted from Faulhaber's formula:\n\n:   ∑\n\n    k\n    =\n    1\n\n    n\n\n    k\n\n    p\n    =\n\n\n    1\n\n    p\n    +\n    1\n\n    ∑\n\n    j\n    =\n    0\n\n    p\n\n    (\n\n\n    p\n    +\n    1\n    j\n\n    )\n\n    B\n\n    j\n\n    n\n\n    p\n    +\n    1\n    −\n    j\n    {\\displaystyle {\\displaystyle \\sum \\_{k=1}^{n}k^{p}={1 \\over p+1}\\sum \\_{j=0}^{p}{p+1 \\choose j}B\\_{j}n^{p+1-j}}}\n\nwhere \n\nB\n\nn\n{\\displaystyle {\\displaystyle B\\_{n}}}\n is the nth-Bernoulli number.\n\nThe first 5 rows of Faulhaber's triangle, are:\n\n```\n    1\n  1/2  1/2\n  1/6  1/2  1/3\n    0  1/4  1/2  1/4\n-1/30    0  1/3  1/2  1/5\n\n```\n\nUsing the third row of the triangle, we have:\n\n∑\n\nk\n=\n1\n\nn\n\nk\n\n2\n=\n\n\n1\n6\nn\n+\n\n\n1\n2\n\nn\n\n2\n+\n\n\n1\n3\n\nn\n\n3\n{\\displaystyle {\\displaystyle \\sum \\_{k=1}^{n}k^{2}={1 \\over 6}n+{1 \\over 2}n^{2}+{1 \\over 3}n^{3}}}\n\nTask\n\n:   * show the first 10 rows of Faulhaber's triangle.\n    * using the 18th row of Faulhaber's triangle, compute the sum: \n\n      ∑\n\n      k\n      =\n      1\n\n      1000\n\n      k\n\n      17\n      {\\displaystyle {\\displaystyle \\sum \\_{k=1}^{1000}k^{17}}}\n       (extra credit).\n\nSee also\n\n* Bernoulli numbers\n* Evaluate binomial coefficients\n* Faulhaber's formula (Wikipedia)\n* Faulhaber's triangle (PDF)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.05\n\n**Translation of**: Sidef\n\n```\n# Helper subs\n\nsub infix:<reduce> (\\prev, \\this) { this.key => this.key * (this.value - prev.value) }\n\nsub next-bernoulli ( (:key($pm), :value(@pa)) ) {\n    $pm + 1 => [ map *.value, [\\reduce] ($pm + 2 ... 1) Z=> 1 / ($pm + 2), |@pa ]\n}\n\nconstant bernoulli = (0 => [1.FatRat], &next-bernoulli ... *).map: { .value[*-1] };\n\nsub binomial (Int $n, Int $p) { combinations($n, $p).elems }\n\nsub asRat (FatRat $r) { $r ?? $r.denominator == 1 ?? $r.numerator !! $r.nude.join('/') !! 0 }\n\n\n# The task\nsub faulhaber_triangle ($p) { map { binomial($p + 1, $_) * bernoulli[$_] / ($p + 1) }, ($p ... 0) }\n\n# First 10 rows of Faulhaber's triangle:\nsay faulhaber_triangle($_)».&asRat.fmt('%5s') for ^10;\nsay '';\n\n# Extra credit:\nmy $p = 17;\nmy $n = 1000;\nsay sum faulhaber_triangle($p).kv.map: { $^value * $n**($^key + 1) }\n\n```\n\nOutput:\n\n```\n    1\n  1/2   1/2\n  1/6   1/2   1/3\n    0   1/4   1/2   1/4\n-1/30     0   1/3   1/2   1/5\n    0 -1/12     0  5/12   1/2   1/6\n 1/42     0  -1/6     0   1/2   1/2   1/7\n    0  1/12     0 -7/24     0  7/12   1/2   1/8\n-1/30     0   2/9     0 -7/15     0   2/3   1/2   1/9\n    0 -3/20     0   1/2     0 -7/10     0   3/4   1/2  1/10\n\n56056972216555580111030077961944183400198333273050000\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCalculate the Feigenbaum constant.\n\nSee\n:   * Details in the Wikipedia article:   Feigenbaum constant."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.04.01\n\n**Translation of**: Ring\n\n```\nmy $a1 = 1;\nmy $a2 = 0;\nmy $d = 3.2;\n\nsay ' i d';\n\nfor 2 .. 13 -> $exp {\n    my $a = $a1 + ($a1 - $a2) / $d;\n    do {\n        my $x = 0;\n        my $y = 0;\n        for ^2 ** $exp {\n            $y = 1 - 2 * $y * $x;\n            $x = $a - $x²;\n        }\n        $a -= $x / $y;\n    } xx 10;\n     $d = ($a1 - $a2) / ($a - $a1);\n     ($a2, $a1) = ($a1, $a);\n     printf \"%2d %.8f\\n\", $exp, $d;\n}\n\n```\n\nOutput:\n\n```\n i d\n 2 3.21851142\n 3 4.38567760\n 4 4.60094928\n 5 4.65513050\n 6 4.66611195\n 7 4.66854858\n 8 4.66906066\n 9 4.66917155\n10 4.66919515\n11 4.66920026\n12 4.66920098\n13 4.66920537\n```"}]}
{"messages": [{"role": "user", "content": "In mathematics, a Fermat number, *named after Pierre de Fermat who first studied them,* is a positive integer of the form **Fn = 2*2**n* + 1** where **n** is a non-negative integer.\n\nDespite the simplicity of generating Fermat numbers, they have some powerful mathematical properties and are extensively used in cryptography & pseudo-random number generation, and are often linked to other number theoric fields.\n\nAs of this writing, (mid 2019), there are only five known prime Fermat numbers, the first five (**F0** through **F4**). Only the first twelve Fermat numbers have been completely factored, though many have been partially factored.\n\nTask\n\n:   * Write a routine (function, procedure, whatever) to generate **Fermat numbers**.\n\n:   * Use the routine to find and display here, on this page, the first **10 Fermat numbers** - **F0** through **F9**.\n\n:   * Find and display here, on this page, the **prime factors** of as many Fermat numbers as you have patience for. (Or as many as can be found in five minutes or less of processing time). *Note: if you make it past **F11**, there may be money, and certainly will be acclaim in it for you.*\n\nSee also\n\n:   * **Wikipedia - Fermat numbers**\n    * **OEIS:A000215 - Fermat numbers**\n    * **OEIS:A019434 - Fermat primes**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nI gave up on factoring F₉ after about 20 minutes.\n\n**Library:** ntheory\n\n```\nuse ntheory:from<Perl5> <factor>;\n\nmy @Fermats = (^Inf).map: 2 ** 2 ** * + 1;\n\nmy $sub = '₀';\nsay \"First 10 Fermat numbers:\";\nprintf \"F%s = %s\\n\", $sub++, $_ for @Fermats[^10];\n\n$sub = '₀';\nsay \"\\nFactors of first few Fermat numbers:\";\nfor @Fermats[^9].map( {\"$_\".&factor} ) -> $f {\n    printf \"Factors of F%s: %s %s\\n\", $sub++, $f.join(' '), $f.elems == 1 ?? '- prime' !! ''\n}\n\n```\n\nOutput:\n\n```\nFirst 10 Fermat numbers:\nF₀ = 3\nF₁ = 5\nF₂ = 17\nF₃ = 257\nF₄ = 65537\nF₅ = 4294967297\nF₆ = 18446744073709551617\nF₇ = 340282366920938463463374607431768211457\nF₈ = 115792089237316195423570985008687907853269984665640564039457584007913129639937\nF₉ = 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084097\n\nFactors of first few Fermat numbers:\nFactors of F₀: 3 - prime\nFactors of F₁: 5 - prime\nFactors of F₂: 17 - prime\nFactors of F₃: 257 - prime\nFactors of F₄: 65537 - prime\nFactors of F₅: 641 6700417 \nFactors of F₆: 274177 67280421310721 \nFactors of F₇: 59649589127497217 5704689200685129054721 \nFactors of F₈: 1238926361552897 93461639715357977769163558199606896584051237541638188580280321\n\n```"}]}
{"messages": [{"role": "user", "content": "A Fermat pseudoprime is a positive composite integer that passes the Fermat primality test.\n\nFermat's little theorem states that if ***p*** is prime and ***a*** is coprime to ***p***, then ***ap−1 − 1*** is divisible by ***p***.\n\nFor an integer ***a*** > 1, if a composite integer ***x*** evenly divides ***ax−1 − 1***, then ***x*** is called a **Fermat pseudoprime** to base ***a***.\n\nFermat pseudoprimes to base **2** are sometimes called **Sarrus numbers** or **Poulet numbers**.\n\nFermat pseudoprimes can be found to any positive integer base. When using a base integer ***a*** = 1, this method returns *all* composite numbers.\n\nTask\n\nFor base integers ***a*** of **1** through **20**:\n\n* Find the **count** of pseudoprimes up to and including **12,000**.\n* Show the first **20** pseudoprimes.\n\nStretch\n\n* Extend the count threshold out to **25,000**, **50,000** or higher.\n\nSee also\n\n* Wikipedia: Fermat pseudoprime * OEIS:A002808 - Composite numbers * OEIS:A001567 - Fermat pseudoprimes to base 2 * OEIS:A005935 - Fermat pseudoprimes to base 3 * OEIS:A020136 - Fermat pseudoprimes to base 4 * OEIS:A005936 - Fermat pseudoprimes to base 5 * OEIS:A005937 - Fermat pseudoprimes to base 6 * OEIS:A005938 - Fermat pseudoprimes to base 7 * OEIS:A020137 - Fermat pseudoprimes to base 8 * OEIS:A020138 - Fermat pseudoprimes to base 9 * OEIS:A005939 - Fermat pseudoprimes to base 10 * OEIS:A020139 - Fermat pseudoprimes to base 11 * OEIS:A020140 - Fermat pseudoprimes to base 12 * OEIS:A020141 - Fermat pseudoprimes to base 13 * OEIS:A020142 - Fermat pseudoprimes to base 14 * OEIS:A020143 - Fermat pseudoprimes to base 15 * OEIS:A020144 - Fermat pseudoprimes to base 16 * OEIS:A020145 - Fermat pseudoprimes to base 17 * OEIS:A020146 - Fermat pseudoprimes to base 18 * OEIS:A020147 - Fermat pseudoprimes to base 19 * OEIS:A020148 - Fermat pseudoprimes to base 20\n\nRelated\n\n* Task: Modular exponentiation * Task: Super-Poulet numbers"}, {"role": "assistant", "content": "```\nuse List::Divvy;\nfor 1..20 -> $base {\n    my @pseudo = lazy (2..*).hyper.grep: { !.is-prime && (1 == expmod $base, $_ - 1, $_) }\n    my $threshold = 100_000;\n    say $base.fmt(\"Base %2d - Up to $threshold: \") ~ (+@pseudo.&upto: $threshold).fmt('%5d')\n        ~ \"  First 20: \" ~ @pseudo[^20].gist\n}\n\n```\n\n```\nBase  1 - Up to 100000: 90407  First 20: (4 6 8 9 10 12 14 15 16 18 20 21 22 24 25 26 27 28 30 32)\nBase  2 - Up to 100000:    78  First 20: (341 561 645 1105 1387 1729 1905 2047 2465 2701 2821 3277 4033 4369 4371 4681 5461 6601 7957 8321)\nBase  3 - Up to 100000:    78  First 20: (91 121 286 671 703 949 1105 1541 1729 1891 2465 2665 2701 2821 3281 3367 3751 4961 5551 6601)\nBase  4 - Up to 100000:   153  First 20: (15 85 91 341 435 451 561 645 703 1105 1247 1271 1387 1581 1695 1729 1891 1905 2047 2071)\nBase  5 - Up to 100000:    73  First 20: (4 124 217 561 781 1541 1729 1891 2821 4123 5461 5611 5662 5731 6601 7449 7813 8029 8911 9881)\nBase  6 - Up to 100000:   104  First 20: (35 185 217 301 481 1105 1111 1261 1333 1729 2465 2701 2821 3421 3565 3589 3913 4123 4495 5713)\nBase  7 - Up to 100000:    73  First 20: (6 25 325 561 703 817 1105 1825 2101 2353 2465 3277 4525 4825 6697 8321 10225 10585 10621 11041)\nBase  8 - Up to 100000:   218  First 20: (9 21 45 63 65 105 117 133 153 231 273 341 481 511 561 585 645 651 861 949)\nBase  9 - Up to 100000:   164  First 20: (4 8 28 52 91 121 205 286 364 511 532 616 671 697 703 946 949 1036 1105 1288)\nBase 10 - Up to 100000:    90  First 20: (9 33 91 99 259 451 481 561 657 703 909 1233 1729 2409 2821 2981 3333 3367 4141 4187)\nBase 11 - Up to 100000:    89  First 20: (10 15 70 133 190 259 305 481 645 703 793 1105 1330 1729 2047 2257 2465 2821 4577 4921)\nBase 12 - Up to 100000:   127  First 20: (65 91 133 143 145 247 377 385 703 1045 1099 1105 1649 1729 1885 1891 2041 2233 2465 2701)\nBase 13 - Up to 100000:    91  First 20: (4 6 12 21 85 105 231 244 276 357 427 561 1099 1785 1891 2465 2806 3605 5028 5149)\nBase 14 - Up to 100000:    96  First 20: (15 39 65 195 481 561 781 793 841 985 1105 1111 1541 1891 2257 2465 2561 2665 2743 3277)\nBase 15 - Up to 100000:    70  First 20: (14 341 742 946 1477 1541 1687 1729 1891 1921 2821 3133 3277 4187 6541 6601 7471 8701 8911 9073)\nBase 16 - Up to 100000:   200  First 20: (15 51 85 91 255 341 435 451 561 595 645 703 1105 1247 1261 1271 1285 1387 1581 1687)\nBase 17 - Up to 100000:    83  First 20: (4 8 9 16 45 91 145 261 781 1111 1228 1305 1729 1885 2149 2821 3991 4005 4033 4187)\nBase 18 - Up to 100000:   134  First 20: (25 49 65 85 133 221 323 325 343 425 451 637 931 1105 1225 1369 1387 1649 1729 1921)\nBase 19 - Up to 100000:   121  First 20: (6 9 15 18 45 49 153 169 343 561 637 889 905 906 1035 1105 1629 1661 1849 1891)\nBase 20 - Up to 100000:   101  First 20: (21 57 133 231 399 561 671 861 889 1281 1653 1729 1891 2059 2413 2501 2761 2821 2947 3059)\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Fibonacci heap. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\n* Implement queue operations for **Fibonacci heaps**. Where H is heap, x node with data value, k integer.\n* Operations:\n  + MakeHeap() - create new empty Fibonacci heap\n  + Insert(H,x) - insert new element x into heap H\n  + Union(H1, H2) - union heap H1 and heap H2\n  + Minimum(H) - return minimum value from heap H\n  + ExtractMin(H) - (or DeleteMin(H)) - return minimum value from heap H and remove it from heap\n  + DecreaseKey(H,x,k) - decrease value of element x in heap H to value k\n  + Delete(H,x) - remove element x from heap H"}, {"role": "assistant", "content": "**Translation of**: Go & Kotlin\n\n```\n# 20200609 Raku programming solution\n\nsubset vEle of Any; \n\nclass Node {\n   has vEle $.value  is rw is default(Nil) ; \n   has Node $.parent is rw ;\n   has Node $.child  is rw ; \n   has Node $.prev   is rw ; \n   has Node $.next   is rw ;  \n   has Int  $.rank   is rw is default(0) ; \n   has Bool $.mark   is rw is default(False) ; \n}\n\nmulti infix:<⪡>(vEle \\a, vEle \\b) { a le b } # custom defined 'less than'\n\nclass Heap { \n\n   has Node $.root is rw ;  \n\n   method MakeHeap { self.root = Node.new } \n\n   method Insert(vEle \\v) {\n      my $x = Node.new: value => v;\n      if self.root.value ~~ Nil {\n         $x.next = $x;\n         $x.prev = $x; \n         self.root = $x\n      } else {\n         meld1(self.root, $x);\n         self.root = $x if $x.value ⪡ self.root.value \n      }\n      return $x\n   }\n\n   method Union(Heap $h2) {\n      if not self.root.defined {\n         self.root = $h2.root\n      } elsif $h2.root.defined { \t\t \n         meld2(self.root, $h2.root);\n         self.root = $h2.root if $h2.root.value ⪡ self.root.value \n      }\n      $h2.root = Nil;\n   }\n\n   method Minimum() {\n      return unless self.root.defined; \n      return self.root.value\n   }\n\n   method ExtractMin() {\n      return Nil unless self.root.defined;\n      my \\min = self.root.value;\n      my %roots;\n\n      sub add (Node \\r) {\n         r.prev = r;\n         r.next = r;\n         loop {\n            (defined my \\x = %roots{r.rank}) or last;\n            %roots{r.rank}:delete;\n            (r, x) = (x, r) if x.value ⪡ r.value ; \n            x.parent = r ;\n            x.mark = False ;\n            if not r.child.defined {\n               x.next = x;\n               x.prev = x;\n               r.child = x\n            } else {\n               meld1(r.child, x)\n            }\n            r.rank++\n         }\n         %roots{r.rank} = r ;\n      }\n\n      loop (my \\r = self.root.next ; not r ~~ self.root ; ) {\n         my $n = r.next;         \n         add(r);\n         r = $n ;\n      }\n      if defined (my \\c = self.root.child ) {\n         c.parent = Nil;\n         r = c.next;\n         add(c);\n         while not r ~~ c {\n            my $n = r.next;\n            r.parent = Nil;\n            add(r);\n            r = $n;\n         }\n      }\n      \n      unless %roots.defined {\n         self.root = Nil;\n         return min\n      }\n      my Node $mv = %roots{my $d = %roots.keys.first}; \n      %roots{$d}:delete;\n      $mv.next = $mv;\n      $mv.prev = $mv;\n      %roots.values.map: {\n         $_.prev = $mv;\n         $_.next = $mv.next;\n         $mv.next.prev = $_;\n         $mv.next = $_; \n         $mv = $_ if $_.value ⪡ $mv.value \n      }\n      self.root = $mv;\n      return min\n   }\n\n\n   method DecreaseKey(\\n, \\v) {\n      die \"DecreaseKey new value greater than existing value\" if n.value ⪡ v;\n      n.value = v; \n      return Nil if n ~~ self.root;\n      my \\p = n.parent;\n      unless p.defined {\n         self.root = n if v ⪡ self.root.value; \n         return Nil \n      }\n      self.cutAndMeld(n);\n      return Nil \n   }\n\n   method cutAndMeld(\\x) {\n      self.cut(x);\n      x.parent = Nil;\n      meld1(self.root, x)\n   }\n\n   method cut(\\x) {\n      my \\p = x.parent;\n      return Nil unless p.defined;\n      p.rank--;\n      if p.rank == 0 {\n         p.child = Nil\n      } else {\n         p.child = x.next;\n         x.prev.next = x.next;\n         x.next.prev = x.prev\n      }\n      return Nil unless p.parent.defined;\n      unless p.mark {\n        p.mark = True;\n        return Nil\n      }\n      self.cutAndMeld(p)\n   }\n \n   method Delete(\\n) {\n      my \\p = n.parent;\n      if not p.defined {\n         self.ExtractMin() and return if n ~~ self.root ; \n         n.prev.next = n.next;\n         n.next.prev = n.prev\n      } else {\n         self.cut(n)\n      }\n      my \\c = n.child;\n      return Nil unless c.defined;\n      loop ( c.parent = Nil, c = c.next ; c ~~ n.child ; c = c.next ) {} \n      meld2(self.root, c)\n   }\n\n   method Vis() {\n\n      if self.root.value ~~ Nil { say \"<empty>\" and return }\n\n      sub f(Node $n, Str $pre) {\n         loop ( my $pc = \"│ \", my $x = $n ; ; $x = $x.next) {\n            if !($x.next ~~ $n) {\n               print $pre, \"├─\"\n            } else {\n               print $pre, \"└─\";\n               $pc = \"  \"\n            }\n            if not $x.child.defined {\n               say \"╴\", $x.value\n            } else {\n               say \"┐\", $x.value;\n               f($x.child, $pre~$pc)\n            }\n            last if $x.next ~~ $n \n         }\n      }\n      f(self.root, \"\")\n   }\n}\n\nsub meld1(\\list, \\single) {\n   list.prev.next = single;\n   single.prev = list.prev;\n   single.next = list;\n   list.prev = single;\n}\n\nsub meld2(\\a, \\b) {\n   a.prev.next = b;\n   b.prev.next = a;\n   ( a.prev, b.prev ) = ( b.prev, a.prev )\n}\n\nsay \"MakeHeap:\";\nmy $h = Heap.new; \n$h.MakeHeap;\n$h.Vis;\n\nsay \"\\nInsert:\";\n$h.Insert(\"cat\");\n$h.Vis;\n\nsay \"\\nUnion:\";\nmy $h2 = Heap.new; \n$h2.MakeHeap;\n$h2.Insert(\"rat\");\n$h.Union($h2);\n$h.Vis;\n\nsay \"\\nMinimum:\";\nmy \\m = $h.Minimum();\nsay m;\n\nsay \"\\nExtractMin:\";\n$h.Insert(\"bat\");\nmy $x = $h.Insert(\"meerkat\"); \nsay \"extracted: \", my $mm = $h.ExtractMin();\n$h.Vis;\n\nsay \"\\nDecreaseKey:\";\n$h.DecreaseKey($x, \"gnat\");\n$h.Vis;\n\nsay \"\\nDelete:\";\n$h.Insert(\"bobcat\");\n$h.Insert(\"bat\");\nsay \"deleting: \", $x.value;\n$h.Delete($x);\n$h.Vis;\n\n```\n\nOutput:\n\n```\nMakeHeap:\n<empty>\n\nInsert:\n└─╴cat\n\nUnion:\n├─╴cat\n└─╴rat\n\nMinimum:\ncat\n\nExtractMin:\nextracted: bat\n├─┐cat\n│ └─╴rat\n└─╴meerkat\n\nDecreaseKey:\n├─┐cat\n│ └─╴rat\n└─╴gnat\n\nDelete:\ndeleting: gnat\n├─╴bat\n├─╴bobcat\n└─┐cat\n  └─╴rat\n```"}]}
{"messages": [{"role": "user", "content": "The **Fibonacci sequence** defined with matrix-exponentiation:\n\n:   :   :   :   :   (\n\n                    1\n\n                    1\n\n\n                    1\n\n                    0\n                    )\n\n                    n\n                    =\n\n\n                    (\n\n                    F\n\n                    n\n                    +\n                    1\n\n\n                    F\n\n                    n\n\n                    F\n\n                    n\n\n\n                    F\n\n                    n\n                    −\n                    1\n                    )\n                    .\n                    {\\displaystyle {\\displaystyle {\\begin{pmatrix}1&1\\\\1&0\\end{pmatrix}}^{n}={\\begin{pmatrix}F\\_{n+1}&F\\_{n}\\\\F\\_{n}&F\\_{n-1}\\end{pmatrix}}.}}\n\nTask\n\nWrite a program using   *matrix exponentiation*   to generate Fibonacci(n) for   **n**   equal to:\n\n:   :   :   * 10\n            * 100\n            * 1,000\n            * 10,000\n            * 100,000\n            * 1,000,000\n            * 10,000,000\n\nOnly display the first **20** decimal digits   and   the last **20** decimal digits of each Fibonacci number.\n\nExtra\n\nGenerate Fibonacci(216 ), Fibonacci(232) and Fibonacci(264) using the same method or another one.\n\nRelated tasks\n\n* Fibonacci sequence\n* Matrix-exponentiation operator"}, {"role": "assistant", "content": "(formerly Perl 6)\nFollowing the general approach of Sidef, and relying on Perl for `fibmod` function. Borrowed/adapted routines from Ramanujan's\\_constant task to allow `FatRat` calculations throughout. Does not quite meet task spec, as n^64 results not working yet.\n\n```\nuse Math::Matrix;\nuse Inline::Perl5;\nmy $p5 = Inline::Perl5.new();\n$p5.use( 'Math::AnyNum' );\n\nconstant D = 53;  # set the size of FatRat calcluations\n\n# matrix exponentiation\nsub fibonacci ($n) {\n    my $M = Math::Matrix.new( [[1,1],[1,0]] );\n    ($M ** $n)[0][1]\n}\n\n# calculation of 𝑒\nsub postfix:<!> (Int $n) { (constant f = 1, |[\\×] 1..*)[$n] }\nsub 𝑒 (--> FatRat) { sum map { FatRat.new(1,.!) }, ^D }\n\n# calculation of π\nsub π (--> FatRat) {\n    my ($a, $n, $g, $z, $pi) = 1, 1, sqrt(1/2.FatRat), 0.25;\n\n    for ^5 {\n        given [ ($a + $g)/2, sqrt $a × $g ] {\n            $z -= (.[0] - $a)**2 × $n;\n            $n += $n;\n            ($a, $g) = @$_;\n            $pi = ($a ** 2 / $z).substr: 0, 2 + D\n        }\n    }\n    $pi.FatRat\n}\n\n# square-root: accepts/return FatRat\nmulti sqrt(FatRat $r --> FatRat) {\n    FatRat.new: sqrt($r.nude[0] × 10**(D×2) div $r.nude[1]), 10**D\n}\n\n# square-root: accepts/return Int\nmulti sqrt(Int $n --> Int) {\n    my $guess = 10**($n.chars div 2);\n    my $iterator = { ( $^x   +   $n div ($^x) ) div 2 };\n    my $endpoint = { $^x == $^y|$^z };\n    min ($guess, $iterator … $endpoint)[*-1, *-2]\n}\n\n# arithmetic-geometric mean: accepts/returns FatRat\nsub AG-mean(FatRat $a is copy, FatRat $g is copy --> FatRat) {\n    ($a, $g) = ($a + $g)/2, sqrt $a × $g until $a - $g < 10**-D;\n    $a\n}\n\n# override built-in definitions with 'FatRat' versions\nconstant 𝑒 = &𝑒();\nconstant π = &π();\n\n# approximation of natural log, accepts any numeric, returns FatRat\nsub log-approx ($x --> FatRat) {\n    constant ln2 = 2 * [+] (((1/3).FatRat**(2*$_+1))/(2*$_+1) for 0..D); # 1/3 = (2-1)/(2+1)\n    π / (2 × AG-mean(1.FatRat, 2.FatRat**(2-D)/$x)) - D × ln2\n}\n\n# power function, with exponent less than zero: accepts/returns FatRat\nmulti infix:<**> (FatRat $base, FatRat $exp is copy where * <  0 --> FatRat) {\n    constant ε = 10**-D;\n    my ($low, $high) = 0.FatRat, 1.FatRat;\n    my $mid  = $high / 2;\n    my $acc  = my $sqr = sqrt($base);\n    $exp = -$exp;\n\n    while (abs($mid - $exp) > ε) {\n        $sqr = sqrt($sqr);\n        if ($mid <= $exp) { $low  = $mid; $acc ×=   $sqr }\n        else              { $high = $mid; $acc ×= 1/$sqr }\n        $mid = ($low + $high) / 2\n    }\n\n    (1/$acc).substr(0, D).FatRat\n}\n\nsub binet_approx (Int $n --> FatRat) {\n    constant PHI =   sqrt(1.25.FatRat) + 0.5 ;\n    constant IHP = -(sqrt(1.25.FatRat) - 0.5);\n    $n × log-approx(PHI) - log-approx(PHI - IHP)\n}\n\nsub nth_fib_first_k_digits ($n,$k) {\n    my $f     = binet_approx($n);\n    my $log10 = log-approx(10);\n    floor( 𝑒**($f - $log10×(floor($f/$log10 + 1))) × 10**$k)\n}\n\nmy &nth_fib_last_k_digits =\n    $p5.run('sub { my($n,$k) = @_; Math::AnyNum::fibmod($n, 10**$k) }');\n\n# matrix exponentiation is very inefficient, n^64 not feasible\nfor (16, 32) -> $n {\n    my $f = fibonacci(2**$n);\n    printf \"F(2^$n) = %s ... %s\\n\", substr($f,0,20), $f % 10**20\n}\n\n# this way is much faster, but not yet able to handle 2^64 case\nfor 16, 32 -> $n {\n    my $first20 = nth_fib_first_k_digits(2**$n, 20);\n    my $last20  = nth_fib_last_k_digits(2**$n, 20);\n    printf \"F(2^$n) = %s ... %s\\n\", $first20, $last20\n}\n\n```\n\nOutput:\n\n```\nF(2^16) = 73199214460290552832 ... 97270190955307463227\nF(2^32) = 61999319689381859818 ... 39623735538208076347\nF(2^16) = 73199214460290552832 ... 97270190955307463227\nF(2^32) = 61999319689381859818 ... 39623735538208076347\n```"}]}
{"messages": [{"role": "user", "content": "These number series are an expansion of the ordinary Fibonacci sequence where:\n\n1. For \n\n   n\n   =\n   2\n   {\\displaystyle {\\displaystyle n=2}}\n    we have the Fibonacci sequence; with initial values \n\n   [\n   1\n   ,\n   1\n   ]\n   {\\displaystyle {\\displaystyle [1,1]}}\n    and \n\n   F\n\n   k\n\n   2\n   =\n\n   F\n\n   k\n   −\n   1\n\n   2\n   +\n\n   F\n\n   k\n   −\n   2\n\n   2\n   {\\displaystyle {\\displaystyle F\\_{k}^{2}=F\\_{k-1}^{2}+F\\_{k-2}^{2}}}\n2. For \n\n   n\n   =\n   3\n   {\\displaystyle {\\displaystyle n=3}}\n    we have the tribonacci sequence; with initial values \n\n   [\n   1\n   ,\n   1\n   ,\n   2\n   ]\n   {\\displaystyle {\\displaystyle [1,1,2]}}\n    and \n\n   F\n\n   k\n\n   3\n   =\n\n   F\n\n   k\n   −\n   1\n\n   3\n   +\n\n   F\n\n   k\n   −\n   2\n\n   3\n   +\n\n   F\n\n   k\n   −\n   3\n\n   3\n   {\\displaystyle {\\displaystyle F\\_{k}^{3}=F\\_{k-1}^{3}+F\\_{k-2}^{3}+F\\_{k-3}^{3}}}\n3. For \n\n   n\n   =\n   4\n   {\\displaystyle {\\displaystyle n=4}}\n    we have the tetranacci sequence; with initial values \n\n   [\n   1\n   ,\n   1\n   ,\n   2\n   ,\n   4\n   ]\n   {\\displaystyle {\\displaystyle [1,1,2,4]}}\n    and \n\n   F\n\n   k\n\n   4\n   =\n\n   F\n\n   k\n   −\n   1\n\n   4\n   +\n\n   F\n\n   k\n   −\n   2\n\n   4\n   +\n\n   F\n\n   k\n   −\n   3\n\n   4\n   +\n\n   F\n\n   k\n   −\n   4\n\n   4\n   {\\displaystyle {\\displaystyle F\\_{k}^{4}=F\\_{k-1}^{4}+F\\_{k-2}^{4}+F\\_{k-3}^{4}+F\\_{k-4}^{4}}}\n     \n   ...\n4. For general \n\n   n\n   >\n   2\n   {\\displaystyle {\\displaystyle n>2}}\n    we have the Fibonacci \n\n   n\n   {\\displaystyle {\\displaystyle n}}\n   -step sequence - \n\n   F\n\n   k\n\n   n\n   {\\displaystyle {\\displaystyle F\\_{k}^{n}}}\n   ; with initial values of the first \n\n   n\n   {\\displaystyle {\\displaystyle n}}\n    values of the \n\n   (\n   n\n   −\n   1\n   )\n   {\\displaystyle {\\displaystyle (n-1)}}\n   'th Fibonacci \n\n   n\n   {\\displaystyle {\\displaystyle n}}\n   -step sequence \n\n   F\n\n   k\n\n   n\n   −\n   1\n   {\\displaystyle {\\displaystyle F\\_{k}^{n-1}}}\n   ; and \n\n   k\n   {\\displaystyle {\\displaystyle k}}\n   'th value of this \n\n   n\n   {\\displaystyle {\\displaystyle n}}\n   'th sequence being \n\n   F\n\n   k\n\n   n\n   =\n\n   ∑\n\n   i\n   =\n   1\n\n   (\n   n\n   )\n\n\n   F\n\n   k\n   −\n   i\n\n   (\n   n\n   )\n   {\\displaystyle {\\displaystyle F\\_{k}^{n}=\\sum \\_{i=1}^{(n)}{F\\_{k-i}^{(n)}}}}\n\nFor small values of \n\nn\n{\\displaystyle {\\displaystyle n}}\n, Greek numeric prefixes are sometimes used to individually name each series.\n\n:   :   :   :   Fibonacci \n\n                n\n                {\\displaystyle {\\displaystyle n}}\n                -step sequences\n\n                | n {\\displaystyle {\\displaystyle n}} | Series name | Values |\n                | --- | --- | --- |\n                | 2 | fibonacci | 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ... |\n                | 3 | tribonacci | 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 ... |\n                | 4 | tetranacci | 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ... |\n                | 5 | pentanacci | 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ... |\n                | 6 | hexanacci | 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ... |\n                | 7 | heptanacci | 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ... |\n                | 8 | octonacci | 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ... |\n                | 9 | nonanacci | 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ... |\n                | 10 | decanacci | 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ... |\n\nAllied sequences can be generated where the initial values are changed:\n\n:   **The Lucas series** sums the two preceding values like the fibonacci series for \n\n    n\n    =\n    2\n    {\\displaystyle {\\displaystyle n=2}}\n     but uses \n\n    [\n    2\n    ,\n    1\n    ]\n    {\\displaystyle {\\displaystyle [2,1]}}\n     as its initial values.\n\nTask\n\n1. Write a function to generate Fibonacci \n\n   n\n   {\\displaystyle {\\displaystyle n}}\n   -step number sequences given its initial values and assuming the number of initial values determines how many previous values are summed to make the next number of the series.\n2. Use this to print and show here at least the first ten members of the Fibo/tribo/tetra-nacci and Lucas sequences.\n\nRelated tasks\n\n* Fibonacci sequence\n* Wolfram Mathworld\n* Hofstadter Q sequence‎\n* Leonardo numbers\n\nAlso see\n\n* Lucas Numbers - Numberphile (Video)\n* Tribonacci Numbers (and the Rauzy Fractal) - Numberphile (Video)\n* Wikipedia, Lucas number\n* MathWorld, Fibonacci Number\n* Some identities for r-Fibonacci numbers\n* OEIS Fibonacci numbers\n* OEIS Lucas numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Lazy List with Closure\n\n```\nsub nacci ( $s = 2, :@start = (1,) ) {\n    my @seq = |@start, { state $n = +@start; @seq[ ($n - $s .. $n++ - 1).grep: * >= 0 ].sum } … *;\n}\n\nput \"{.fmt: '%2d'}-nacci: \", nacci($_)[^20] for 2..12 ;\n\nput \"Lucas: \", nacci(:start(2,1))[^20];\n\n```\n\nOutput:\n\n```\n 2-nacci: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765\n 3-nacci: 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 5768 10609 19513 35890 66012\n 4-nacci: 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 10671 20569 39648 76424 147312\n 5-nacci: 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 13624 26784 52656 103519 203513\n 6-nacci: 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 15109 29970 59448 117920 233904\n 7-nacci: 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 15808 31489 62725 124946 248888\n 8-nacci: 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 16128 32192 64256 128257 256005\n 9-nacci: 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 16272 32512 64960 129792 259328\n10-nacci: 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 16336 32656 65280 130496 260864\n11-nacci: 1 1 2 4 8 16 32 64 128 256 512 1024 2047 4093 8184 16364 32720 65424 130816 261568\n12-nacci: 1 1 2 4 8 16 32 64 128 256 512 1024 2048 4095 8189 16376 32748 65488 130960 261888\nLucas: 2 1 3 4 7 11 18 29 47 76 123 199 322 521 843 1364 2207 3571 5778 9349\n```\n\n### Generative\n\nA slightly more straight forward way of constructing a lazy list.\n\n**Works with**: Rakudo version 2015.12\n\n```\nsub fib ($n, @xs is copy = [1]) {\n    flat gather {\n        take @xs[*];\n        loop {\n            take my $x = [+] @xs;\n            @xs.push: $x;\n            @xs.shift if @xs > $n;\n        }\n    }\n}\n\nfor 2..10 -> $n {\n    say fib($n, [1])[^20];\n}\nsay fib(2, [2,1])[^20];\n\n```"}]}
{"messages": [{"role": "user", "content": "The **Fibonacci sequence** is a sequence    Fn    of natural numbers defined recursively:\n\n```\n      F0 = 0 \n      F1 = 1 \n      Fn = Fn-1 + Fn-2, if n>1 \n\n```\n\nTask\n\nWrite a function to generate the    nth    Fibonacci number.\n\nSolutions can be iterative or recursive (though recursive solutions are generally considered too slow and are mostly used as an exercise in recursion).\n\nThe sequence is sometimes extended into negative numbers by using a straightforward inverse of the positive definition:\n\n```\n      Fn = Fn+2 - Fn+1, if n<0   \n\n```\n\nsupport for negative      n      in the solution is optional.\n\nRelated tasks\n\n* Fibonacci n-step number sequences‎\n* Leonardo numbers\n\nReferences\n\n* Wikipedia, Fibonacci number\n* Wikipedia, Lucas number\n* MathWorld, Fibonacci Number\n* Some identities for r-Fibonacci numbers\n* OEIS Fibonacci numbers\n* OEIS Lucas numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### List Generator\n\nThis constructs the fibonacci sequence as a lazy infinite list.\n\n```\nconstant @fib = 0, 1, *+* ... *;\n```\n\nIf you really need a function for it:\n\n```\nsub fib ($n) { @fib[$n] }\n```\n\nTo support negative indices:\n\n```\nconstant @neg-fib = 0, 1, *-* ... *;\nsub fib ($n) { $n >= 0 ?? @fib[$n] !! @neg-fib[-$n] }\n```\n\n### Iterative\n\n```\nsub fib (Int $n --> Int) {\n    $n > 1 or return $n;\n    my ($prev, $this) = 0, 1;\n    ($prev, $this) = $this, $this + $prev for 1 ..^ $n;\n    return $this;\n}\n```\n\n### Recursive\n\n```\nproto fib (Int $n --> Int) {*}\nmulti fib (0)  { 0 }\nmulti fib (1)  { 1 }\nmulti fib ($n) { fib($n - 1) + fib($n - 2) }\n```"}]}
{"messages": [{"role": "user", "content": "Fibonacci word.\n\nThe   Fibonacci Word   may be created in a manner analogous to the   Fibonacci Sequence   as described here:\n\n```\n    Define   F_Word1   as   1\n    Define   F_Word2   as   0\n    Form     F_Word3   as   F_Word2     concatenated with   F_Word1    i.e.:   01\n    Form     F_Wordn   as   F_Wordn-1   concatenated with   F_wordn-2\n\n```\n\nTask\n\nPerform the above steps for     n = 37.\n\nYou may display the first few but not the larger values of   n.\n  \n{Doing so will get the task's author into trouble with them what be (again!).}\n\nInstead, create a table for   F\\_Words   **1**   to   **37**   which shows:\n\n:   :   * The number of characters in the word\n        * The word's Entropy\n\nRelated tasks\n\n* Fibonacci word/fractal\n* Entropy\n* Entropy/Narcissist"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nconstant @fib-word = 1, 0, { $^b ~ $^a } ... *;\n \nsub entropy {\n    -log(2) R/\n        [+] map -> \\p { p * log p },\n            $^string.comb.Bag.values »/» $string.chars\n}\nfor @fib-word[^37] {\n    printf \"%5d\\t%10d\\t%.8e\\t%s\\n\",\n    (state $n)++, .chars, .&entropy, $n > 10 ?? '' !! $_;\n}\n\n```\n\nThat works, but is terribly slow due to all the string processing and bag creation, just to count 0's and 1's. By contrast, the following prints the table up to 100 almost instantly by tracking the values to calculate entropy in parallel with the actual strings. This works in Raku because lazy lists are calculated on demand, so if we don't actually ask for the larger string forms, we don't calculate them. Which would be relatively difficult for a string containing 573147844013817084101 characters, unless you happen to have a computer with a zettabyte or so of memory sitting in your garage.\n\n```\nconstant @fib-word = '1', '0', { $^b ~ $^a } ... *;\nconstant @fib-ones = 1, 0, * + * ... *;\nconstant @fib-chrs = 1, 1, * + * ... *;\n \nmulti entropy(0) { 0 }\nmulti entropy(1) { 0 }\nmulti entropy($n) {\n    my $chars = @fib-chrs[$n];\n    my $ones  = @fib-ones[$n];\n    my $zeros = $chars - $ones;\n    -log(2) R/\n        [+] map -> \\p { p * log p },\n            $ones / $chars, $zeros / $chars\n}\n\nfor 0..100 -> $n {\n    printf \"%5d\\t%21d\\t%.15e\\t%s\\n\",\n\t    $n, @fib-chrs[$n], entropy($n), $n > 9 ?? '' !! @fib-word[$n];\n}\n\n```\n\nOutput:\n\n```\n    0\t                    1\t0.000000000000000e+00\t1\n    1\t                    1\t0.000000000000000e+00\t0\n    2\t                    2\t1.000000000000000e+00\t01\n    3\t                    3\t9.182958340544895e-01\t010\n    4\t                    5\t9.709505944546688e-01\t01001\n    5\t                    8\t9.544340029249650e-01\t01001010\n    6\t                   13\t9.612366047228759e-01\t0100101001001\n    7\t                   21\t9.587118829771317e-01\t010010100100101001010\n    8\t                   34\t9.596868937742167e-01\t0100101001001010010100100101001001\n    9\t                   55\t9.593160320543776e-01\t0100101001001010010100100101001001010010100100101001010\n   10\t                   89\t9.594579158386695e-01\t\n   11\t                  144\t9.594037542210229e-01\t\n   12\t                  233\t9.594244469559866e-01\t\n   13\t                  377\t9.594165437404406e-01\t\n   14\t                  610\t9.594195626031441e-01\t\n   15\t                  987\t9.594184095152244e-01\t\n   16\t                 1597\t9.594188499578099e-01\t\n   17\t                 2584\t9.594186817240321e-01\t\n   18\t                 4181\t9.594187459836640e-01\t\n   19\t                 6765\t9.594187214386754e-01\t\n   20\t                10946\t9.594187308140276e-01\t\n   21\t                17711\t9.594187272329618e-01\t\n   22\t                28657\t9.594187286008074e-01\t\n   23\t                46368\t9.594187280783370e-01\t\n   24\t                75025\t9.594187282779029e-01\t\n   25\t               121393\t9.594187282016755e-01\t\n   26\t               196418\t9.594187282307919e-01\t\n   27\t               317811\t9.594187282196701e-01\t\n   28\t               514229\t9.594187282239183e-01\t\n   29\t               832040\t9.594187282222958e-01\t\n   30\t              1346269\t9.594187282229156e-01\t\n   31\t              2178309\t9.594187282226789e-01\t\n   32\t              3524578\t9.594187282227692e-01\t\n   33\t              5702887\t9.594187282227345e-01\t\n   34\t              9227465\t9.594187282227477e-01\t\n   35\t             14930352\t9.594187282227427e-01\t\n   36\t             24157817\t9.594187282227447e-01\t\n   37\t             39088169\t9.594187282227441e-01\t\n   38\t             63245986\t9.594187282227441e-01\t\n   39\t            102334155\t9.594187282227441e-01\t\n   40\t            165580141\t9.594187282227441e-01\t\n   41\t            267914296\t9.594187282227441e-01\t\n   42\t            433494437\t9.594187282227441e-01\t\n   43\t            701408733\t9.594187282227441e-01\t\n   44\t           1134903170\t9.594187282227441e-01\t\n   45\t           1836311903\t9.594187282227441e-01\t\n   46\t           2971215073\t9.594187282227441e-01\t\n   47\t           4807526976\t9.594187282227441e-01\t\n   48\t           7778742049\t9.594187282227441e-01\t\n   49\t          12586269025\t9.594187282227441e-01\t\n   50\t          20365011074\t9.594187282227441e-01\t\n   51\t          32951280099\t9.594187282227441e-01\t\n   52\t          53316291173\t9.594187282227441e-01\t\n   53\t          86267571272\t9.594187282227441e-01\t\n   54\t         139583862445\t9.594187282227441e-01\t\n   55\t         225851433717\t9.594187282227441e-01\t\n   56\t         365435296162\t9.594187282227441e-01\t\n   57\t         591286729879\t9.594187282227441e-01\t\n   58\t         956722026041\t9.594187282227441e-01\t\n   59\t        1548008755920\t9.594187282227441e-01\t\n   60\t        2504730781961\t9.594187282227441e-01\t\n   61\t        4052739537881\t9.594187282227441e-01\t\n   62\t        6557470319842\t9.594187282227441e-01\t\n   63\t       10610209857723\t9.594187282227441e-01\t\n   64\t       17167680177565\t9.594187282227441e-01\t\n   65\t       27777890035288\t9.594187282227441e-01\t\n   66\t       44945570212853\t9.594187282227441e-01\t\n   67\t       72723460248141\t9.594187282227441e-01\t\n   68\t      117669030460994\t9.594187282227441e-01\t\n   69\t      190392490709135\t9.594187282227441e-01\t\n   70\t      308061521170129\t9.594187282227441e-01\t\n   71\t      498454011879264\t9.594187282227441e-01\t\n   72\t      806515533049393\t9.594187282227441e-01\t\n   73\t     1304969544928657\t9.594187282227441e-01\t\n   74\t     2111485077978050\t9.594187282227441e-01\t\n   75\t     3416454622906707\t9.594187282227441e-01\t\n   76\t     5527939700884757\t9.594187282227441e-01\t\n   77\t     8944394323791464\t9.594187282227441e-01\t\n   78\t    14472334024676221\t9.594187282227441e-01\t\n   79\t    23416728348467685\t9.594187282227441e-01\t\n   80\t    37889062373143906\t9.594187282227441e-01\t\n   81\t    61305790721611591\t9.594187282227441e-01\t\n   82\t    99194853094755497\t9.594187282227441e-01\t\n   83\t   160500643816367088\t9.594187282227441e-01\t\n   84\t   259695496911122585\t9.594187282227441e-01\t\n   85\t   420196140727489673\t9.594187282227441e-01\t\n   86\t   679891637638612258\t9.594187282227441e-01\t\n   87\t  1100087778366101931\t9.594187282227441e-01\t\n   88\t  1779979416004714189\t9.594187282227441e-01\t\n   89\t  2880067194370816120\t9.594187282227441e-01\t\n   90\t  4660046610375530309\t9.594187282227441e-01\t\n   91\t  7540113804746346429\t9.594187282227441e-01\t\n   92\t 12200160415121876738\t9.594187282227441e-01\t\n   93\t 19740274219868223167\t9.594187282227441e-01\t\n   94\t 31940434634990099905\t9.594187282227441e-01\t\n   95\t 51680708854858323072\t9.594187282227441e-01\t\n   96\t 83621143489848422977\t9.594187282227441e-01\t\n   97\t135301852344706746049\t9.594187282227441e-01\t\n   98\t218922995834555169026\t9.594187282227441e-01\t\n   99\t354224848179261915075\t9.594187282227441e-01\t\n  100\t573147844013817084101\t9.594187282227441e-01\n```"}]}
{"messages": [{"role": "user", "content": "The Fibonacci word may be represented as a fractal as described here:\n  \n  \n(Clicking on the above website   (hal.archives-ouvertes.fr)    will leave a cookie.)\n\n:   For F\\_wordm start with F\\_wordCharn=1\n:   Draw a segment forward\n:   If current F\\_wordChar is 0\n\n    :   Turn left if n is even\n    :   Turn right if n is odd\n:   next n and iterate until end of F\\_word\n\nTask\n\nCreate and display a fractal similar to Fig 1.\n  \n  \n(Clicking on the above website   (hal.archives-ouvertes.fr)    will leave a cookie.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nconstant @fib-word = '1', '0', { $^b ~ $^a } ... *;\n\nsub MAIN($m = 17, $scale = 3) {\n    (my %world){0}{0} = 1;\n    my $loc = 0+0i;\n    my $dir = i;\n    my $n = 1;\n\n    for @fib-word[$m].comb {\n        when '0' {\n            step;\n            if $n %% 2 { turn-left }\n            else { turn-right; }\n        }\n        $n++;\n    }\n\n    braille-graphics %world;\n\n    sub step {\n        for ^$scale {\n            $loc += $dir;\n            %world{$loc.im}{$loc.re} = 1;\n        }\n    }\n\n    sub turn-left  { $dir *= i; }\n    sub turn-right { $dir *= -i; }\n\n}\n\nsub braille-graphics (%a) {\n    my ($ylo, $yhi, $xlo, $xhi);\n    for %a.keys -> $y {\n\t$ylo min= +$y; $yhi max= +$y;\n\tfor %a{$y}.keys -> $x {\n\t    $xlo min= +$x; $xhi max= +$x;\n\t}\n    }\n\n    for $ylo, $ylo + 4 ...^ * > $yhi -> \\y {\n\tfor $xlo, $xlo + 2 ...^ * > $xhi -> \\x {\n\t    my $cell = 0x2800;\n\t    $cell += 1   if %a{y + 0}{x + 0};\n\t    $cell += 2   if %a{y + 1}{x + 0};\n\t    $cell += 4   if %a{y + 2}{x + 0};\n\t    $cell += 8   if %a{y + 0}{x + 1};\n\t    $cell += 16  if %a{y + 1}{x + 1};\n\t    $cell += 32  if %a{y + 2}{x + 1};\n\t    $cell += 64  if %a{y + 3}{x + 0};\n\t    $cell += 128 if %a{y + 3}{x + 1};\n\t    print chr($cell);\n\t}\n\tprint \"\\n\";\n    }\n}\n\n```\n\nOutput:\n\n```\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣇⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⢤⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⠃⠘⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⣇⣸⠉⣇⣀⠀⣀⣸⠉⣇⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⢤⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⡖⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢈⣉⡁⠀⠀⠀⢈⣉⡁⢈⣉⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⢤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⢤⠀⡤⠼⠀⠧⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⠚⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡏⢹⣀⡏⠉⠀⠉⢹⣀⡏⢹⣀⡀⢀⣀⡏⢹⣀⡏⠉⠀⠉⢹⣀⡏⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⡄⢠⠤⡄⠀⠀⠀⢠⠤⡄⢠⠤⠇⠸⠤⡄⢠⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⠚⠀⠓⢲⠀⡖⠚⠀⠓⠚⠀⠀⠀⠀⠓⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⢀⣀⡏⢹⣀⡀⢀⣀⡏⢹⣀⡏⠉⠀⠉⢹⣀⡏⢹⣀⡀⢀⣀⡏⢹⣀⡏⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠸⠤⡄⢠⠤⠇⠸⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠤⠇⠸⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⢰⠒⡆⢰⠒⠃⠘⠒⡆⢰⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠒⡆⢰⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⣏⣉⠀⣉⣉⠀⠀⠀⠀⣉⣉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣉⣉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠸⠤⠇⠸⠤⡄⢠⠤⠇⠸⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠤⠇⠸⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠤⠇⠸⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⢰⠒⠃⠘⠒⡆⢰⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠒⡆⢰⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠒⡆⢰⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠈⠉⣇⣸⠉⠁⠈⠉⣇⣸⠉⣇⣀⠀⣀⣸⠉⣇⣸⠉⠁⠈⠉⣇⣸⠉⣇⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣸⠉⣇⣸⠉⠁⠈⠉⣇⣸⠉⣇⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⢤⠀⡤⠼⠀⠧⢤⠀⡤⢤⠀⠀⠀⠀⡤⢤⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠧⢤⠀⡤⢤⠀⠀⠀⠀⡤⢤⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⠃⠘⠒⠃⠀⠀⠀⠘⠒⠃⠘⠒⡆⢰⠒⠃⠘⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠒⠃⠘⠒⡆⢰⠒⠃⠘⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⣇⣸⠉⣇⣀⠀⣀⣸⠉⣇⣸⠉⠁⠈⠉⣇⣸⠉⣇⣀⠀⣀⣸⠉⣇⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣸⠉⣇⣀⠀⣀⣸⠉⣇⣸⠉⠁⠈⠉⣇⣸⠉⣇⣀⠀⣀⣸⠉⣇⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⢤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⢤⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠧⢤⠀⡤⠼⠀⠧⢤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⢤⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⠚⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⡖⢲⠀⠀⠀⠀⡖⢲⠀⡖⠚⠀⠓⢲⠀⡖⠚⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⡖⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢈⣉⡁⠀⠀⠀⢈⣉⡁⢈⣉⡇⢸⣉⡁⢈⣉⡁⠀⠀⠀⢈⣉⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢈⣉⡁⠀⠀⠀⢈⣉⡁⢈⣉⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⢤⠀⡤⠼⠀⠧⠼⠀⠀⠀⠀⠧⠼⠀⠧⢤⠀⡤⠼⠀⠧⢤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⢤⠀⡤⠼⠀⠧⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡖⠚⠀⠓⢲⠀⡖⠚⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡏⢹⣀⡏⠉⠀⠉⢹⣀⡏⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⢹⣀⡏⠉⠀⠉⢹⣀⡏⢹⣀⡀⢀⣀⡏⢹⣀⡏⠉⠀⠉⢹⣀⡏⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⡄⢠⠤⡄⠀⠀⠀⢠⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠤⡄⠀⠀⠀⢠⠤⡄⢠⠤⠇⠸⠤⡄⢠⠤⡄⠀⠀⠀⢠⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⠚⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡖⠚⠀⠓⢲⠀⡖⠚⠀⠓⠚⠀⠀⠀⠀⠓⠚⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣹⠀⣏⣉⠀⣀⣀⠀⠀⠀⠀⣀⣀⠀⣉⣹⠀⣏⣉⠀⣉⣹⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣹⠀⣏⣉⠀⣀⣀⠀⠀⠀⠀⣀⣀⠀⣉⣹⠀⣏⣉⠀⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⠇⠀⠀⠀⠸⠤⠇⠸⠤⡄⢠⠤⠇⠸⠤⠇⠀⠀⠀⠸⠤⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⠇⠀⠀⠀⠸⠤⠇⠸⠤⡄⢠⠤⠇⠸⠤⠇⠀⠀⠀⠸⠤⠇⠸⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⡆⢰⠒⠃⠘⠒⡆⢰⠒⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⡆⢰⠒⠃⠘⠒⡆⢰⠒⡆⠀⠀⠀⢰⠒⡆⢰⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣉⠀⠀⠀⠀⣉⣉⠀⣉⣹⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣉⠀⠀⠀⠀⣉⣉⠀⣉⣹⠀⣏⣉⠀⣉⣉⠀⠀⠀⠀⣀⣀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⠇⠸⠤⡄⢠⠤⠇⠸⠤⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⠇⠸⠤⡄⢠⠤⠇⠸⠤⠇⠀⠀⠀⠸⠤⠇⠸⠤⡄⢠⠤⠇⠸⠤⡄⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⠃⠘⠒⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⠃⠘⠒⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⠃⠘⠒⡆⢰⠒⠃⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⣇⣸⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⣇⣸⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⣇⣸⠉⠁⠈⠉⣇⣸⠉⣇⣀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⢤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⢤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⢤⠀⠀⠀⠀⡤⢤⠀⡤⠼\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⠃⠘⠒⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⠃⠘⠒⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⠃⠘⠒⡆⢰⠒⠃⠘⠒⠃⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡀⢈⣉⡇⢸⣉⡁⢀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡀⢈⣉⡇⢸⣉⡁⢀⣀⡀⠀⠀⠀⢀⣀⡀⢈⣉⡇⢸⣉⡁⢈⣉⡇⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⠼⠀⠀⠀⠀⠧⠼⠀⠧⢤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⠼⠀⠀⠀⠀⠧⠼⠀⠧⢤⠀⡤⠼⠀⠧⠼⠀⠀⠀⠀⠧⠼⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⢲⠀⠀⠀⠀⡖⢲⠀⡖⠚⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⢲⠀⠀⠀⠀⡖⢲⠀⡖⠚⠀⠓⢲⠀⡖⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡀⠀⠀⠀⢈⣉⡁⢈⣉⡇⢸⣉⡁⢈⣉⡁⠀⠀⠀⢀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡀⠀⠀⠀⢈⣉⡁⢈⣉⡇⢸⣉⡁⢈⣉⡁⠀⠀⠀⢈⣉⡁⢈⣉⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⢤⠀⡤⠼⠀⠧⠼⠀⠀⠀⠀⠧⠼⠀⠧⢤⠀⡤⠼⠀⠧⢤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠧⢤⠀⡤⠼⠀⠧⠼⠀⠀⠀⠀⠧⠼⠀⠧⢤⠀⡤⠼⠀⠧⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡖⠚⠀⠓⢲⠀⡖⠚⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡏⢹⣀⡏⠉⠀⠉⢹⣀⡏⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⢹⣀⡏⠉⠀⠉⢹⣀⡏⢹⣀⡀⢀⣀⡏⢹⣀⡏⠉⠀⠉⢹⣀⡏⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⢹⣀⡏⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⡄⢠⠤⡄⠀⠀⠀⢠⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠤⡄⠀⠀⠀⢠⠤⡄⢠⠤⠇⠸⠤⡄⢠⠤⡄⠀⠀⠀⢠⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⠚⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡖⠚⠀⠓⢲⠀⡖⠚⠀⠓⠚⠀⠀⠀⠀⠓⠚⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣹⠀⣏⣉⠀⣀⣀⠀⠀⠀⠀⣀⣀⠀⣉⣹⠀⣏⣉⠀⣉⣹⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣹⠀⣏⣉⠀⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⠇⠀⠀⠀⠸⠤⠇⠸⠤⡄⢠⠤⠇⠸⠤⠇⠀⠀⠀⠸⠤⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⠇⠀⠀⠀⠸⠤⠇⠸⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⡆⠀⠀⠀⢰⠒⡆⢰⠒⠃⠘⠒⡆⢰⠒⡆⠀⠀⠀⢰⠒⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⡆⠀⠀⠀⢰⠒⡆⢰⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣹⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣹⠀⣏⣉⠀⠉⠉⠀⠀⠀⠀⠉⠉⠀⣉⣹⠀⣏⣉⠀⣉⣹⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣹⠀⣏⣉⠀⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⢤⠀⡤⠼⠀⠧⢤⠀⡤⢤⠀⠀⠀⠀⡤⢤⠀⡤⠼⠀⠧⢤⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠧⢤⠀⡤⠼⠀⠧⢤⠀⡤⢤⠀⠀⠀⠀⡤⢤⠀⡤⠼⠀⠧⢤⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⠃⠘⠒⠃⠀⠀⠀⠘⠒⠃⠘⠒⡆⢰⠒⠃⠘⠒⠃⠀⠀⠀⠘⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠒⠃⠀⠀⠀⠘⠒⠃⠘⠒⡆⢰⠒⠃⠘⠒⠃⠀⠀⠀⠘⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⣇⣸⠉⣇⣀⠀⣀⣸⠉⣇⣸⠉⠁⠈⠉⣇⣸⠉⣇⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣸⠉⣇⣸⠉⠁⠈⠉⣇⣸⠉⣇⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⡤⢤⠀⠀⠀⠀⡤⢤⠀⡤⠼⠀⠧⢤⠀⡤⢤⠀⠀⠀⠀⡤⢤⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠧⢤⠀⡤⢤⠀⠀⠀⠀⡤⢤⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⢰⠒⠃⠘⠒⡆⢰⠒⠃⠘⠒⠃⠀⠀⠀⠘⠒⠃⠘⠒⡆⢰⠒⠃⠘⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠒⠃⠘⠒⡆⢰⠒⠃⠘⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⢀⣀⡀⢈⣉⡇⢸⣉⡁⢈⣉⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣉⡁⢈⣉⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣉⡁⢈⣉⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⡤⠼⠀⠧⠼⠀⠀⠀⠀⠧⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠧⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠧⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠓⢲⠀⡖⢲⠀⠀⠀⠀⡖⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡖⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠈⠉⠁⢈⣉⡇⢸⣉⡁⢈⣉⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣉⡁⢈⣉⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠸⠤⡄⢠⠤⠇⠸⠤⡄⢠⠤⡄⠀⠀⠀⢠⠤⡄⢠⠤⠇⠸⠤⡄⢠⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠓⠚⠀⠀⠀⠀⠓⠚⠀⠓⢲⠀⡖⠚⠀⠓⠚⠀⠀⠀⠀⠓⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡏⢹⣀⡏⠉⠀⠉⢹⣀⡏⢹⣀⡀⢀⣀⡏⢹⣀⡏⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⡄⢠⠤⡄⠀⠀⠀⢠⠤⡄⢠⠤⠇⠸⠤⡄⢠⠤⡄⠀⠀⠀⢠⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⠚⠀⠓⢲⠀⡖⠚⠀⠓⠚⠀⠀⠀⠀⠓⠚⠀⠓⢲⠀⡖⠚⠀⠓⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣹⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣹⠀⣏⣉⠀⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠤⠇⠀⠀⠀⠸⠤⠇⠸⠤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⡆⠀⠀⠀⢰⠒⡆⢰⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣏⣉⠀⣉⣹⠀⣏⣉⠀⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⢤⠀⡤⠼⠀⠧⢤⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⠃⠘⠒⠃⠀⠀⠀⠘⠒⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⣇⣸⠉⣇⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡤⠼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠃\n```"}]}
{"messages": [{"role": "user", "content": "Filename extensions are a rudimentary but commonly used way of identifying files types.\n\nTask\n\nGiven an arbitrary filename and a list of extensions, tell whether the filename has one of those extensions.\n\nNotes:\n\n* The check should be case insensitive.\n* The extension must occur at the very end of the filename, and be immediately preceded by a dot (`.`).\n* You may assume that none of the given extensions are the empty string, and none of them contain a dot. Other than that they may be arbitrary strings.\n\n*Extra credit:*\n:   Allow extensions to contain dots. This way, users of your function/program have full control over what they consider as the extension in cases like:\n\n```\n  archive.tar.gz\n\n```\n\n:   Please state clearly whether or not your solution does this.\n\nTest cases\n\nThe following test cases all assume this list of extensions:   `zip`, `rar`, `7z`, `gz`, `archive`, `A##`\n\n:   :   :   :   :   :   :   :   | Filename | Result |\n                                | --- | --- |\n                                | `MyData.a##` | true |\n                                | `MyData.tar.Gz` | true |\n                                | `MyData.gzip` | false |\n                                | `MyData.7z.backup` | false |\n                                | `MyData...` | false |\n                                | `MyData` | false |\n\nIf your solution does the extra credit requirement, add `tar.bz2` to the list of extensions, and check the following additional test cases:\n\n:   :   :   :   :   :   :   :   | Filename | Result |\n                                | --- | --- |\n                                | `MyData_v1.0.tar.bz2` | true |\n                                | `MyData_v1.0.bz2` | false |\n\nMotivation\n\nChecking if a file is in a certain category of file formats with known extensions (e.g. archive files, or image files) is a common problem in practice, and may be approached differently from extracting and outputting an arbitrary extension *(see e.g. `FileNameExtensionFilter` in Java)*.\n\nIt also requires less assumptions about the format of an extension, because the calling code can decide what extensions are valid.\n\nFor these reasons, this task exists in addition to the Extract file extension task.\n\nRelated tasks\n\n* Extract file extension\n* String matching"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nDoes the extra credit requirement.\n\n```\nsub check-extension ($filename, *@extensions) {\n    so $filename ~~ /:i '.' @extensions $/\n}\n\n# Testing:\n\nmy @extensions = <zip rar 7z gz archive A## tar.bz2>;\nmy @files= <\n    MyData.a##  MyData.tar.Gz  MyData.gzip  MyData.7z.backup  MyData...  MyData\n    MyData_v1.0.tar.bz2  MyData_v1.0.bz2\n>;\nsay \"{$_.fmt: '%-19s'} - {check-extension $_, @extensions}\" for @files;\n\n```\n\nOutput:\n\n```\nMyData.a##          - True\nMyData.tar.Gz       - True\nMyData.gzip         - False\nMyData.7z.backup    - False\nMyData...           - False\nMyData              - False\nMyData_v1.0.tar.bz2 - True\nMyData_v1.0.bz2     - False\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a file called   \"output.txt\",   and place in it the contents of the file   \"input.txt\",   *via an intermediate variable*.\n\nIn other words, your program will demonstrate:\n\n:   :   1. how to read from a file into a variable\n        2. how to write a variable's contents into a file\n\nOneliners that skip the intermediate variable are of secondary interest — operating systems have copy commands for that."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nIf it is okay to have a temporary copy of the entire file in memory:\n\n**Works with**: Rakudo version 2016.07\n\n```\nspurt \"output.txt\", slurp \"input.txt\";\n```\n\nOtherwise, copying line-by line:\n\n**Works with**: Rakudo version 2015.12\n\n```\nmy $in = open \"input.txt\";\nmy $out = open \"output.txt\", :w;\nfor $in.lines -> $line {\n    $out.say: $line;\n}\n$in.close;\n$out.close;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGet and set the modification time of a file."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n```\nuse NativeCall;\n\nclass utimbuf is repr('CStruct') {\n    has int $.actime;\n    has int $.modtime;\n\n    submethod BUILD(:$atime, :$mtime) {\n        $!actime = $atime;\n        $!modtime = $mtime.to-posix[0].round;\n    }\n}\n\nsub sysutime(Str, utimbuf --> int32) is native is symbol('utime') {*}\n\nsub MAIN (Str $file) {\n    my $mtime = $file.IO.modified orelse .die;\n\n    my $ubuff = utimbuf.new(:atime(time),:mtime($mtime));\n\n    sysutime($file, $ubuff);\n}\n\n```\n\nSets the last access time to now,\nwhile restoring the modification time to what it was before."}]}
{"messages": [{"role": "user", "content": "Verify the size of a file called     **input.txt**     for a file in the current working directory, and another one in the file system root."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.12\n\n```\nsay 'input.txt'.IO.s;\nsay '/input.txt'.IO.s;\n\n```\n\nCross-platform version of the second one:\n\n```\nsay $*SPEC.rootdir.IO.child(\"input.txt\").s;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nBeginning from the current directory, or optionally from a directory specified as a command-line argument, determine how many files there are of various sizes in a directory hierarchy.\n\nMy suggestion is to sort by logarithmn of file size, since a few bytes here or there, or even a factor of two or three, may not be that significant.\n\nDon't forget that empty files may exist, to serve as a marker.\n\nIs your file system predominantly devoted to a large number of smaller files, or a smaller number of huge files?"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.05\n\nBy default, process the current and all readable sub-directories, or, pass in a directory path at the command line.\n\n```\nsub MAIN($dir = '.') {\n    sub log10 (Int $s) { $s ?? $s.log(10).Int !! 0 }\n    my %fsize;\n    my @dirs = $dir.IO;\n    while @dirs {\n        for @dirs.pop.dir -> $path {\n            %fsize{$path.s.&log10}++ if $path.f;\n            @dirs.push: $path if $path.d and $path.r\n        }\n    }\n    my $max = %fsize.values.max;\n    my $bar-size = 80;\n    say \"File size distribution in bytes for directory: $dir\\n\";\n    for 0 .. %fsize.keys.max {\n          say sprintf( \"# Files @ %5sb %8s: \", $_ ?? \"10e{$_-1}\" !! 0, %fsize{$_} // 0 ),\n              histogram( $max, %fsize{$_} // 0, $bar-size )\n    }\n    say %fsize.values.sum, ' total files.';\n}\n\nsub histogram ($max, $value, $width = 60) {\n    my @blocks = <| ▏ ▎ ▍ ▌ ▋ ▊ ▉ █>;\n    my $scaled = ($value * $width / $max).Int;\n    my ($end, $bar) = $scaled.polymod(8);\n    (@blocks[8] x $bar * 8) ~ (@blocks[$end] if $end) ~ \"\\n\"\n}\n\n```\n\nOutput:\n\n```\nFile size distribution in bytes for directory: /home\n\n# Files @     0b      989: ▏\n\n# Files @  10e0b     6655: ████████\n\n# Files @  10e1b    31776: ████████████████████████████████████████\n\n# Files @  10e2b    63165: ████████████████████████████████████████████████████████████████████████████████\n\n# Files @  10e3b    19874: ████████████████████████▏\n\n# Files @  10e4b     7730: ████████▏\n\n# Files @  10e5b     3418: ▌\n\n# Files @  10e6b     1378: ▏\n\n# Files @  10e7b      199:\n\n# Files @  10e8b       45:\n\n135229 total files.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSelect certain elements from an Array into a new Array in a generic way.\n\nTo demonstrate, select all even numbers from an Array.\n\nAs an option, give a second solution which filters destructively,\nby modifying the original Array rather than creating a new Array."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nmy @a = 1..6;\nmy @even = grep * %% 2, @a;\n```\n\nAlternatively:\n\n```\nmy @a = 1..6;\nmy @even = @a.grep(* %% 2);\n```\n\nDestructive:\n\n```\nmy @a = 1..6;\n@a .= grep(* %% 2);\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind adjacent primes under **1,000,000** whose difference **(> 36)** is a square integer."}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\nuse Math::Primesieve;\n\nmy $iterator = Math::Primesieve::iterator.new;\nmy $limit    = 1e10;\nmy @squares  = (1..30).map: *²;\nmy $last     = 2;\nmy @gaps;\nmy @counts;\n\nloop {\n    my $this = (my $p = $iterator.next) - $last;\n    quietly @gaps[$this].push($last) if +@gaps[$this] < 10;\n    @counts[$this]++;\n    last if $p > $limit;\n    $last = $p;\n}\n\nprint \"Adjacent primes up to {comma $limit.Int} with a gap value that is a perfect square:\";\nfor @gaps.pairs.grep: { (.key ∈ @squares) && .value.defined} -> $p {\n    my $ten = (@counts[$p.key] > 10) ?? ', (first ten)' !! '';\n    say \"\\nGap {$p.key}: {comma @counts[$p.key]} found$ten:\";\n    put join \"\\n\", $p.value.batch(5)».map({\"($_, {$_+ $p.key})\"})».join(', ');\n}\n\n```\n\nOutput:\n\n```\nAdjacent primes up to 10,000,000,000 with a gap value that is a perfect square:\nGap 1: 1 found:\n(2, 3)\n\nGap 4: 27,409,998 found, (first ten):\n(7, 11), (13, 17), (19, 23), (37, 41), (43, 47)\n(67, 71), (79, 83), (97, 101), (103, 107), (109, 113)\n\nGap 16: 15,888,305 found, (first ten):\n(1831, 1847), (1933, 1949), (2113, 2129), (2221, 2237), (2251, 2267)\n(2593, 2609), (2803, 2819), (3121, 3137), (3373, 3389), (3391, 3407)\n\nGap 36: 11,593,345 found, (first ten):\n(9551, 9587), (12853, 12889), (14107, 14143), (15823, 15859), (18803, 18839)\n(22193, 22229), (22307, 22343), (22817, 22853), (24281, 24317), (27143, 27179)\n\nGap 64: 1,434,957 found, (first ten):\n(89689, 89753), (107377, 107441), (288583, 288647), (367957, 368021), (381103, 381167)\n(400759, 400823), (445363, 445427), (623107, 623171), (625699, 625763), (637003, 637067)\n\nGap 100: 268,933 found, (first ten):\n(396733, 396833), (838249, 838349), (1313467, 1313567), (1648081, 1648181), (1655707, 1655807)\n(2345989, 2346089), (2784373, 2784473), (3254959, 3255059), (3595489, 3595589), (4047157, 4047257)\n\nGap 144: 35,563 found, (first ten):\n(11981443, 11981587), (18687587, 18687731), (20024339, 20024483), (20388583, 20388727), (21782503, 21782647)\n(25507423, 25507567), (27010003, 27010147), (28716287, 28716431), (31515413, 31515557), (32817493, 32817637)\n\nGap 196: 1,254 found, (first ten):\n(70396393, 70396589), (191186251, 191186447), (208744777, 208744973), (233987851, 233988047), (288568771, 288568967)\n(319183093, 319183289), (336075937, 336076133), (339408151, 339408347), (345247753, 345247949), (362956201, 362956397)\n\nGap 256: 41 found, (first ten):\n(1872851947, 1872852203), (2362150363, 2362150619), (2394261637, 2394261893), (2880755131, 2880755387), (2891509333, 2891509589)\n(3353981623, 3353981879), (3512569873, 3512570129), (3727051753, 3727052009), (3847458487, 3847458743), (4008610423, 4008610679)\n```"}]}
{"messages": [{"role": "user", "content": "As described on the **Chess960** page, Chess960 (a.k.a Fischer Random Chess, Chess9LX) is a variant of chess where the array of pieces behind the pawns is randomized at the start of the game to minimize the value of opening theory \"book knowledge\". That task is to generate legal starting positions, and some of the solutions accept a standard Starting Position Identifier number (\"SP-ID\"), and generate the corresponding position.\n\nTask\n\nThis task is to go the other way: given a starting array of pieces (provided in any form that suits your implementation, whether string or list or array, of letters or Unicode chess symbols or enum values, etc.), derive its unique SP-ID. For example, given the starting array **QNRBBNKR** (or **♕♘♖♗♗♘♔♖** or **♛♞♜♝♝♞♚♜**), which we assume is given as seen from White's side of the board from left to right, your (sub)program should return 105; given the starting lineup of standard chess, it should return 518.\n\nYou may assume the input is a valid Chess960 position; detecting invalid input (including illegal characters or starting arrays with the bishops on the same color square or the king not between the two rooks) is optional.\n\nAlgorithm\n\nThe derivation is the inverse of the algorithm given at Wikipedia, and goes like this (we'll use the standard chess setup as an example).\n\n1. Ignoring the Queen and Bishops, find the positions of the Knights within the remaining five spaces (in the standard array they're in the second and fourth positions), and then find the index number of that combination. There's a table at the above Wikipedia article, but it's just the possible positions sorted left to right and numbered 0 to 9: 0=**NN---**, 1=**N-N--**, 2=**N--N-**, 3=**N---N**, 4=**-NN--**, etc; our pair is combination number 5. Call this number N. **N=5**\n\n2. Still ignoring the Bishops, find the position of the Queen in the remaining 6 spaces; number them 0..5 from left to right and call the index of the Queen's position Q. In our example, **Q=2**.\n\n3. Finally, find the positions of the two bishops within their respective sets of four like-colored squares. It's important to note here that the board in chess is placed such that the leftmost position on the home row is on a dark square and the rightmost a light. So if we number the squares of each color 0..3 from left to right, the dark bishop in the standard position is on square 1 (**D=1**), and the light bishop is on square 2 (**L=2**).\n\n4. Then the position number is given by **4(4(6N + Q)+D)+L**, which reduces to **96N + 16Q + 4D + L**. In our example, that's 96×5 + 16×2 + 4×1 + 2 = 480 + 32 + 4 + 2 = 518.\n\nNote that an earlier iteration of this page contained an incorrect description of the algorithm which would give the same SP-ID for both of the following two positions.\n\n```\n   RQNBBKRN = 601\n   RNQBBKRN = 617\n\n```"}, {"role": "assistant", "content": "```\nsub c960-spid($array) {\n    # standardize on letters for easier processing\n    my $ascii = $array.trans('♜♞♝♛♚♖♘♗♕♔' => 'RNBQK');\n\n    # error-checking\n    my %Names = <Q Queen K King R Rook N Knight B Bishop>;\n    return 'Illegal position: should have exactly eight pieces' unless 8 == $ascii.chars;\n    return 'Illegal position: Bishops not on opposite colors.'  unless 1 == sum $ascii.indices('B').map(* % 2);\n    return 'Illegal position: King not between rooks.'          unless $ascii ~~ /'R' .* 'K' .* 'R'/;\n    for <K 1 Q 1 B 2 N 2 R 2> -> $piece, $count {\n        return \"Illegal position: should have exactly $count %Names{$piece}\\(s\\)\\n\" unless $count == $ascii.indices($piece)\n    }\n\n    # Work backwards through the placement rules.\n    # King and rooks are forced during placement, so ignore them. \n\n    # 1. Figure out which knight combination was used:\n    my @knights = $ascii.subst(/<[QB]>/, '', :g).indices('N');\n    my $knight = combinations(5,2).kv.grep( -> $i, @c { @c eq @knights } ).flat.first;\n\n    # 2. Then which queen position:\n    my $queen = $ascii.subst('B', '', :g).index('Q'); \n\n    # 3. Finally the two bishops:\n    my @bishops = $ascii.indices('B');\n    my ($dark,$light) = (@bishops.first %% 2 ?? @bishops !! @bishops.reverse) Xdiv 2;\n\n    $ascii.trans('RNBQK' => '♖♘♗♕♔') ~ ' ' ~ 4 × (4 × (6 × $knight + $queen) + $dark) + $light;\n}\n\nsay .&c960-spid for <♖♘♗♕♔♗♘♖ ♛♞♜♝♝♞♚♜ RQNBBKRN RNQBBKRN QNBRBNKR>;\n\n```\n\nOutput:\n\n```\n♖♘♗♕♔♗♘♖ 518\n♕♘♖♗♗♘♔♖ 105\n♖♕♘♗♗♔♖♘ 601\n♖♘♕♗♗♔♖♘ 617\nIllegal position: Bishops not on opposite colors.\n```"}]}
{"messages": [{"role": "user", "content": "Create a routine that, given a set of strings representing directory paths and a single character directory separator, will return a string representing that part of the directory tree that is common to all the directories.\n\nTest your routine using the forward slash '/' character as the directory separator and the following three strings as input paths:\n\n```\n     '/home/user1/tmp/coverage/test'\n     '/home/user1/tmp/covert/operator'\n     '/home/user1/tmp/coven/members'\n\n```\n\nNote: The resultant path should be the valid directory `'/home/user1/tmp'` and not the longest common string `'/home/user1/tmp/cove'`.\n\nIf your language has a routine that performs this function (even if it does not have a changeable separator character), then mention it as part of the task.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $sep = '/';\nmy @dirs = </home/user1/tmp/coverage/test\n            /home/user1/tmp/covert/operator\n            /home/user1/tmp/coven/members>;\n\nmy @comps = @dirs.map: { [ .comb(/ $sep [ <!before $sep> . ]* /) ] }; \n\nmy $prefix = '';\n\nwhile all(@comps[*]»[0]) eq @comps[0][0] {\n    $prefix ~= @comps[0][0] // last;\n    @comps».shift;\n}\n\nsay \"The longest common path is $prefix\";\n\n```\n\nOutput:\n\n```\nThe longest common path is /home/user1/tmp\n\n```\n\nIf you'd prefer a pure FP solution without side effects, you can use this:\n\n```\nmy $sep := '/';\nmy @dirs := </home/user1/tmp/coverage/test\n             /home/user1/tmp/covert/operator\n             /home/user1/tmp/coven/members>;\n\nmy @comps = @dirs.map: { [ .comb(/ $sep [ <!before $sep> . ]* /) ] };\n\nsay \"The longest common path is \",\n    gather for 0..* -> $column {\n        last unless all(@comps[*]»[$column]) eq @comps[0][$column];\n        take @comps[0][$column] // last;\n    }\n\n```\n\nOr here's another factoring, that focuses on building the result with cumulative sequences and getting the solution with `first`:\n\n```\nmy $sep = '/';\nmy @dirs = </home/user1/tmp/coverage/test\n            /home/user1/tmp/covert/operator\n            /home/user1/tmp/coven/members>;\n\nsub is_common_prefix { so $^prefix eq all(@dirs).substr(0, $prefix.chars) }\n\nsay ([\\~] @dirs.comb(/ $sep [ <!before $sep> . ]* /)).reverse.first: &is_common_prefix\n\n```"}]}
{"messages": [{"role": "user", "content": "In a large directory structure it is easy to inadvertently leave unnecessary copies of files around, which can use considerable disk space and create confusion.\n\nTask\n\nCreate a program which, given a minimum size and a folder/directory, will find all files of at least *size* bytes with duplicate contents under the directory and output or show the sets of duplicate files in order of decreasing size.\n\nThe program may be command-line or graphical, and duplicate content may be determined by direct comparison or by calculating a hash of the data.\n\nSpecify which filesystems or operating systems your program works with if it has any filesystem- or OS-specific requirements.\n\nIdentify hard links (filenames referencing the same content) in the output if applicable for the filesystem.\n\nFor extra points, detect when whole directory sub-trees are identical, or optionally remove or link identical files."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis implementation takes a starting directory (defaults to the current directory) and has a few flags to set behaviour: --minsize, minimum file size to look at, defaults to 5 bytes; and --recurse, recurse into the directory structure, default True. It finds files of the same size, calculates hashes to compare, then reports files that hash the same.\n\n```\nuse Digest::SHA256::Native;\n\nsub MAIN( $dir = '.', :$minsize = 5, :$recurse = True ) {\n    my %files;\n    my @dirs = $dir.IO.absolute.IO;\n    while @dirs {\n        my @files = @dirs.pop;\n        while @files {\n            for @files.pop.dir -> $path {\n                %files{ $path.s }.push: $path if $path.f and $path.s >= $minsize;\n                @dirs.push: $path if $path.d and $path.r and $recurse\n            }\n        }\n    }\n\n    for %files.sort( +*.key ).grep( *.value.elems > 1)».kv -> ($size, @list) {\n        my %dups;\n        @list.map: { %dups{ sha256-hex( ($_.slurp :bin).decode ) }.push: $_.Str };\n        for %dups.grep( *.value.elems > 1)».value -> @dups {\n            say sprintf(\"%9s : \", scale $size ),  @dups.join(', ');\n        }\n    }\n}\n\nsub scale ($bytes) {\n    given $bytes {\n        when $_ < 2**10 {  $bytes                    ~ ' B'  }\n        when $_ < 2**20 { ($bytes / 2**10).round(.1) ~ ' KB' }\n        when $_ < 2**30 { ($bytes / 2**20).round(.1) ~ ' MB' }\n        default         { ($bytes / 2**30).round(.1) ~ ' GB' }\n    }\n}\n\n```\n\nSample output:\n\nPassing in command line switches: --minsize=0 --recurse=False /home/me/p6\n\n```\n     0 B : /home/me/p6/vor.ppm, /home/me/p6/ns.txt\n   190 B : /home/me/p6/scrub(copy).t, /home/me/p6/scrub.t\n  1.3 KB : /home/me/p6/coco.p6, /home/me/p6/coc.p6\n 80.5 KB : /home/me/p6/temp.txt, /home/me/p6/temp.html\n279.6 KB : /home/me/p6/pentaflake.svg, /home/me/p6/5nflake.svg\n```"}]}
{"messages": [{"role": "user", "content": "*Clarification: This task is asking for the position of two bits in the binary representation of a positive integer. Some parts of this task assume that this is the native representation in the language you are working in. Any part of this task which makes assumptions about native representation should be treated as a recommendation which is only relevant in some contexts. A bit is defined as the exponent in a binary polynomial -- an exponent corresponding to a power of 2 which has a non-zero multiplier in the summation sequence of powers of two which yields the desired positive integer, where the only allowed coefficients are 0 and 1.*\n\nDefine routines (or operators) **lwb** and **upb** that find the *first* and *last* set bit in a binary value. Implement using a binary search to find the location of the particular upper/lower bit.\n\nAlso: Define the reverse routines (or operators) **rlwb** and **rupb** that find host's *positive integers* least- and most-significant set bit in a binary value expressed in LSB 0 bit numbering, i.e. indexed from the extreme right bit.\n\nUse primarily **bit** operations, such as **and**, **or**, and bit shifting. Avoid additions, multiplications and especially avoid divisions.\n\nTwo implementations\n\n1. For the host word size on the host platform, implement the routine \"efficiently\" in without looping or recursion.\n2. For the extended precision/long word implement the algorithm more generally - maybe as a template, and maybe with looping - so that any *bits width* for a binary type can be accommodated.\n\nTest cases\n\n1. For the host machine word size: Use the powers of 42 up to host's the \"natural\" word size to calculate the index of the first and last set bit.\n2. For the extended precision: Use the powers of 1302 up to the host's next \"natural\" **long** host *word* size to calculate the index of the first and last set bit.\n3. Output bit indexes in LSB 0 bit numbering.\n\nAdditionally\n\nIn a particular language, there maybe (at least) two alternative approaches of calculating the required values:\n\n* Using an external library.\n* Using a built-in library.\n\nIf any of these approaches are available, then *also* note the library or built-in name.\n\nSee also\n\n* Find the log base 2 of an N-bit integer in O(lg(N)) operations\n* 80386 Instruction Set - BSF -- Bit Scan Forward"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku integers are arbitrary sized, and the lsb and msb methods are built-in.\n\n```\nsub table ($base,$power) {\n    my $digits = ($base ** $power).chars;\n    printf \"%{$digits}s  lsb msb\\n\", 'number';\n    for 0..$power {\n\tmy $x = $base ** $_;\n\tprintf \"%{$digits}d  %2d  %2d\\n\", $x, $x.lsb, $x.msb;\n    }\n}\n\ntable 42, 20;\ntable 1302, 20;\n\n```\n\nOutput:\n\n```\n                           number  lsb msb\n                                1   0   0\n                               42   1   5\n                             1764   2  10\n                            74088   3  16\n                          3111696   4  21\n                        130691232   5  26\n                       5489031744   6  32\n                     230539333248   7  37\n                    9682651996416   8  43\n                  406671383849472   9  48\n                17080198121677824  10  53\n               717368321110468608  11  59\n             30129469486639681536  12  64\n           1265437718438866624512  13  70\n          53148384174432398229504  14  75\n        2232232135326160725639168  15  80\n       93753749683698750476845056  16  86\n     3937657486715347520027492352  17  91\n   165381614442044595841154678784  18  97\n  6946027806565873025328496508928  19  102\n291733167875766667063796853374976  20  107\n                                                         number  lsb msb\n                                                              1   0   0\n                                                           1302   1  10\n                                                        1695204   2  20\n                                                     2207155608   3  31\n                                                  2873716601616   4  41\n                                               3741579015304032   5  51\n                                            4871535877925849664   6  62\n                                         6342739713059456262528   7  72\n                                      8258247106403412053811456   8  82\n                                  10752237732537242494062515712   9  93\n                               13999413527763489727269395457024  10  103\n                            18227236413148063624904752885045248  11  113\n                         23731861809918778839625988256328912896  12  124\n                      30898884076514250049193036709740244590592  13  134\n                   40230347067621553564049333796081798456950784  14  144\n                52379911882043262740392232602498501590949920768  15  155\n             68198645270420328087990686848453049071416796839936  16  165\n          88794636142087267170563874276685869890984669485596672  17  175\n      115610616256997621856074164308245002598062039670246866944  18  186\n   150525022366610903656608561929334993382676775650661420761088  19  196\n195983579121327396560904347631994161384245161897161169830936576  20  206\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a list of integer arrays **nums** (which may be unsorted), find the smallest missing positive integer in each array in the list.\n\nA missing positive integer is any positive integer, starting from 1, which is not present in the array.\n\nExample\n\n* **nums**  =   [1,2,0], [3,4,-1,1], [7,8,9,11,12]\n* **output** =   3, 2, 1"}, {"role": "assistant", "content": "```\nsay $_, \" ==> \", (1..Inf).first( -> \\n { n ∉ $_ } ) for\n[ 1, 2, 0], [3, 4, 1, 1], [7, 8, 9, 11, 12], [1, 2, 3, 4, 5], [-6, -5, -2, -1], [5, -5], [-2], [1], []\n\n```\n\nOutput:\n\n```\n[1 2 0] ==> 3\n[3 4 1 1] ==> 2\n[7 8 9 11 12] ==> 1\n[1 2 3 4 5] ==> 6\n[-6 -5 -2 -1] ==> 1\n[5 -5] ==> 1\n[-2] ==> 1\n[1] ==> 2\n[] ==> 1\n```"}]}
{"messages": [{"role": "user", "content": "Find if a point is within a triangle.\n\nTask\n\n:   :   * Assume points are on a plane defined by (x, y) real number coordinates.\n\n:   :   * Given a point P(x, y) and a triangle formed by points A, B, and C, determine if P is within triangle ABC.\n\n:   :   * You may use any algorithm.\n\n:   :   * Bonus: explain why the algorithm you chose works.\n\nRelated tasks\n\n* Determine\\_if\\_two\\_triangles\\_overlap\n\nAlso see\n:   * Discussion of several methods. [[1]]\n    * Determine if a point is in a polygon [[2]]\n    * Triangle based coordinate systems [[3]]\n    * Wolfram entry [[4]]"}, {"role": "assistant", "content": "Reusing code from the Convex hull task and some logic from the Determine if two triangles overlap task.\n\n```\nclass Point {\n    has Real $.x is rw;\n    has Real $.y is rw;\n    method gist { [~] '(', self.x,', ', self.y, ')' };\n}\n\nsub sign (Point $a, Point $b, Point $c) {\n    ($b.x - $a.x)*($c.y - $a.y) - ($b.y - $a.y)*($c.x - $a.x);\n}\n\nsub triangle (*@points where *.elems == 6) {\n    @points.batch(2).map: { Point.new(:x(.[0]),:y(.[1])) };\n}\n\nsub is-within ($point, @triangle is copy) {\n   my @signs = sign($point, |(@triangle.=rotate)[0,1]) xx 3;\n   so (all(@signs) >= 0) or so(all(@signs) <= 0);\n}\n\nmy @triangle = triangle((1.5, 2.4), (5.1, -3.1), (-3.8, 0.5));\n\nfor Point.new(:x(0),:y(0)),\n    Point.new(:x(0),:y(1)),\n    Point.new(:x(3),:y(1))\n  -> $point {\n    say \"Point {$point.gist} is within triangle {join ', ', @triangle».gist}: \",\n        $point.&is-within: @triangle\n}\n\n```\n\nOutput:\n\n```\nPoint (0, 0) is within triangle (1.5, 2.4), (5.1, -3.1), (-3.8, 0.5): True\nPoint (0, 1) is within triangle (1.5, 2.4), (5.1, -3.1), (-3.8, 0.5): True\nPoint (3, 1) is within triangle (1.5, 2.4), (5.1, -3.1), (-3.8, 0.5): False\n```"}]}
{"messages": [{"role": "user", "content": "A truncatable prime is one where all non-empty substrings that finish at the end of the number (right-substrings) are also primes *when understood as numbers in a particular base*. The largest such prime in a given (integer) base is therefore computable, provided the base is larger than 2.\n\nLet's consider what happens in base 10. Obviously the right most digit must be prime, so in base 10 candidates are 2,3,5,7. Putting a digit in the range 1 to base-1 in front of each candidate must result in a prime. So 2 and 5, like the whale and the petunias in *The Hitchhiker's Guide to the Galaxy*, come into existence only to be extinguished before they have time to realize it, because 2 and 5 preceded by any digit in the range 1 to base-1 is not prime. Some numbers formed by preceding 3 or 7 by a digit in the range 1 to base-1 are prime. So 13,17,23,37,43,47,53,67,73,83,97 are candidates. Again, putting a digit in the range 1 to base-1 in front of each candidate must be a prime. Repeating until there are no larger candidates finds the largest left truncatable prime.\n\nLet's work base 3 by hand:\n\n0 and 1 are not prime so the last digit must be 2. 123 = 510 which is prime, 223 = 810 which is not so 123 is the only candidate. 1123 = 1410 which is not prime, 2123 = 2310 which is, so 2123 is the only candidate. 12123 = 5010 which is not prime, 22123 = 7710 which also is not prime. So there are no more candidates, therefore 23 is the largest left truncatable prime in base 3.\n\nThe task is to reconstruct as much, and possibly more, of the table in the OEIS as you are able.\n\nRelated Tasks:\n\n* Miller-Rabin primality test"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nPretty fast for bases 3 .. 11. 12 is slow. 18 is glacial.\n\n```\nuse ntheory:from<Perl5> <is_prime>;\n\nfor 3 .. 11 -> $base {\n    say \"Starting base $base...\";\n    my @stems = grep { .is-prime }, ^$base;\n    for 1 .. * -> $digits {\n        print ' ', @stems.elems;\n        my @new;\n        my $place = $base ** $digits;\n        for 1 ..^ $base -> $digit {\n            my $left = $digit * $place;\n            @new.append: (@stems »+» $left).grep: { is_prime(\"$_\") }\n        }\n        last unless +@new;\n        @stems = @new;\n    }\n    say \"\\nLargest ltp in base $base = {@stems.max} or :$base\\<@stems.max.base($base)}>\\n\";\n}\n\n```\n\nOutput:\n\n```\nStarting base 3...\n 1 1 1\nLargest ltp in base 3 = 23 or :3<212>\n\nStarting base 4...\n 2 2 3 3 3 3\nLargest ltp in base 4 = 4091 or :4<333323>\n\nStarting base 5...\n 2 4 4 3 1 1\nLargest ltp in base 5 = 7817 or :5<222232>\n\nStarting base 6...\n 3 4 12 25 44 54 60 62 59 51 35 20 12 7 3 2 1\nLargest ltp in base 6 = 4836525320399 or :6<14141511414451435>\n\nStarting base 7...\n 3 6 6 4 1 1 1\nLargest ltp in base 7 = 817337 or :7<6642623>\n\nStarting base 8...\n 4 12 29 50 66 77 61 51 38 27 17 8 3 2 1\nLargest ltp in base 8 = 14005650767869 or :8<313636165537775>\n\nStarting base 9...\n 4 9 15 17 24 16 9 6 5 3\nLargest ltp in base 9 = 1676456897 or :9<4284484465>\n\nStarting base 10...\n 4 11 39 99 192 326 429 521 545 517 448 354 276 212 117 72 42 24 13 6 5 4 3 1\nLargest ltp in base 10 = 357686312646216567629137 or :10<357686312646216567629137>\n\nStarting base 11...\n 4 8 15 18 15 8 4 2 1\nLargest ltp in base 11 = 2276005673 or :11<A68822827>\n\nStarting base 12...\n 5 23 119 409 1124 2496 4733 7711 11231 14826 17341 18787 19001 17567 15169 12085 9272 6606 4451 2882 1796 1108 601 346 181 103 49 19 8 2 1 1\nLargest ltp in base 12 = 13092430647736190817303130065827539 or :12<471A34A164259BA16B324AB8A32B7817>\n\nStarting base 13...\n 5 13 20 23 17 11 7 4\nLargest ltp in base 13 = 812751503 or :13<CC4C8C65>\n\nStarting base 14...\n 6 26 101 300 678 1299 2093 3017 3751 4196 4197 3823 3206 2549 1908 1269 783 507 322 163 97 55 27 13 5 2\nLargest ltp in base 14 = 615419590422100474355767356763 or :14<D967CCD63388522619883A7D23>\n\nStarting base 15...\n 6 22 79 207 391 644 934 1177 1275 1167 1039 816 608 424 261 142 74 45 25 13 7 1\nLargest ltp in base 15 = 34068645705927662447286191 or :15<6C6C2CE2CEEEA4826E642B>\n\nStarting base 16...\n 6 31 124 337 749 1292 1973 2695 3210 3490 3335 2980 2525 1840 1278 878 556 326 174 93 50 25 9 5 1\nLargest ltp in base 16 = 1088303707153521644968345559987 or :16<DBC7FBA24FE6AEC462ABF63B3>\n\nStarting base 17...\n 6 22 43 55 74 58 41 31 23 8 1\nLargest ltp in base 17 = 13563641583101 or :17<6C66CC4CC83>\n...\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind the limit of recursion."}, {"role": "assistant", "content": "(formerly Perl 6)\nMaximum recursion depth is memory dependent. Values in excess of 1 million are easily achieved.\n\n**Works with**: Rakudo version 2015.12\n\n```\nmy $x = 0;\nrecurse;\n\nsub recurse () {\n   ++$x;\n   say $x if $x %% 1_000_000;   \n   recurse;\n}\n```\n\nOutput:\n\nWhen manually terminated memory use was on the order of 4Gb:\n\n```\n1000000\n2000000\n3000000\n4000000\n5000000\n6000000\n7000000\n8000000\n9000000\n10000000\n^C\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show here on this page the minimum number of coins that can make a value of   **988.**\n\nAvailable coins are:   **1,   2,   5,   10,   20,   50,   100,**   and   **200.**\n\nThe coins that would be dispensed are:\n\n```\n     four coins of 200\n      one coin  of 100\n      one coin  of  50 \n      one coin  of  20\n      one coin  of  10 \n      one coin  of   5 \n      one coin  of   2\n      one coin  of   1\n\n```"}, {"role": "assistant", "content": "Since unit denominations are possible, don't bother to check to see if an exact pay-out isn't possible.\n\n```\nmy @denominations = 200, 100, 50, 20, 10, 5, 2, 1;\n\nsub change (Int $n is copy where * >= 0) { gather for @denominations { take $n div $_; $n %= $_ } }\n\nfor 988, 1307, 37511, 0 -> $amount {\n    say \"\\n$amount:\";\n    printf \"%d × %d\\n\", |$_ for $amount.&change Z @denominations;\n}\n\n```\n\nOutput:\n\n```\n988:\n4 × 200\n1 × 100\n1 × 50\n1 × 20\n1 × 10\n1 × 5\n1 × 2\n1 × 1\n\n1307:\n6 × 200\n1 × 100\n0 × 50\n0 × 20\n0 × 10\n1 × 5\n1 × 2\n0 × 1\n\n37511:\n187 × 200\n1 × 100\n0 × 50\n0 × 20\n1 × 10\n0 × 5\n0 × 2\n1 × 1\n\n0:\n0 × 200\n0 × 100\n0 × 50\n0 × 20\n0 × 10\n0 × 5\n0 × 2\n0 × 1\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n* Find and show (in decimal) the first six numbers (non-negative integers) that are   palindromes   in   *both*:\n\n:   :   :   * base 2\n            * base 3\n\n* Display   **0**   (zero) as the first number found, even though some other definitions ignore it.\n* Optionally, show the decimal number found in its binary and ternary form.\n* Show all output here.\n\nIt's permissible to assume the first two numbers and simply list them.\n\nSee also\n\n* Sequence A60792,   numbers that are palindromic in bases 2 and 3 on *The On-Line Encyclopedia of Integer Sequences*."}, {"role": "assistant", "content": "(formerly Perl 6)\nInstead of searching for numbers that are palindromes in one base then checking the other, generate palindromic trinary numbers directly, then check to see if they are also binary palindromes (with additional simplifying constraints as noted in other entries). Outputs the list in decimal, binary and trinary.\n\n```\nconstant palindromes = 0, 1, |gather for 1 .. * -> $p {\n    my $pal = $p.base(3);\n    my $n = :3($pal ~ '1' ~ $pal.flip);\n    next if $n %% 2;\n    my $b2 = $n.base(2);\n    next if $b2.chars %% 2;\n    next unless $b2 eq $b2.flip;\n    take $n;\n}\n\nprintf \"%d, %s, %s\\n\", $_, .base(2), .base(3) for palindromes[^6];\n\n```\n\nOutput:\n\n```\n0, 0, 0\n1, 1, 1\n6643, 1100111110011, 100010001\n1422773, 101011011010110110101, 2200021200022\n5415589, 10100101010001010100101, 101012010210101\n90396755477, 1010100001100000100010000011000010101, 22122022220102222022122\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind prime   **n**     for   **0 < n < 500**     which are also primes when the (decimal) digits are reversed.\n  \nNearly Emirp Primes, which don't count palindromatic primes like 101."}, {"role": "assistant", "content": "```\nunit sub MAIN ($limit = 500);\nsay \"{+$_} reversible primes < $limit:\\n{$_».fmt(\"%\" ~ $limit.chars ~ \"d\").batch(10).join(\"\\n\")}\",\n    with ^$limit .grep: { .is-prime and .flip.is-prime }\n\n```\n\nOutput:\n\n```\n34 reversible primes < 500:\n  2   3   5   7  11  13  17  31  37  71\n 73  79  97 101 107 113 131 149 151 157\n167 179 181 191 199 311 313 337 347 353\n359 373 383 389\n```"}]}
{"messages": [{"role": "user", "content": "Task\n:   Find prime numbers of the form    n*3*+2,   where 0 < n < 200"}, {"role": "assistant", "content": "```\n# 20210315 Raku programming solution\n\nsay ((1…199)»³ »+»2).grep: *.is-prime\n\n```\n\nOutput:\n\n```\n(3 29 127 24391 91127 250049 274627 328511 357913 571789 1157627 1442899 1860869 2146691 2924209 3581579 5000213 5177719 6751271)\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show on this page the least positive integer number **n**, where difference of **n\\*n** and **(n-1)\\*(n-1)** greater than **1000**.\n  \nThe result is **501** because **501\\*501 - 500\\*500 = 251001 - 250000 = 1001 > 1000**."}, {"role": "assistant", "content": "```\nsay first { $_² - ($_-1)² > 1000 }, ^Inf;\n\n```\n\nOutput:\n\n```\n501\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind squares **n** where **n+1** is prime and **n<1.000**"}, {"role": "assistant", "content": "Use up to to one thousand (1,000) rather than up to one (1.000) as otherwise it would be a pretty short list...\n\n```\nsay ({$++²}…^*>Ⅿ).grep: (*+1).is-prime\n\n```\n\nOutput:\n\n```\n(1 4 16 36 100 196 256 400 576 676)\n```\n\nAlthough, technically, there is absolutely nothing in the task directions specifying that **n** needs to be the square of an *integer*. So, more accurately...\n\n```\nput (^Ⅿ).grep(*.is-prime).map(*-1).batch(20)».fmt(\"%3d\").join: \"\\n\"\n\n```\n\nOutput:\n\n```\n  1   2   4   6  10  12  16  18  22  28  30  36  40  42  46  52  58  60  66  70\n 72  78  82  88  96 100 102 106 108 112 126 130 136 138 148 150 156 162 166 172\n178 180 190 192 196 198 210 222 226 228 232 238 240 250 256 262 268 270 276 280\n282 292 306 310 312 316 330 336 346 348 352 358 366 372 378 382 388 396 400 408\n418 420 430 432 438 442 448 456 460 462 466 478 486 490 498 502 508 520 522 540\n546 556 562 568 570 576 586 592 598 600 606 612 616 618 630 640 642 646 652 658\n660 672 676 682 690 700 708 718 726 732 738 742 750 756 760 768 772 786 796 808\n810 820 822 826 828 838 852 856 858 862 876 880 882 886 906 910 918 928 936 940\n946 952 966 970 976 982 990 996\n```"}]}
{"messages": [{"role": "user", "content": "Finding the intersection of an infinite ray with a plane in 3D is an important topic in collision detection.\n\nTask\n\nFind the point of intersection for the infinite ray with direction   (0, -1, -1)   passing through position   (0, 0, 10)   with the infinite plane with a normal vector of   (0, 0, 1)   and which passes through [0, 0, 5]."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.11\n\n**Translation of**: Python\n\n```\nclass Line {\n    has $.P0; # point\n    has $.u⃗;  # ray\n}\nclass Plane {\n    has $.V0; # point\n    has $.n⃗;  # normal\n}\n\nsub infix:<∙> ( @a, @b where +@a == +@b ) { [+] @a «*» @b } # dot product\n\nsub line-plane-intersection ($𝑳, $𝑷) {\n    my $cos = $𝑷.n⃗ ∙ $𝑳.u⃗; # cosine between normal & ray\n    return 'Vectors are orthogonal; no intersection or line within plane'\n      if $cos == 0;\n    my $𝑊 = $𝑳.P0 «-» $𝑷.V0;      # difference between P0 and V0\n    my $S𝐼 = -($𝑷.n⃗ ∙ $𝑊) / $cos;  # line segment where it intersects the plane\n    $𝑊 «+» $S𝐼 «*» $𝑳.u⃗ «+» $𝑷.V0; # point where line intersects the plane\n }\n\nsay 'Intersection at point: ', line-plane-intersection(\n     Line.new( :P0(0,0,10), :u⃗(0,-1,-1) ),\n    Plane.new( :V0(0,0, 5), :n⃗(0, 0, 1) )\n  );\n\n```\n\nOutput:\n\n```\nIntersection at point: (0 -5 5)\n```\n\n### With a geometric algebra library\n\nSee task geometric algebra\n\n```\nuse Clifford:ver<6.2.1>;\n\n# We pick a (non-degenerate) projective basis and\n# we define the dual and meet operators.\nmy $I = [∧] my ($i, $j, $k, $l) = @e;\nsub prefix:<∗>($M) { $M/$I }\nsub infix:<∨>($A, $B) { ∗((∗$B)∧(∗$A)) }\n\nmy $direction = -$j - $k;\n\n# Homogeneous coordinates of (X, Y, Z) are (X, Y, Z, 1)\nmy $point = 10*$k + $l;\n\n# A projective line is a bivector\nmy $line = $direction ∧ $point;\n\n# A projective plane is a trivector\nmy $plane = (5*$k + $l) ∧ ($k*-$i∧$j∧$k);\n\n# The intersection is the meet\nmy $m = $line ∨ $plane;\n\n# Affine coordinates of (X, Y, Z, W) are (X/W, Y/W, Z/W)\nsay $m/($m·$l) X· ($i, $j, $k);\n\n```\n\nOutput:\n\n```\n(0 -5 5)\n```"}]}
{"messages": [{"role": "user", "content": "Finding the intersection of two lines that are in the same plane is an important topic in collision detection.[1]\n\nTask\n\nFind the point of intersection of two lines in 2D.\n\nThe 1st line passes though    (4,0)    and    (6,10) .\n  \nThe 2nd line passes though    (0,3)    and    (10,7) ."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.11\n\n**Translation of**: zkl\n\n```\nsub intersection (Real $ax, Real $ay, Real $bx, Real $by,\n                  Real $cx, Real $cy, Real $dx, Real $dy ) {\n\n    sub term:<|AB|> { determinate($ax, $ay, $bx, $by) }\n    sub term:<|CD|> { determinate($cx, $cy, $dx, $dy) }\n\n    my $ΔxAB = $ax - $bx;\n    my $ΔyAB = $ay - $by;\n    my $ΔxCD = $cx - $dx;\n    my $ΔyCD = $cy - $dy;\n\n    my $x-numerator = determinate( |AB|, $ΔxAB, |CD|, $ΔxCD );\n    my $y-numerator = determinate( |AB|, $ΔyAB, |CD|, $ΔyCD );\n    my $denominator = determinate( $ΔxAB, $ΔyAB, $ΔxCD, $ΔyCD );\n\n    return 'Lines are parallel' if $denominator == 0;\n\n    ($x-numerator/$denominator, $y-numerator/$denominator);\n}\n\nsub determinate ( Real $a, Real $b, Real $c, Real $d ) { $a * $d - $b * $c }\n\n# TESTING\nsay 'Intersection point: ', intersection( 4,0, 6,10, 0,3, 10,7 );\nsay 'Intersection point: ', intersection( 4,0, 6,10, 0,3, 10,7.1 );\nsay 'Intersection point: ', intersection( 0,0, 1,1, 1,2, 4,5 );\n\n```\n\nOutput:\n\n```\nIntersection point: (5 5)\nIntersection point: (5.010893 5.054466)\nIntersection point: Lines are parallel\n\n```\n\n### Using a geometric algebra library\n\nSee task geometric algebra.\n\n```\nuse Clifford;\n\n# We pick a projective basis,\n# and we compute its pseudo-scalar and its square.\nmy ($i, $j, $k) = @e;\nmy $I = $i∧$j∧$k;\nmy $I2 = ($I**2).narrow;\n\n# Homogeneous coordinates of point (X,Y) are (X,Y,1)\nmy $A =  4*$i +  0*$j + $k;\nmy $B =  6*$i + 10*$j + $k;\nmy $C =  0*$i +  3*$j + $k;\nmy $D = 10*$i +  7*$j + $k;\n\n# We form lines by joining points\nmy $AB = $A∧$B;\nmy $CD = $C∧$D;\n\n# The intersection is their meet, which we\n# compute by using the De Morgan law\nmy $ab = $AB*$I/$I2;\nmy $cd = $CD*$I/$I2;\nmy $M = ($ab ∧ $cd)*$I/$I2;\n\n# Affine coordinates are (X/Z, Y/Z)\nsay $M/($M·$k) X· $i, $j;\n\n```\n\nOutput:\n\n```\n(5 5)\n```"}]}
{"messages": [{"role": "user", "content": "Write a program or a script that returns the last Sundays of each month of a given year. The year may be given through any simple input method in your language (command line, std in, etc).\n\nExample of an expected output:\n\n```\n./last_sundays 2013\n2013-01-27\n2013-02-24\n2013-03-31\n2013-04-28\n2013-05-26\n2013-06-30\n2013-07-28\n2013-08-25\n2013-09-29\n2013-10-27\n2013-11-24\n2013-12-29\n```\n\nRelated tasks\n\n* Day of the week\n* Five weekends\n* Last Friday of each month"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n```\nsub MAIN ($year = Date.today.year) {\n    for 1..12 -> $month {\n        my $month-end = Date.new($year, $month, Date.new($year,$month,1).days-in-month);\n        say $month-end - $month-end.day-of-week % 7;\n    }\n}\n\n```\n\nOutput  —  for input `2018`:\n\n```\n2018-01-28\n2018-02-25\n2018-03-25\n2018-04-29\n2018-05-27\n2018-06-24\n2018-07-29\n2018-08-26\n2018-09-30\n2018-10-28\n2018-11-25\n2018-12-30\n```"}]}
{"messages": [{"role": "user", "content": "```\n                    ABCD\n                    CABD\n                    ACDB\n                    DACB\n                    BCDA\n                    ACBD\n                    ADCB\n                    CDAB\n                    DABC\n                    BCAD\n                    CADB\n                    CDBA\n                    CBAD\n                    ABDC\n                    ADBC\n                    BDCA\n                    DCBA\n                    BACD\n                    BADC\n                    BDAC\n                    CBDA\n                    DBCA\n                    DCAB\n\n```\n\nListed above are   all-but-one   of the permutations of the symbols   **A**,   **B**,   **C**,   and   **D**,   *except*   for one permutation that's   *not*   listed.\n\nTask\n\nFind that missing permutation.\n\nMethods\n\n* Obvious method:\n\n```\n        enumerate all permutations of   A,  B,  C,  and  D,  \n        and then look for the missing permutation. \n\n```\n\n* alternate method:\n\n```\n        Hint:  if all permutations were shown above,  how many \n        times would  A  appear in each position?     \n        What is the  parity  of this number?\n\n```\n\n* another alternate method:\n\n```\n        Hint:  if you add up the letter values of each column, \n        does a missing letter   A,  B,  C,  and  D   from each\n        column cause the total value for each column to be unique?\n\n```\n\nRelated task\n\n* Permutations)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @givens = <ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA\n                CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB>;\n\nmy @perms = <A B C D>.permutations.map: *.join;\n\n.say when none(@givens) for @perms;\n\n```\n\nOutput:\n\n```\nDBAC\n```\n\nOf course, all of these solutions are working way too hard,\nwhen you can just xor all the bits,\nand the missing one will just pop right out:\n\n```\nsay [~^] <ABCD CABD ACDB DACB BCDA ACBD ADCB CDAB DABC BCAD CADB CDBA\n          CBAD ABDC ADBC BDCA DCBA BACD BADC BDAC CBDA DBCA DCAB>;\n\n```\n\nOutput:\n\n```\nDBAC\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function to search plain text for URIs or IRIs.\n\nThe function should return a list of URIs or IRIs found in the text.\n\nThe definition of a URI is given in RFC 3986.\nIRI is defined in RFC 3987.\n\nFor searching URIs in particular \"Appendix C. Delimiting a URI in Context\" is noteworthy.\n\nThe abbreviation IRI isn't as well known as URI and the short description is that an IRI is just an alternate form of a URI that supports Internationalization and hence Unicode. While many specifications support both forms this isn't universal.\n\nConsider the following issues:\n\n:   * `. , ; ' ? ( )`    are legal characters in a URI, but they are often used in plain text as a delimiter.\n    * IRIs allow most (but not all) unicode characters.\n    * URIs can be something else besides http:// or https://\n\nSample text\n\n```\n     this URI contains an illegal character, parentheses and a misplaced full stop:\n     http://en.wikipedia.org/wiki/Erich_Kästner_(camera_designer). (which is handled by http://mediawiki.org/).\n     and another one just to confuse the parser: http://en.wikipedia.org/wiki/-)\n     \")\" is handled the wrong way by the mediawiki parser.\n     ftp://domain.name/path(balanced_brackets)/foo.html\n     ftp://domain.name/path(balanced_brackets)/ending.in.dot.\n     ftp://domain.name/path(unbalanced_brackets/ending.in.dot.\n     leading junk ftp://domain.name/path/embedded?punct/uation.\n     leading junk ftp://domain.name/dangling_close_paren)\n     if you have other interesting URIs for testing, please add them here:  \n\n```\n\nRegular expressions to solve the task are fine, but alternative approaches are welcome too. (otherwise, this task would degrade into 'finding and applying the best regular expression')\n\n**Extra Credit:**   implement the parser to match the IRI specification in RFC 3987."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis needs an installed URI distribution.\n\n**Works with**: Rakudo version 2018.03\n\n```\nuse v6;\nuse IETF::RFC_Grammar::URI;\n\nsay q:to/EOF/.match(/ <IETF::RFC_Grammar::URI::absolute-URI> /, :g).list.join(\"\\n\");\n    this URI contains an illegal character, parentheses and a misplaced full stop:\n    http://en.wikipedia.org/wiki/Erich_Kästner_(camera_designer). (which is handled by http://mediawiki.org/).\n    and another one just to confuse the parser: http://en.wikipedia.org/wiki/-)\n    \")\" is handled the wrong way by the mediawiki parser.\n    ftp://domain.name/path(balanced_brackets)/foo.html\n    ftp://domain.name/path(balanced_brackets)/ending.in.dot.\n    ftp://domain.name/path(unbalanced_brackets/ending.in.dot.\n    leading junk ftp://domain.name/path/embedded?punct/uation.\n    leading junk ftp://domain.name/dangling_close_paren)\n    EOF\n\nsay $/[*-1];\nsay \"We matched $/[*-1], which is a $/[*-1].^name() at position $/[*-1].from() to $/[*-1].to()\"\n\n```\n\nLike most of the solutions here it does not comply to IRI but only to URI:\n\n```\nstop:\nhttp://en.wikipedia.org/wiki/Erich_K\nhttp://mediawiki.org/).\nparser:\nhttp://en.wikipedia.org/wiki/-)\nftp://domain.name/path(balanced_brackets)/foo.html\nftp://domain.name/path(balanced_brackets)/ending.in.dot.\nftp://domain.name/path(unbalanced_brackets/ending.in.dot.\nftp://domain.name/path/embedded\nftp://domain.name/dangling_close_paren)\n｢ftp://domain.name/dangling_close_paren)｣\n IETF::RFC_Grammar::URI::absolute_URI => ｢ftp://domain.name/dangling_close_paren)｣\n  scheme => ｢ftp｣\nWe matched ftp://domain.name/dangling_close_paren), which is a Match, at position 554 to 593\n```\n\nThe last lines show that we get Match objects back that we can query to get all kinds of information.\nWe even get the information what subrules matched, and since these are also Match objects we can obtain\ntheir match position in the text."}]}
{"messages": [{"role": "user", "content": "Task\n\nUse the dictionary  unixdict.txt\n\nFind the words which contains all the vowels,   but each vowel should appear only once in a word.\n\nThe length of any word shown should have a length   **>  10****.**\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "Yet another \"Filter a word list\" task.\n\n```\nput +.words, \" words found:\\n\", $_ with 'unixdict.txt'.IO.words\\\n  .grep({ .chars > 10 and all(.comb.Bag<a e i o u>) == 1 })\\\n  .batch(5)».fmt('%-13s').join: \"\\n\";\n\n```\n\nOutput:\n\n```\n25 words found:\nambidextrous  bimolecular   cauliflower   communicable  communicate  \nconsanguine   consultative  countervail   exclusionary  grandiloquent\nimportunate   incommutable  incomputable  insupportable loudspeaking \nmalnourished  mensuration   oneupmanship  pandemonium   permutation  \nperturbation  portraiture   praseodymium  stupefaction  sulfonamide \n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nUse the dictionary  unixdict.txt\n\nFind the words which contains most consonants,   but each consonant should appear only once in a word.\n\nThe length of any word shown should have a length   **>  10****.**\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "Hmm. Depends on how you define \"most\".\n\n```\nunit sub MAIN ($min = 11);\nmy @vowel = <a e i o u>;\nmy $vowel = rx/ @vowel /;\nmy @consonant = ('a'..'z').grep: { $_ ∉ @vowel };\nmy $consonant = rx/ @consonant /;\n\nsay \"Minimum characters in a word: $min\";\n\nsay \"Number found, consonant count and list of words with the largest absolute number of unique, unrepeated consonants:\";\nsay +.value, ' @ ', $_ for 'unixdict.txt'.IO.words.grep( {.chars >= $min and so all(.comb.Bag{@consonant}) <= 1} )\n    .classify( { +.comb(/$consonant/) } ).sort(-*.key).head(2);\n\nsay \"\\nNumber found, ratio and list of words with the highest ratio of unique, unrepeated consonants to vowels:\";\nsay +.value, ' @ ', $_  for 'unixdict.txt'.IO.slurp.words.grep( {.chars >= $min and so all(.comb.Bag{@consonant}) <= 1} )\n    .classify( { +.comb(/$vowel/) ?? (+.comb(/$consonant/) / +.comb(/$vowel/) ) !! Inf } ).sort(-*.key).head(3);\n\n```\n\nOutput:\n\n```\nMinimum characters in a word: 11\nNumber found, consonant count and list of words with the largest absolute number of unique, unrepeated consonants:\n1 @ 9 => [comprehensible]\n39 @ 8 => [administrable anthropology blameworthy bluestocking boustrophedon bricklaying chemisorption christendom claustrophobia compensatory comprehensive counterexample demonstrable disciplinary discriminable geochemistry hypertensive indecipherable indecomposable indiscoverable lexicography manslaughter misanthropic mockingbird monkeyflower neuropathology paralinguistic pharmacology pitchblende playwriting shipbuilding shortcoming springfield stenography stockholder switchblade switchboard switzerland thunderclap]\n\nNumber found, ratio and list of words with the highest ratio of unique, unrepeated consonants to vowels:\n14 @ 2.666667 => [blameworthy bricklaying christendom mockingbird pitchblende playwriting shortcoming springfield stenography stockholder switchblade switchboard switzerland thunderclap]\n13 @ 2 => [anthropology bluestocking compensatory demonstrable disciplinary geochemistry hypertensive lexicography manslaughter misanthropic monkeyflower pharmacology shipbuilding]\n1 @ 1.8 => [comprehensible]\n```\n\nCharacter count of 11 minimum is rather arbitrary. If we feed it a character count minimum of 5, the first one returns a pretty similar answer, 8 additional words at 8 consonants (all with 10 characters.)\n\nThe second would actually come up with some infinite ratios (since we somewhat bogusly don't count 'y' as a vowel.):\n\n```\nMinimum characters in a word: 5\nNumber found, consonant count and list of words with the largest absolute number of unique, unrepeated consonants:\n1 @ 9 => [comprehensible]\n47 @ 8 => [administrable anthropology bankruptcy blacksmith blameworthy bluestocking boustrophedon bricklaying chemisorption christendom claustrophobia compensatory comprehensive counterexample crankshaft demonstrable disciplinary discriminable geochemistry hypertensive indecipherable indecomposable indiscoverable lexicography lynchburg manslaughter misanthropic mockingbird monkeyflower neuropathology paralinguistic pharmacology pitchblende playwright playwriting shipbuilding shortcoming sprightly springfield stenography stockholder strickland stronghold switchblade switchboard switzerland thunderclap]\n\nNumber found, ratio and list of words with the highest ratio of unique, unrepeated consonants to vowels:\n6 @ Inf => [crypt glyph lymph lynch nymph psych]\n2 @ 8 => [lynchburg sprightly]\n5 @ 7 => [klystron mcknight schwartz skylight splotchy]\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nUse the dictionary   unixdict.txt\n\nFind words which contains more than three   **e**   vowels   *and*   contains only   **e**   vowels.\n\nShow the output here on this page.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "Hardly even worth saving as a script file; an easily entered one-liner.\n\n```\n.say for \"unixdict.txt\".IO.lines.grep: { !/<[aiou]>/ and /e.*e.*e.*e/ };\n\n```\n\nOutput:\n\n```\nbelvedere\ndereference\nelsewhere\nerlenmeyer\nevergreen\neverywhere\nexegete\nfreewheel\nnevertheless\npersevere\npreference\nreferee\nseventeen\nseventeenth\ntelemeter\ntennessee\n\n```\n\nIn an attempt to be a little less useless, here's an alternate script that allows you to specify a vowel, the minimum count to search for, and the file to search. Counts base vowels case, and combining accent insensitive; works with *any* text file, not just word lists. Defaults to finding words with at least 4 'e's in unixdict.txt. Default output is same as above.\n\n```\nunit sub MAIN ($vowel = 'e', $min = 4, $file = 'unixdict.txt');\n.say for squish sort\n  ( $file.IO.slurp.words.grep: { ((my $b = .lc.samemark(' ').comb.Bag){$vowel} >= $min) && $b<a e i o u>.sum == $b{$vowel} } )\\\n  ».subst(/<[\":;,.?!_\\[\\]]>/, '', :g);\n\n```\n\nHow about: find words with at least 4 'a's in the Les Misérables file used for the Word frequency task?\n\nCommand line `> raku monovowel a 4 lemiz.txt`\n\nOutput:\n\n```\nCaracalla\nCaracara\nSalamanca\nVâsaphantâ\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nUsing the dictionary  unixdict.txt\n  \n  \nfind the words whose first and last three letters are equal.\n\nThe length of any word shown should have a length   **>  5****.**\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\n# 20210210 Raku programming solution\n\nmy ( \\L, \\N, \\IN ) = 5, 3, 'unixdict.txt';\n\nfor IN.IO.lines { .say if .chars > L and .substr(0,N) eq .substr(*-N,*) }\n\n```\n\nOutput:\n\n```\nantiperspirant\ncalendrical\neinstein\nhotshot\nmurmur\noshkosh\ntartar\ntestes\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nUsing the dictionary   unixdict.txt,   find words which odd letters are consonants and even letters are vowels or vice versa.\n  \nDisplay the words here (on this page).\n\nThe length of any word shown should have a length   **> 9****.**\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "Sigh. Yet another \"Filter a word list\" task. In a effort to make it a *little* more interesting, rather than just doing a one-liner, build a grammar and use that to filter.\n\n```\ngrammar VOWCON {\n    token       TOP { <|w> <vowel>? ( <consonant> <vowel> )* <consonant>? <|w> }\n    token     vowel { <[aeiou]> }\n    token consonant { <[a..z] - [aeiou]> }\n}\n\nsay ( grep { VOWCON.parse: .lc }, grep { .chars > 9 }, 'unixdict.txt'.IO.words ).batch(6)».fmt('%-15s').join: \"\\n\";\n\n```\n\nOutput:\n\n```\naboriginal      apologetic      bimolecular     borosilicate    calorimeter     capacitate     \ncapacitive      capitoline      capitulate      caricature      colatitude      coloratura     \ncolorimeter     debilitate      decelerate      decolonize      definitive      degenerate     \ndeliberate      demodulate      denominate      denotative      deregulate      desiderata     \ndesideratum     dilapidate      diminutive      epigenetic      facilitate      hemosiderin    \nheretofore      hexadecimal     homogenate      inoperative     judicature      latitudinal    \nlegitimate      lepidolite      literature      locomotive      manipulate      metabolite     \nnicotinamide    oratorical      paragonite      pejorative      peridotite      peripatetic    \npolarimeter     recitative      recuperate      rehabilitate    rejuvenate      remunerate     \nrepetitive      reticulate      savonarola      similitude      solicitude      tananarive     \ntelekinesis     teratogenic     topologize      unilateral      unimodular      uninominal     \nverisimilitude\n```"}]}
{"messages": [{"role": "user", "content": "A Finite state machine (FSM) is computational abstraction which maps a finite number of states to other states within the same set, via transitions. An FSM can only be in one state at any given moment. Transitions can either be explicit or implicit; explicit transitions are triggered by an input signal and implicit transitions by the internal state of the system (that is, the current state). Implicit transitions thus represent \"automatic\" or sequenced states that are generally processed between explicit transitions (although they can also be used to provide an optional path when no valid transition exists for a given input signal).\n\nExample\n\nConsider the model of a simple vending machine. The machine is initially in the \"ready\" state, which maps to exactly two states in the following way:\n\n:   ready -> **deposit** -> waiting\n\n:   ready -> **quit** -> exit\n\nThe variables in bold-face represent transitions. Any input signal not corresponding to one of those transitions can either trigger an error or be ignored. Otherwise, the current state is updated and the process is repeated. If, for example, a **deposit** input signal is encountered, the FSM will move to the \"waiting\" state, which defines these transitions:\n\n:   waiting -> **select** -> dispense\n\n:   waiting -> **refund** -> refunding\n\nThe \"dispense\" state defines only one transition:\n\n:   dispense -> **remove** -> ready\n\nNote, however, that in this example the \"refunding\" state doesn't actually require input in order to move to the \"ready\" state, so an implicit transition is defined as such:\n\n:   refunding -> ready\n\nTask\n\nImplement a finite state machine which handles both explicit and implicit transitions. Then demonstrate an example which models some real-world process.\n\nSee also\n\n* Computers Without Memory (Finite State Automata), A Computerphile Video."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n#===== The state machine =====#\n\nclass StateMachine {\n    class State {...}\n    class Transition {...}\n\n    has State %!state;\n    has &.choose-transition is rw;\n\n    method add-state(Str $id, &action)\n    {\n        %!state{$id} = State.new(:$id, :&action);\n    }\n\n    multi method add-transition(Str $from, Str $to)\n    {\n        %!state{$from}.implicit-next = %!state{$to};\n    }\n\n    multi method add-transition(Str $from, $id, Str $to)\n    {\n        %!state{$from}.explicit-next.push: Transition.new(:$id, to => %!state{$to});\n    }\n\n    method run(Str $initial-state)\n    {\n        my $state = %!state{$initial-state};\n        \n        loop {\n            $state.action.();\n            if $state.implicit-next -> $_ { $state = $_; }\n            elsif $state.explicit-next -> $_ { $state = &.choose-transition.(|$_).to; }\n            else { last; }\n        }\n    }\n\n    class Transition {\n        has $.id;\n        has State $.to;\n    }\n    class State {\n        has $.id;\n        has &.action;\n        has State $.implicit-next is rw;\n        has Transition @.explicit-next;\n    }\n}\n\n\n#===== Usage example: Console-based vending machine =====#\n\nmy StateMachine $machine .= new;\n\n$machine.choose-transition = sub (*@transitions) {\n    say \"[{.key + 1}] {.value.id}\" for @transitions.pairs;\n    loop {\n        my $n = val get;\n        return @transitions[$n - 1] if $n ~~ Int && $n ~~ 1..@transitions;\n        say \"Invalid input; try again.\";\n    }\n}\n\n$machine.add-state(\"ready\",     { say \"Please deposit coins.\";                     });\n$machine.add-state(\"waiting\",   { say \"Please select a product.\";                  });\n$machine.add-state(\"dispense\",  { sleep 2; say \"Please remove product from tray.\"; });\n$machine.add-state(\"refunding\", { sleep 1; say \"Refunding money...\";               });\n$machine.add-state(\"exit\",      { say \"Shutting down...\";                          });\n\n$machine.add-transition(\"ready\",     \"quit\",    \"exit\");\n$machine.add-transition(\"ready\",     \"deposit\", \"waiting\");\n$machine.add-transition(\"waiting\",   \"select\",  \"dispense\");\n$machine.add-transition(\"waiting\",   \"refund\",  \"refunding\");\n$machine.add-transition(\"dispense\",  \"remove\",  \"ready\");\n$machine.add-transition(\"refunding\",            \"ready\");\n\n$machine.run(\"ready\");\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow on this page the first 9 prime Fibonacci numbers."}, {"role": "assistant", "content": "```\nput ++$ .fmt(\"%2d: \") ~ $_ for (0, 1, * + * … *).grep( &is-prime )[^20];\n\n```\n\nOutput:\n\n```\n 1: 2\n 2: 3\n 3: 5\n 4: 13\n 5: 89\n 6: 233\n 7: 1597\n 8: 28657\n 9: 514229\n10: 433494437\n11: 2971215073\n12: 99194853094755497\n13: 1066340417491710595814572169\n14: 19134702400093278081449423917\n15: 475420437734698220747368027166749382927701417016557193662268716376935476241\n16: 529892711006095621792039556787784670197112759029534506620905162834769955134424689676262369\n17: 1387277127804783827114186103186246392258450358171783690079918032136025225954602593712568353\n18: 3061719992484545030554313848083717208111285432353738497131674799321571238149015933442805665949\n19: 10597999265301490732599643671505003412515860435409421932560009680142974347195483140293254396195769876129909\n20: 36684474316080978061473613646275630451100586901195229815270242868417768061193560857904335017879540515228143777781065869\n```"}]}
{"messages": [{"role": "user", "content": "According to Wikipedia, \"In computing, a first-class object ... is an entity that can be constructed at run-time, passed as a parameter, returned from a subroutine, or assigned into a variable\".\n\nOften this term is used in the context of \"first class functions\". In an analogous way, a programming language may support \"first class environments\".\n\nThe environment is minimally, the set of variables accessible to a statement being executed. Change the environments and the same statement could produce different results when executed.\n\nOften an environment is captured in a closure, which encapsulates a function together with an environment. That environment, however, is **not** first-class, as it cannot be created, passed etc. independently from the function's code.\n\nTherefore, a first class environment is a set of variable bindings which can be constructed at run-time, passed as a parameter, returned from a subroutine, or assigned into a variable. It is like a closure without code. A statement must be able to be executed within a stored first class environment and act according to the environment variable values stored within.\n\nTask\n\nBuild a dozen environments, and a single piece of code to be run repeatedly in each of these environments.\n\nEach environment contains the bindings for two variables:\n\n:   * a value in the Hailstone sequence, and\n    * a count which is incremented until the value drops to 1.\n\nThe initial hailstone values are 1 through 12, and the count in each environment is zero.\n\nWhen the code runs, it calculates the next hailstone step in the current environment (unless the value is already 1) and counts the steps. Then it prints the current value in a tabular form.\n\nWhen all hailstone values dropped to 1, processing stops, and the total number of hailstone steps for each environment is printed."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nSet up an array of hashes containing the current values and iteration counts then pass each hash in turn with a code reference to a routine to calculate the next iteration.\n\n```\nmy $calculator = sub ($n is rw) {\n    $n == 1 ?? 1 !! $n %% 2 ?? $n div 2 !! $n * 3 + 1\n}\n\nsub next (%this, &get_next) {\n    return %this if %this.<value> == 1;\n    %this.<value> .= &get_next;\n    %this.<count>++;\n    %this;\n}\n\nmy @hailstones = map { %(value => $_, count => 0) }, 1 .. 12;\n\nwhile not all( map { $_.<value> }, @hailstones ) == 1 {\n    say [~] map { $_.<value>.fmt: '%4s' }, @hailstones;\n    @hailstones[$_] .= &next($calculator) for ^@hailstones;\n}\n\nsay \"\\nCounts\\n\" ~ [~] map { $_.<count>.fmt: '%4s' }, @hailstones;\n\n```\n\nOutput:\n\n```\n   1   2   3   4   5   6   7   8   9  10  11  12\n   1   1  10   2  16   3  22   4  28   5  34   6\n   1   1   5   1   8  10  11   2  14  16  17   3\n   1   1  16   1   4   5  34   1   7   8  52  10\n   1   1   8   1   2  16  17   1  22   4  26   5\n   1   1   4   1   1   8  52   1  11   2  13  16\n   1   1   2   1   1   4  26   1  34   1  40   8\n   1   1   1   1   1   2  13   1  17   1  20   4\n   1   1   1   1   1   1  40   1  52   1  10   2\n   1   1   1   1   1   1  20   1  26   1   5   1\n   1   1   1   1   1   1  10   1  13   1  16   1\n   1   1   1   1   1   1   5   1  40   1   8   1\n   1   1   1   1   1   1  16   1  20   1   4   1\n   1   1   1   1   1   1   8   1  10   1   2   1\n   1   1   1   1   1   1   4   1   5   1   1   1\n   1   1   1   1   1   1   2   1  16   1   1   1\n   1   1   1   1   1   1   1   1   8   1   1   1\n   1   1   1   1   1   1   1   1   4   1   1   1\n   1   1   1   1   1   1   1   1   2   1   1   1\nCounts\n   0   1   7   2   5   8  16   3  19   6  14   9\n```"}]}
{"messages": [{"role": "user", "content": "Find the first perfect square in a given base **N** that has at least **N** digits and\nexactly **N** *significant unique* digits when expressed in base **N**.\n\nE.G. In base **10**, the first perfect square with at least **10** unique digits is **1026753849** (**32043²**).\n\nYou may use analytical methods to reduce the search space, but the code must do a search. Do not use magic numbers or just feed the code the answer to verify it is correct.\n\nTask\n\n* Find and display here, on this page, the first perfect square in base **N**, with **N** significant unique digits when expressed in base **N**, for each of base **2** through **12**. Display each number in the base **N** for which it was calculated.\n\n* (optional) Do the same for bases **13** through **16**.\n\n* (stretch goal) Continue on for bases **17** - **??** (Big Integer math)\n\nSee also\n\n* OEIS A260182: smallest square that is pandigital in base n.\n\nRelated task\n\n* Casting out nines"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\nAs long as you have the patience, this will work for bases 2 through 36.\n\nBases 2 through 19 finish quickly, (about 10 seconds on my system), 20 takes a while, 21 is pretty fast, 22 is glacial. 23 through 26 takes several hours.\n\nUse analytical start value filtering based on observations by Hout++\nand Nigel Galloway++ on the\ndiscussion page.\n\nTry it online!\n\n```\n#`[\n\nOnly search square numbers that have at least N digits;\nsmaller could not possibly match.\n\nOnly bother to use analytics for large N. Finesse takes longer than brute force for small N.\n\n]\n\nunit sub MAIN ($timer = False);\n\nsub first-square (Int $n) {\n    my @start = flat '1', '0', (2 ..^ $n)».base: $n;\n\n    if $n > 10 { # analytics\n        my $root  = digital-root( @start.join, :base($n) );\n        my @roots = (2..$n).map(*²).map: { digital-root($_.base($n), :base($n) ) };\n        if $root ∉ @roots {\n            my $offset = min(@roots.grep: * > $root ) - $root;\n            @start[1+$offset] = $offset ~ @start[1+$offset];\n        }\n    }\n\n    my $start = @start.join.parse-base($n).sqrt.ceiling;\n    my @digits = reverse (^$n)».base: $n;\n    my $sq;\n    my $now  = now;\n    my $time = 0;\n    my $sr;\n    for $start .. * {\n        $sq = .²;\n        my $s = $sq.base($n);\n        my $f;\n        $f = 1 and last unless $s.contains: $_ for @digits;\n        if $timer && $n > 19 && $_ %% 1_000_000 {\n            $time += now - $now;\n            say \"N $n:  {$_}² = $sq <$s> : {(now - $now).round(.001)}s\" ~\n                \" : {$time.round(.001)} elapsed\";\n            $now = now;\n        }\n        next if $f;\n        $sr = $_;\n        last\n    }\n    sprintf( \"Base %2d: %13s² == %-30s\", $n, $sr.base($n), $sq.base($n) ) ~\n        ($timer ?? ($time + now - $now).round(.001) !! '');\n}\n\nsub digital-root ($root is copy, :$base = 10) {\n    $root = $root.comb.map({:36($_)}).sum.base($base) while $root.chars > 1;\n    $root.parse-base($base);\n}\n\nsay  \"First perfect square with N unique digits in base N: \";\nsay .&first-square for flat\n   2 .. 12, # required\n  13 .. 16, # optional\n  17 .. 19, # stretch\n  20, # slow\n  21, # pretty fast\n  22, # very slow\n  23, # don't hold your breath\n  24, # slow but not too terrible\n  25, # very slow\n  26, #   \"\n;\n\n```\n\nOutput:\n\n```\nFirst perfect square with N unique digits in base N:\nBase  2:            10² == 100\nBase  3:            22² == 2101\nBase  4:            33² == 3201\nBase  5:           243² == 132304\nBase  6:           523² == 452013\nBase  7:          1431² == 2450361\nBase  8:          3344² == 13675420\nBase  9:         11642² == 136802574\nBase 10:         32043² == 1026753849\nBase 11:        111453² == 1240A536789\nBase 12:        3966B9² == 124A7B538609\nBase 13:       3828943² == 10254773CA86B9\nBase 14:       3A9DB7C² == 10269B8C57D3A4\nBase 15:      1012B857² == 102597BACE836D4\nBase 16:      404A9D9B² == 1025648CFEA37BD9\nBase 17:     423F82GA9² == 101246A89CGFB357ED\nBase 18:     44B482CAD² == 10236B5F8EG4AD9CH7\nBase 19:    1011B55E9A² == 10234DHBG7CI8F6A9E5\nBase 20:    49DGIH5D3G² == 1024E7CDI3HB695FJA8G\nBase 21:   4C9HE5FE27F² == 1023457DG9HI8J6B6KCEAF\nBase 22:   4F94788GJ0F² == 102369FBGDEJ48CHI7LKA5\nBase 23:  1011D3EL56MC² == 10234ACEDKG9HM8FBJIL756\nBase 24:  4LJ0HDGF0HD3² == 102345B87HFECKJNIGMDLA69\nBase 25: 1011E145FHGHM² == 102345DOECKJ6GFB8LIAM7NH9\nBase 26: 52K8N53BDM99K² == 1023458LO6IEMKG79FPCHNJDBA\n```"}]}
{"messages": [{"role": "user", "content": "(This task is taken from a   *Project Euler*   problem.)\n\n(All numbers herein are expressed in base ten.)\n\n**27   =   128**   and   **7**   is\nthe first power of   **2**   whose leading decimal digits are   **12**.\n\nThe next power of   **2**   whose leading decimal digits\nare   **12**   is   **80**,\n  \n**280   =   1208925819614629174706176**.\n\nDefine      ***p*(*L,n*)**      to be the  ***n*th**-smallest\nvalue of    ***j***    such that the base ten representation\nof    **2*j***    begins with the digits of    ***L*** .\n\n```\n    So   p(12, 1) =  7    and\n         p(12, 2) = 80\n\n```\n\nYou are also given that:\n\n```\n         p(123, 45)   =   12710\n\n```\n\nTask\n:   :   * find:\n\n        :   :   :   * ***p*(12, 1)**\n                    * ***p*(12, 2)**\n                    * ***p*(123, 45)**\n                    * ***p*(123, 12345)**\n                    * ***p*(123, 678910)**\n\n        * display the results here, on this page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\nUses logs similar to Go and Pascal entries. Takes advantage of patterns in the powers to cut out a bunch of calculations.\n\n```\nuse Lingua::EN::Numbers;\n\nconstant $ln2ln10 = log(2) / log(10);\n\nmy @startswith12  = ^∞ .grep: { ( 10 ** ($_ * $ln2ln10 % 1) ).substr(0,3) eq '1.2' };\n\nmy @startswith123 = lazy gather loop {\n    state $pre   = '1.23';\n    state $count = 0;\n    state $this  = 0;\n    given $this {\n        when 196 {\n            $this = 289;\n            my \\n = $count + $this;\n            $this = 485 unless ( 10 ** (n * $ln2ln10 % 1) ).substr(0,4) eq $pre;\n        }\n        when 485 {\n            $this = 196;\n            my \\n = $count + $this;\n            $this = 485 unless ( 10 ** (n * $ln2ln10 % 1) ).substr(0,4) eq $pre;\n        }\n        when 289 { $this = 196 }\n        when 90  { $this = 289 }\n        when 0   { $this = 90  }\n    }\n    take $count += $this;\n}\n\nmulti p ($prefix where *.chars == 2, $nth) {  @startswith12[$nth-1] }\nmulti p ($prefix where *.chars == 3, $nth) { @startswith123[$nth-1] }\n\n# The Task\nfor < 12 1  12 2  123 45  123 12345  123 678910 > -> $prefix, $nth {\n    printf \"%-15s %9s power of two (2^n) that starts with %5s is at n = %s\\n\", \"p($prefix, $nth):\",\n        comma($nth) ~ ordinal-digit($nth).substr(*-2), \"'$prefix'\", comma p($prefix, $nth);\n}\n\n```\n\nOutput:\n\n```\np(12, 1):             1st power of two (2^n) that starts with  '12' is at n = 7\np(12, 2):             2nd power of two (2^n) that starts with  '12' is at n = 80\np(123, 45):          45th power of two (2^n) that starts with '123' is at n = 12,710\np(123, 12345):   12,345th power of two (2^n) that starts with '123' is at n = 3,510,491\np(123, 678910): 678,910th power of two (2^n) that starts with '123' is at n = 193,060,223\n```"}]}
{"messages": [{"role": "user", "content": "A language has first-class functions if it can do each of the following without recursively invoking a compiler or interpreter or otherwise metaprogramming:\n\n* Create new functions from preexisting functions at run-time\n* Store functions in collections\n* Use functions as arguments to other functions\n* Use functions as return values of other functions\n\nTask\n\nWrite a program to create an ordered collection *A* of functions of a real number. At least one function should be built-in and at least one should be user-defined; try using the sine, cosine, and cubing functions. Fill another collection *B* with the inverse of each function in *A*. Implement function composition as in Functional Composition. Finally, demonstrate that the result of applying the composition of each function in *A* and its inverse in *B* to a value, is the original value. (Within the limits of computational accuracy).\n\n(A solution need not actually call the collections \"A\" and \"B\". These names are only used in the preceding paragraph for clarity.)\n\nRelated task\n\nFirst-class Numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\nHere we use the Z (\"zipwith\") metaoperator to zip the 𝐴 and 𝐵 lists with builtin composition operator, ∘ (or just o). The .() construct invokes the function contained in the $\\_ (current topic) variable.\n\n```\nmy \\𝐴 = &sin,  &cos,  { $_ ** <3/1> }\nmy \\𝐵 = &asin, &acos, { $_ ** <1/3> }\n\nsay .(.5) for 𝐴 Z∘ 𝐵\n\n```\n\nOutput:\n\n```\n0.5\n0.4999999999999999\n0.5000000000000001\n\n```\n\nIt is not clear why we don't get exactly 0.5, here.\n\nOperators, both builtin and user-defined, are first class too.\n\n```\nmy @a = 1,2,3;\nmy @op = &infix:<+>, &infix:<->, &infix:<*>;\nfor flat @a Z @op -> $v, &op { say 42.&op($v) }\n\n```\n\nOutput:\n\n```\n43\n40\n126\n```"}]}
{"messages": [{"role": "user", "content": "In First-class functions, a language is showing how its manipulation of functions is similar to its manipulation of other types.\n\nThis tasks aim is to compare and contrast a language's implementation of first class functions, with its normal handling of numbers.\n\nWrite a program to create an ordered collection of a mixture of literally typed and expressions producing a real number, together with another ordered collection of their multiplicative inverses. Try and use the following pseudo-code to generate the numbers for the ordered collections:\n\n```\n  x  = 2.0\n  xi = 0.5\n  y  = 4.0\n  yi = 0.25\n  z  = x + y\n  zi = 1.0 / ( x + y )\n\n```\n\nCreate a function *multiplier*, that given two numbers as arguments returns a function that when called with one argument, returns the result of multiplying the two arguments to the call to multiplier that created it and the argument in the call:\n\n```\n new_function = multiplier(n1,n2)\n # where new_function(m) returns the result of n1 * n2 * m\n\n```\n\nApplying the multiplier of a number and its inverse from the two ordered collections of numbers in pairs, show that the result in each case is one.  \n**Compare and contrast the resultant program with the corresponding entry in First-class functions.** They should be close.\n\nTo paraphrase the task description: Do what was done before, but with numbers rather than functions"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015-09-10\n\n```\nsub multiplied ($g, $f) { return { $g * $f * $^x } }\n \nmy $x  = 2.0;\nmy $xi = 0.5;\nmy $y  = 4.0;\nmy $yi = 0.25;\nmy $z  = $x + $y;\nmy $zi = 1.0 / ( $x + $y );\n\nmy @numbers = $x, $y, $z;\nmy @inverses = $xi, $yi, $zi;\n \nfor flat @numbers Z @inverses { say multiplied($^g, $^f)(.5) }\n\n```\n\nOutput:\n\n```\n0.5\n0.5\n0.5\n```\n\nThe structure of this is identical to first-class function task."}]}
{"messages": [{"role": "user", "content": "The month of October in 2010 has five Fridays, five Saturdays, and five Sundays.\n\nTask\n\n1. Write a program to show all months that have this same characteristic of five full weekends from the year 1900 through 2100 (Gregorian calendar).\n2. Show the *number* of months with this property (there should be 201).\n3. Show at least the first and last five dates, in order.\n\n**Algorithm suggestions**\n\n* Count the number of Fridays, Saturdays, and Sundays in every month.\n* Find all of the 31-day months that begin on Friday.\n\n**Extra credit**\n\nCount and/or show all of the years which do not have at least one five-weekend month (there should be 29).\n\nRelated tasks\n\n* Day of the week\n* Last Friday of each month\n* Find last sunday of each month"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015-09-10\n\n```\n# A month has 5 weekends iff it has 31 days and starts on Friday.\n\nmy @years = 1900 .. 2100;\nmy @has31 = 1, 3, 5, 7, 8, 10, 12;\nmy @happy = ($_ when *.day-of-week == 5 for (@years X @has31).map(-> ($y, $m) { Date.new: $y, $m, 1 }));\n\nsay 'Happy month count:  ', +@happy;\nsay 'First happy months: ' ~ @happy[^5];\nsay 'Last  happy months: ' ~ @happy[*-5 .. *];\nsay 'Dreary years count: ',  @years - @happy».year.squish;\n\n```\n\nOutput:\n\n```\nHappy month count:  201\nFirst happy months: 1901-03-01 1902-08-01 1903-05-01 1904-01-01 1904-07-01\nLast  happy months: 2097-03-01 2098-08-01 2099-05-01 2100-01-01 2100-10-01\nDreary years count: 29\n```"}]}
{"messages": [{"role": "user", "content": "Many big data or scientific programs use boxplots to show distributions of data.   In addition, sometimes saving large arrays for boxplots can be impractical and use extreme amounts of RAM.   It can be useful to save large arrays as arrays with five numbers to save memory.\n\nFor example, the   **R**   programming language implements Tukey's five-number summary as the **fivenum** function.\n\nTask\n\nGiven an array of numbers, compute the five-number summary.\n\nNote\n\nWhile these five numbers can be used to draw a boxplot,   statistical packages will typically need extra data.\n\nMoreover, while there is a consensus about the \"box\" of the boxplot,   there are variations among statistical packages for the whiskers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nsub fourths ( Int $end ) {\n    my $end_22 = $end div 2 / 2;\n\n    return 0, $end_22, $end/2, $end - $end_22, $end;\n}\nsub fivenum ( @nums ) {\n    my @x = @nums.sort(+*)\n        or die 'Input must have at least one element';\n\n    my @d = fourths(@x.end);\n\n    return ( @x[@d».floor] Z+ @x[@d».ceiling] ) »/» 2;\n}\n\nsay .&fivenum for [15, 6, 42, 41, 7, 36, 49, 40, 39, 47, 43],\n                  [36, 40, 7, 39, 41, 15], [\n    0.14082834,  0.09748790,  1.73131507,  0.87636009, -1.95059594,\n    0.73438555, -0.03035726,  1.46675970, -0.74621349, -0.72588772,\n    0.63905160,  0.61501527, -0.98983780, -1.00447874, -0.62759469,\n    0.66206163,  1.04312009, -0.10305385,  0.75775634,  0.32566578,\n];\n\n```\n\nOutput:\n\n```\n(6 25.5 40 42.5 49)\n(7 15 37.5 40 41)\n(-1.95059594 -0.676741205 0.23324706 0.746070945 1.73131507)\n```"}]}
{"messages": [{"role": "user", "content": "Fixed length read/write\n\nBefore terminals, computers commonly used punch card readers or paper tape input.\n\nA common format before these devices were superseded by terminal technology was based on the Hollerith code, Hollerith code.\n\nThese input devices handled 80 columns per card and had a limited character set, encoded by punching holes in one or more rows of the card for each column.\n\nThese devices assumed/demanded a fixed line width of 80 characters, newlines were not required (and could not even be encoded in some systems).\n\nTask\n\nWrite a program to read 80 column fixed length records (no newline terminators (but newline characters allowed in the data)) and then write out the reverse of each line as fixed length 80 column records.\n\nSamples here use printable characters, but that is not a given with fixed length data. Filenames used are sample.txt, infile.dat, outfile.dat.\n\n**Note:** There are no newlines, inputs and outputs are fixed at 80 columns, no more, no less, space padded. Fixed length data is 8 bit complete. NUL bytes of zero are allowed.\n\nThese fixed length formats are still in wide use on mainframes, with JCL and with COBOL (which commonly use EBCDIC encoding and not ASCII). Most of the large players in day to day financial transactions know all about fixed length records and the expression *logical record length*.\n\nSample data\n\nTo create the sample input file, use an editor that supports fixed length records or use a conversion utility. For instance, most GNU/Linux versions of **dd** support blocking and unblocking records with a conversion byte size.\n\n```\nLine 1...1.........2.........3.........4.........5.........6.........7.........8\nLine 2\nLine 3\nLine 4\n\nLine 6\nLine 7\n     Indented line 8............................................................\nLine 9                                                                 RT MARGIN\n```\n\n```\nprompt$ dd if=sample.txt of=infile.dat cbs=80 conv=block\n```\n\nwill create a fixed length record file of 80 bytes given newline delimited text input.\n\n```\nprompt$ dd if=infile.dat cbs=80 conv=unblock\n```\n\nwill display a file with 80 byte logical record lengths to standard out as standard text with newlines.\n\nBonus round\n\nForth systems often include BLOCK words. A block is 1024 bytes. Source code is stored as 16 lines of 64 characters each (again, no newline character or sequence to mark the end of a line).\n\nWrite a program to convert a block file to text (using newlines). Trailing spaces should be excluded from the output.\n\nAlso demonstrate how to convert from a normal text file to block form. All lines either truncated or padded to 64 characters with no newline terminators. The last block filled to be exactly 1024 characters by adding blanks if needed. Assume a full range of 8 bit byte values for each character.\n\nThe COBOL example uses forth.txt and forth.blk filenames."}, {"role": "assistant", "content": "(formerly Perl 6)\nLink to a copy of the input file used: flr-infile.dat\n\nEssentially the same as task Selective\\_File\\_Copy except more boring.\n\n```\n$*OUT = './flr-outfile.dat'.IO.open(:w, :bin) orelse .die; # open a file in binary mode for writing\nwhile my $record = $*IN.read(80) {                       # read in fixed sized binary chunks\n     $*OUT.write: $record.=reverse;                      # write reversed records out to $outfile\n     $*ERR.say: $record.decode('ASCII');                 # display decoded records on STDERR\n}\nclose $*OUT;\n\n```\n\nOutput:\n\n```\n8.........7.........6.........5.........4.........3.........2.........1...1 eniL\n                                                                          2 eniL\n                                                                          3 eniL\n                                                                          4 eniL\n                                                                                \n                                                                          6 eniL\n                                                                          7 eniL\n............................................................8 enil detnednI     \nNIGRAM TR                                                                 9 eniL\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program that prints the integers from   **1**   to   **100**   (inclusive).\n\nBut:\n\n:   * for multiples of three,   print   **Fizz**     instead of the number;\n    * for multiples of five,   print   **Buzz**     instead of the number;\n    * for multiples of both three and five,   print   **FizzBuzz**     instead of the number.\n\nThe   *FizzBuzz*   problem was presented as the lowest level of comprehension required to illustrate adequacy.\n\nAlso see\n\n* (a blog)   dont-overthink-fizzbuzz\n* (a blog)   fizzbuzz-the-programmers-stairway-to-heaven"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo Star version 2015-09-10\n\nMost straightforwardly:\n\n```\nfor 1 .. 100 {\n    when $_ %% (3 & 5) { say 'FizzBuzz'; }\n    when $_ %% 3       { say 'Fizz'; }\n    when $_ %% 5       { say 'Buzz'; }\n    default            { .say; }\n}\n```\n\nOr abusing multi subs:\n\n```\nmulti sub fizzbuzz(Int $ where * %% 15) { 'FizzBuzz' }\nmulti sub fizzbuzz(Int $ where * %%  5) { 'Buzz' }\nmulti sub fizzbuzz(Int $ where * %%  3) { 'Fizz' }\nmulti sub fizzbuzz(Int $number        ) { $number }\n(1 .. 100)».&fizzbuzz.say;\n```\n\nOr abusing list metaoperators:\n\n```\n[1..100].map({[~] ($_%%3, $_%%5) »||» \"\" Z&& <fizz buzz> or $_ })».say\n```\n\nConcisely (readable):\n\n```\nsay 'Fizz' x $_ %% 3 ~ 'Buzz' x $_ %% 5 || $_ for 1 .. 100;\n```\n\nShortest FizzBuzz to date:\n\n```\nsay \"Fizz\"x$_%%3~\"Buzz\"x$_%%5||$_ for 1..100\n```\n\nAnd here's an implementation that never checks for divisibility:\n\n```\n.say for\n    (\n      (flat ('' xx 2, 'Fizz') xx *)\n      Z~\n      (flat ('' xx 4, 'Buzz') xx *)\n    )\n    Z||\n    1 .. 100;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function to flatten the nesting in an arbitrary list of values.\n\nYour program should work on the equivalent of this list:\n\n```\n  [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]\n\n```\n\nWhere the correct result would be the list:\n\n```\n   [1, 2, 3, 4, 5, 6, 7, 8]\n\n```\n\nRelated task\n\n* Tree traversal"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo Star version 2018.03\n\n```\nmy @l = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []];\n\nsay .perl given gather @l.deepmap(*.take); # lazy recursive version\n\n# Another way to do it is with a recursive function (here actually a Block calling itself with the &?BLOCK dynamic variable):\n\nsay { |(@$_ > 1 ?? map(&?BLOCK, @$_) !! $_) }(@l)\n```"}]}
{"messages": [{"role": "user", "content": "The game\n\nGiven an   **N×N**   square array of zeroes or ones in an initial configuration,   and a target configuration of zeroes and ones.\n\nThe game is to transform one to the other in as few moves as possible by inverting whole numbered rows or whole lettered\ncolumns at once   (as one move).\n\nIn an inversion.   any  **1**  becomes  **0**,   and any  **0**  becomes  **1**  for that whole row or column.\n\nTask\n\nCreate a program to score for the Flipping bits game.\n\n1. The game should create an original random target configuration and a starting configuration.\n2. Ensure that the starting position is *never* the target position.\n3. The target position must be guaranteed as reachable from the starting position.   (One possible way to do this is to generate the start position by legal flips from a random target position.   The flips will always be reversible back to the target from the given start position).\n4. The number of moves taken so far should be shown.\n\nShow an example of a short game here, on this page, for a   **3×3**   array of bits."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.11\n\nPass in a parameter to set the square size for the puzzle. (Defaults to 4.) Arbitrarily limited to between 1 and 26. Yes, you can choose to solve a 1 element square puzzle, but it won't be very challenging. Accepts upper or lower case letters for columns. Disregards any out-of-range indices. Enter a blank or 0 (zero) to exit.\n\n```\nsub MAIN ($square = 4) {\n    say \"{$square}? Seriously?\" and exit if $square < 1 or $square > 26;\n    my %bits = map { $_ => %( map { $_ => 0 }, ('A' .. *)[^ $square] ) },\n        (1 .. *)[^ $square];\n    scramble %bits;\n    my $target = build %bits;\n    scramble %bits until build(%bits) ne $target;\n    display($target, %bits);\n    my $turns = 0;\n    while my $flip = prompt \"Turn {++$turns}: Flip which row / column? \" {\n        flip $flip.match(/\\w/).uc, %bits;\n        if display($target, %bits) {\n            say \"Hurray! You solved it in $turns turns.\";\n            last;\n        }\n    }\n}\n\nsub display($goal, %hash) {\n    shell('clear');\n    say \"Goal\\n$goal\\nYou\";\n    my $this = build %hash;\n    say $this;\n    return ($goal eq $this);\n}\n\nsub flip ($a, %hash) {\n    given $a {\n        when any(keys %hash) {\n            %hash{$a}{$_} = %hash{$a}{$_} +^ 1 for %hash{$a}.keys\n        };\n        when any(keys %hash{'1'}) {\n            %hash{$_}{$a} = %hash{$_}{$a} +^ 1 for %hash.keys\n        };\n    }\n}\n\nsub build (%hash) {\n    my $string = '   ';\n    $string ~= sprintf \"%2s \", $_ for sort keys %hash{'1'};\n    $string ~= \"\\n\";\n    for %hash.keys.sort: +* -> $key {\n        $string ~= sprintf \"%2s \", $key;\n        $string ~= sprintf \"%2s \", %hash{$key}{$_} for sort keys %hash{$key};\n        $string ~=  \"\\n\";\n    };\n    $string\n}\n\nsub scramble(%hash) {\n    my @keys = keys %hash;\n    @keys.push: | keys %hash{'1'};\n    flip $_,  %hash for @keys.pick( @keys/2 );\n}\n\n```\n\nA sample 3 x 3 game might look like this:\n\n```\nGoal\n    A  B  C \n 1  1  1  0 \n 2  0  0  1 \n 3  1  1  0 \n\nYou\n    A  B  C \n 1  0  0  0 \n 2  1  1  1 \n 3  1  1  1 \n\nTurn 1: Flip which row / column? 2\n\nGoal\n    A  B  C \n 1  1  1  0 \n 2  0  0  1 \n 3  1  1  0 \n\nYou\n    A  B  C \n 1  0  0  0 \n 2  0  0  0 \n 3  1  1  1 \n\nTurn 2: Flip which row / column? 1\n\nGoal\n    A  B  C \n 1  1  1  0 \n 2  0  0  1 \n 3  1  1  0 \n\nYou\n    A  B  C \n 1  1  1  1 \n 2  0  0  0 \n 3  1  1  1 \n\nTurn 3: Flip which row / column? c\n\nGoal\n    A  B  C \n 1  1  1  0 \n 2  0  0  1 \n 3  1  1  0 \n\nYou\n    A  B  C \n 1  1  1  0 \n 2  0  0  1 \n 3  1  1  0 \n\nHurray! You solved it in 3 turns.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDocument common flow-control structures.\n\nOne common example of a flow-control structure is the    `goto`    construct.\n\nNote that   Conditional Structures   and   Loop Structures   have their own articles/categories.\n\nRelated tasks\n\n* Conditional Structures\n* Loop Structures"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Control exceptions\n\nControl flow is extensible in Raku; most abnormal control flow (including the standard loop and switch exits) is managed by throwing control exceptions that are caught by the code implementing the construct in question. Warnings are also handled via control exceptions, and turn into control flow if the dynamic context chooses not to resume after the warning. See [S04/Control exceptions] for more information.\n\n### Phasers\n\nPhasers are blocks that are transparent to the normal control flow but that are automatically called at an appropriate phase of compilation or execution. The current list of phasers may be found in [S04/Phasers].\n\n### goto\n\n```\nTOWN: goto TOWN;\n\n```\n\nLabels that have not been defined yet must be enclosed in quotes."}]}
{"messages": [{"role": "user", "content": "Floyd's triangle   lists the natural numbers in a right triangle aligned to the left where\n\n* the first row is   **1**     (unity)\n* successive rows start towards the left with the next number followed by successive naturals listing one more number than the line above.\n\nThe first few lines of a Floyd triangle looks like this:\n\n```\n 1\n 2  3\n 4  5  6\n 7  8  9 10\n11 12 13 14 15\n\n```\n\nTask\n:   1. Write a program to generate and display here the first   n   lines of a Floyd triangle.   \n       (Use   n=5   and   n=14   rows).\n    2. Ensure that when displayed in a mono-space font, the numbers line up in vertical columns as shown and that only one space separates numbers of the last row."}, {"role": "assistant", "content": "(formerly Perl 6)\nHere's two ways of doing it.\n\n```\nconstant @floyd1 = (1..*).rotor(1..*);\nconstant @floyd2 = gather for 1..* -> $s { take [++$ xx $s] }\n\nsub format-rows(@f) {\n    my @table;\n    my @formats = @f[@f-1].map: {\"%{.chars}s\"}\n    for @f -> @row {\n        @table.push: (@row Z @formats).map: -> ($i, $f) { $i.fmt($f) }\n    }\n    join \"\\n\", @table;\n}\n\nsay format-rows(@floyd1[^5]);\nsay '';\nsay format-rows(@floyd2[^14]);\n\n```\n\nOutput:\n\n```\n 1 \n 2  3 \n 4  5  6 \n 7  8  9 10 \n11 12 13 14 15\n \n 1 \n 2  3 \n 4  5  6 \n 7  8  9 10 \n11 12 13 14 15 \n16 17 18 19 20 21 \n22 23 24 25 26 27 28 \n29 30 31 32 33 34 35 36 \n37 38 39 40 41 42 43 44  45 \n46 47 48 49 50 51 52 53  54  55 \n56 57 58 59 60 61 62 63  64  65  66 \n67 68 69 70 71 72 73 74  75  76  77  78 \n79 80 81 82 83 84 85 86  87  88  89  90  91 \n92 93 94 95 96 97 98 99 100 101 102 103 104 105\n```"}]}
{"messages": [{"role": "user", "content": "The Floyd–Warshall algorithm is an algorithm for finding shortest paths in a weighted graph with positive or negative edge weights.\n\nTask\n\nFind the lengths of the shortest paths between all pairs of vertices of the given directed graph. Your code may assume that the input has already been checked for loops, parallel edges and negative cycles.\n\nPrint the pair, the distance and (optionally) the path.\n\nExample\n\n```\npair     dist    path\n1 -> 2    -1     1 -> 3 -> 4 -> 2\n1 -> 3    -2     1 -> 3\n1 -> 4     0     1 -> 3 -> 4\n2 -> 1     4     2 -> 1\n2 -> 3     2     2 -> 1 -> 3\n2 -> 4     4     2 -> 1 -> 3 -> 4\n3 -> 1     5     3 -> 4 -> 2 -> 1\n3 -> 2     1     3 -> 4 -> 2\n3 -> 4     2     3 -> 4\n4 -> 1     3     4 -> 2 -> 1\n4 -> 2    -1     4 -> 2\n4 -> 3     1     4 -> 2 -> 1 -> 3\n```\n\nSee also\n\n* Floyd-Warshall Algorithm - step by step guide (youtube)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.12\n\n**Translation of**: Ruby\n\n```\nsub Floyd-Warshall (Int $n, @edge) {\n    my @dist = [0, |(Inf xx $n-1)], *.Array.rotate(-1) … !*[*-1];\n    my @next = [0 xx $n] xx $n;\n\n    for @edge -> ($u, $v, $w) {\n        @dist[$u-1;$v-1] = $w;\n        @next[$u-1;$v-1] = $v-1;\n    }\n\n    for [X] ^$n xx 3 -> ($k, $i, $j) {\n        if @dist[$i;$j] > my $sum = @dist[$i;$k] + @dist[$k;$j] {\n            @dist[$i;$j] = $sum;\n            @next[$i;$j] = @next[$i;$k];\n        }\n    }\n\n    say ' Pair  Distance     Path';\n    for [X] ^$n xx 2 -> ($i, $j){\n        next if $i == $j;\n        my @path = $i;\n        @path.push: @next[@path[*-1];$j] until @path[*-1] == $j;\n        printf(\"%d → %d  %4d       %s\\n\", $i+1, $j+1, @dist[$i;$j],\n          @path.map( *+1 ).join(' → '));\n    }\n}\n\nFloyd-Warshall(4, [[1, 3, -2], [2, 1, 4], [2, 3, 3], [3, 4, 2], [4, 2, -1]]);\n\n```\n\nOutput:\n\n```\n Pair  Distance     Path\n1 → 2    -1       1 → 3 → 4 → 2\n1 → 3    -2       1 → 3\n1 → 4     0       1 → 3 → 4\n2 → 1     4       2 → 1\n2 → 3     2       2 → 1 → 3\n2 → 4     4       2 → 1 → 3 → 4\n3 → 1     5       3 → 4 → 2 → 1\n3 → 2     1       3 → 4 → 2\n3 → 4     2       3 → 4\n4 → 1     3       4 → 2 → 1\n4 → 2    -1       4 → 2\n4 → 3     1       4 → 2 → 1 → 3\n\n```"}]}
{"messages": [{"role": "user", "content": "Lagrange's theorem tells us that every positive integer can be written as a sum of at most four squares.\n\nMany, (square numbers) can be written as a \"sum\" of a single square. **E.G.:** `4 == 22`.\n\nSome numbers require at least two squares to be summed. `5 == 22 + 12`\n\nOthers require at least three squares. `6 == 22 + 12 + 12`\n\nFinally, some, (the focus of this task) require the sum at least four squares. `7 == 22 + 12 + 12 + 12`. There is no way to reach 7 summing fewer than four squares.\n\nThese numbers show up in crystallography; x-ray diffraction patterns of cubic crystals depend on a length squared plus a width squared plus a height squared. Some configurations that require at least four squares are impossible to index and are colloquially known as **forbidden numbers**.\n\nNote that some numbers *can* be made from the sum of four squares: `16 == 22 + 22 + 22 + 22`, but since it can also be formed from fewer than four, `16 == 42`, it does not count as a forbidden number.\n\nTask\n\n* Find and show the first fifty forbidden numbers.\n\n* Find and show the **count** of forbidden numbers up to 500, 5,000.\n\nStretch\n\n* Find and show the **count** of forbidden numbers up to 50,000, 500,000.\n\nSee also\n\n* Wikipedia: Lagrange's theorem * OEIS A004215 - Numbers that are the sum of 4 but no fewer nonzero squares"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\nuse List::Divvy;\n\nmy @f = (1..*).map: *×8-1;\n\nmy @forbidden = lazy flat @f[0], gather for ^∞ {\n    state ($p0, $p1) = 1, 0;\n    take (@f[$p0] < @forbidden[$p1]×4) ?? @f[$p0++] !! @forbidden[$p1++]×4;\n}\n\nput \"First fifty forbidden numbers: \\n\" ~\n  @forbidden[^50].batch(10)».fmt(\"%3d\").join: \"\\n\";\n\nput \"\\nForbidden number count up to {.Int.&cardinal}: \" ~\n  comma +@forbidden.&upto: $_ for 5e2, 5e3, 5e4, 5e5, 5e6;\n\n```\n\nOutput:\n\n```\nFirst fifty forbidden numbers: \n  7  15  23  28  31  39  47  55  60  63\n 71  79  87  92  95 103 111 112 119 124\n127 135 143 151 156 159 167 175 183 188\n191 199 207 215 220 223 231 239 240 247\n252 255 263 271 279 284 287 295 303 311\n\nForbidden number count up to five hundred: 82\n\nForbidden number count up to five thousand: 831\n\nForbidden number count up to fifty thousand: 8,330\n\nForbidden number count up to five hundred thousand: 83,331\n\nForbidden number count up to five million: 833,329\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Forest-fire model. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nImplement the Drossel and Schwabl definition of the forest-fire model.\n\nIt is basically a 2D   cellular automaton   where each cell can be in three distinct states (*empty*, *tree* and *burning*) and evolves according to the following rules (as given by Wikipedia)\n\n1. A burning cell turns into an empty cell\n2. A tree will burn if at least one neighbor is burning\n3. A tree ignites with probability   *f*    even if no neighbor is burning\n4. An empty space fills with a tree with probability    *p*\n\nNeighborhood is the   Moore neighborhood;   boundary conditions are so that on the boundary the cells are always empty (\"fixed\" boundary condition).\n\nAt the beginning, populate the lattice with empty and tree cells according to a specific probability (e.g. a cell has the probability 0.5 to be a tree). Then, let the system evolve.\n\nTask's requirements do not include graphical display or the ability to change parameters (probabilities    *p*    and    *f* )   through a graphical or command line interface.\n\nRelated tasks\n\n* See   Conway's Game of Life\n* See   Wireworld."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### ANSI graphics\n\n**Works with**: rakudo version 2015-10-04\n\nThis version saves a lot of looking around by using four states instead of three; the Heating state does a lookahead to track trees that are being heated up by burning trees, so we only ever have to traverse the neighbors of burning trees, not all trees. Also, by only checking the list of burning trees, we can avoid copying the entire forest each iteration, since real forests are mutable.\n\n```\nconstant $RED = \"\\e[1;31m\";\nconstant $YELLOW = \"\\e[1;33m\";\nconstant $GREEN = \"\\e[1;32m\";\nconstant $CLEAR = \"\\e[0m\";\n# make sure we clear colors at the end\nEND print $CLEAR;\n \nenum Cell-State <Empty Tree Heating Burning>;\nmy @pix = '  ', $GREEN ~ '木', $YELLOW ~ '木', $RED ~ '木';\n \nclass Forest {\n    has Rat $.p = 0.01;\n    has Rat $.f = 0.001;\n    has Int $!height;\n    has Int $!width;\n    has @!coords;\n    has @!spot;\n    has @!neighbors;\n\n    method BUILD (Int :$!height, Int :$!width) {\n\t@!coords = ^$!height X ^$!width;\n\t@!spot = [ (Bool.pick ?? Tree !! Empty) xx $!width ] xx $!height;\n        self!init-neighbors;\n    }\n \n    method !init-neighbors {\n        for @!coords -> ($i, $j) {\n            @!neighbors[$i][$j] = eager gather for\n                    [-1,-1],[+0,-1],[+1,-1],\n                    [-1,+0],        [+1,+0],\n                    [-1,+1],[+0,+1],[+1,+1]\n\t    {\n\t\ttake-rw @!spot[$i + .[0]][$j + .[1]] // next;\n\t    }\n\t}\n    }\n \n    method step {\n\tmy @heat;\n        for @!coords -> ($i, $j) {\n            given @!spot[$i][$j] {\n                when Empty   { $_ = Tree if rand < $!p }\n                when Tree    { $_ = Heating if rand < $!f }\n                when Heating { $_ = Burning; push @heat, ($i, $j); }\n                when Burning { $_ = Empty }\n            }\n        }\n\tfor @heat -> ($i,$j) {\n\t    $_ = Heating for @!neighbors[$i][$j].grep(Tree);\n\t}\n    }\n \n    method show {\n        for ^$!height -> $i {\n            say @pix[@!spot[$i].list].join;\n        }\n    }\n}\n\nmy ($ROWS, $COLS) = qx/stty size/.words;\n\nsignal(SIGINT).act: { print \"\\e[H\\e[2J\"; exit }\n\nsub MAIN (Int $height = $ROWS - 2, Int $width = +$COLS div 2 - 1) {\n    my Forest $forest .= new(:$height, :$width);\n    print \"\\e[2J\";      # ANSI clear screen\n    loop {\n\tprint \"\\e[H\";   # ANSI home\n\tsay $++;\n\t$forest.show;\n\t$forest.step;\n    }\n}\n\n```\n\n### SDL2 Animation\n\nAn alternate version implemented in SDL2.\n\n```\nuse NativeCall;\nuse SDL2::Raw;\n\nmy ($width, $height) = 900, 900;\n\nSDL_Init(VIDEO);\nmy SDL_Window $window = SDL_CreateWindow(\n    \"Forest Fire - Raku\",\n    SDL_WINDOWPOS_CENTERED_MASK, SDL_WINDOWPOS_CENTERED_MASK,\n    $width, $height,\n    RESIZABLE\n);\nmy SDL_Renderer $renderer = SDL_CreateRenderer( $window, -1, ACCELERATED +| PRESENTVSYNC );\n\nSDL_ClearError();\n\nmy int ($w, $h) = 200, 200;\n\nmy $forest_texture = SDL_CreateTexture($renderer, %PIXELFORMAT<RGB332>, STREAMING, $w, $h);\n\nmy $pixdatabuf  = CArray[int64].new(0, $w, $h, $w);\nmy $work-buffer = CArray[int64].new(0, $w, $h, $w);\n\nmy int $bare    = 0;    # Black\nmy int $tree    = 8;    # Green\nmy int $heating = -120; # Orange ( 132 but it's being passed into an int8 )\nmy int $burning = 128;  # Red\nmy int $buf = $w * $h;\nmy $humidity    = .7;  # Chance that a tree next to a burning tree will resist catching fire\nmy $tree-spawn  = .75; # Initial probability that a space will contain a tree. Probability\n                       # will be adjusted (way down) once rendering starts.\n\nsub render {\n\n    # work-around to pass the pointer-pointer.\n    my $pixdata = nativecast(Pointer[int64], $pixdatabuf);\n    SDL_LockTexture($forest_texture, SDL_Rect, $pixdata, my int $pitch);\n\n    $pixdata = nativecast(CArray[int8], Pointer.new($pixdatabuf[0]));\n\n    loop (my int $row; $row < $h; $row = $row + 1) {\n        my int $rs = $row * $w; # row start\n        my int $re = $rs  + $w; # row end\n        loop (my int $idx = $rs; $idx < $re; $idx = $idx + 1) {\n            # Skip it if it is a tree\n            next if $pixdata[$idx] == $tree;\n            if $pixdata[$idx] == $bare {\n                # Maybe spawn a tree on bare ground\n                $work-buffer[$idx] = rand < $tree-spawn ?? $tree !! $bare;\n            } elsif $pixdata[$idx] == $heating {\n                # Check if there are trees around a hot spot and light them if humidity is low enough\n                $work-buffer[$idx - $w - 1] = $heating if rand > $humidity && $pixdata[$idx - $w - 1] && $row > 0;\n                $work-buffer[$idx - $w    ] = $heating if rand > $humidity && $pixdata[$idx - $w    ] && $row > 0;\n                $work-buffer[$idx - $w + 1] = $heating if rand > $humidity && $pixdata[$idx - $w + 1] && $row > 0;\n                $work-buffer[$idx - 1     ] = $heating if rand > $humidity && $pixdata[$idx -  1    ];\n                $work-buffer[$idx + $w - 1] = $heating if rand > $humidity && $pixdata[$idx + $w - 1];\n                $work-buffer[$idx + $w    ] = $heating if rand > $humidity && $pixdata[$idx + $w    ];\n                $work-buffer[$idx + $w + 1] = $heating if rand > $humidity && $pixdata[$idx + $w + 1];\n                $work-buffer[$idx + 1     ] = $heating if rand > $humidity && $pixdata[$idx +  1    ];\n\n                # Hotspot becomes a flame\n                $work-buffer[$idx] = $burning\n            } else {\n                # Extinguish a flame after fuel is gone\n                $work-buffer[$idx] = $bare;\n            }\n        }\n    }\n    # copy working buffer to main texture buffer\n    loop (my int $i; $i < $buf; $i = $i + 1) { $pixdata[$i] = $work-buffer[$i] }\n\n    # start a fire maybe\n    $pixdata[$buf.rand] = $heating if rand < .1;\n\n    SDL_UnlockTexture($forest_texture);\n\n    SDL_RenderCopy($renderer, $forest_texture, SDL_Rect, SDL_Rect.new(:x(0), :y(0), :w($width), :h($height)));\n    SDL_RenderPresent($renderer);\n    once $tree-spawn = .005;\n}\n\nmy $event = SDL_Event.new;\n\nenum KEY_CODES ( K_Q => 20 );\n\nmain: loop {\n\n    while SDL_PollEvent($event) {\n        my $casted_event = SDL_CastEvent($event);\n\n        given $casted_event {\n            when *.type == QUIT {\n                last main;\n            }\n            when *.type == KEYDOWN {\n                if KEY_CODES(.scancode) -> $comm {\n                    given $comm {\n                        when 'K_Q'      { last main }\n                    }\n                }\n            }\n            when *.type == WINDOWEVENT {\n                if .event == RESIZED {\n                    $width  = .data1;\n                    $height = .data2;\n                }\n            }\n        }\n    }\n    render();\n    print fps;\n}\nsay '';\n\nsub fps {\n    state $fps-frames = 0;\n    state $fps-now    = now;\n    state $fps        = '';\n    $fps-frames++;\n    if now - $fps-now >= 1 {\n        $fps = [~] \"\\b\" x 40, ' ' x 20, \"\\b\" x 20 ,\n            sprintf \"FPS: %5.2f  \", ($fps-frames / (now - $fps-now)).round(.01);\n        $fps-frames = 0;\n        $fps-now = now;\n    }\n    $fps\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSpawn a new process which can run simultaneously with, and independently of, the original parent process."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.06\n\n```\nuse NativeCall;\nsub fork() returns int32 is native { ... }\n\nif fork() -> $pid {\n    print \"I am the proud parent of $pid.\\n\";\n}\nelse {\n    print \"I am a child.  Have you seen my mommy?\\n\";\n}\n\n```\n\nOutput:\n\n```\nI am the proud parent of 17691.\nI am a child.  Have you seen my mommy?\n```"}]}
{"messages": [{"role": "user", "content": "A *power series* is an infinite sum of the form\n\na\n\n0\n+\n\na\n\n1\n⋅\nx\n+\n\na\n\n2\n⋅\n\nx\n\n2\n+\n\na\n\n3\n⋅\n\nx\n\n3\n+\n⋯\n{\\displaystyle {\\displaystyle a\\_{0}+a\\_{1}\\cdot x+a\\_{2}\\cdot x^{2}+a\\_{3}\\cdot x^{3}+\\cdots }}\n\nThe *ai* are called the *coefficients* of the series. Such sums can be added, multiplied etc., where the new coefficients of the powers of *x* are calculated according to the usual rules.\n\nIf one is not interested in evaluating such a series for particular values of *x*, or in other words, if convergence doesn't play a role, then such a collection of coefficients is called *formal power series*. It can be treated like a new kind of number.\n\n**Task**: Implement formal power series as a numeric type. Operations should at least include *addition*, *multiplication*, *division* and additionally non-numeric operations like *differentiation* and *integration* (with an integration constant of zero). Take care that your implementation deals with the potentially infinite number of coefficients.\n\nAs an example, define the power series of sine and cosine in terms of each other using integration, as in\n\nsin\n⁡\nx\n=\n\n∫\n\n0\n\nx\ncos\n⁡\nt\n\nd\nt\n{\\displaystyle {\\displaystyle \\sin x=\\int \\_{0}^{x}\\cos t\\,dt}}\n\ncos\n⁡\nx\n=\n1\n−\n\n∫\n\n0\n\nx\nsin\n⁡\nt\n\nd\nt\n{\\displaystyle {\\displaystyle \\cos x=1-\\int \\_{0}^{x}\\sin t\\,dt}}\n\n**Goals**: Demonstrate how the language handles new numeric types and delayed (or *lazy*) evaluation."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nclass DerFPS { ... }\nclass IntFPS { ... }\n\nrole FPS {\n    method coeffs        { ... }\n    method differentiate { DerFPS.new(:x(self)) }\n    method integrate     { IntFPS.new(:x(self)) }\n\n    method pretty($n) {\n        sub super($i) { $i.trans('0123456789' => '⁰¹²³⁴⁵⁶⁷⁸⁹') }\n        my $str = $.coeffs[0];\n        for flat 1..$n Z $.coeffs[1..$n] -> $p, $c {\n            when $c > 0 { $str ~= \" + { $c .nude.join: '/'}∙x{super($p)}\" }\n            when $c < 0 { $str ~= \" - {-$c .nude.join: '/'}∙x{super($p)}\" }\n        }\n        $str;\n    }\n}\n\nclass ExplicitFPS does FPS { has @.coeffs }\n\nclass SumFPS does FPS {\n    has FPS ($.x, $.y);\n    method coeffs { $.x.coeffs Z+ $.y.coeffs }\n}\n\nclass DifFPS does FPS {\n    has FPS ($.x, $.y);\n    method coeffs { $.x.coeffs Z- $.y.coeffs }\n}\n\nclass ProFPS does FPS {\n    has FPS ($.x, $.y);\n    method coeffs { (0..*).map: { [+] ($.x.coeffs[0..$_] Z* $.y.coeffs[$_...0]) } }\n}\n\nclass InvFPS does FPS {\n    has FPS $.x;\n    method coeffs {\n        # see http://en.wikipedia.org/wiki/Formal_power_series#Inverting_series\n        flat gather {\n            my @a = $.x.coeffs;\n            @a[0] != 0 or fail \"Cannot invert power series with zero constant term.\";\n            take my @b = (1 / @a[0]);\n            take @b[$_] = -@b[0] * [+] (@a[1..$_] Z* @b[$_-1...0]) for 1..*;\n        }\n    }\n}\n\nclass DerFPS does FPS {\n    has FPS $.x;\n    method coeffs { (1..*).map: { $_ * $.x.coeffs[$_] } }\n}\n\nclass IntFPS does FPS {\n    has FPS $.x;\n    method coeffs { 0, |(0..*).map: { $.x.coeffs[$_] / ($_+1) } }\n}\n\nclass DeferredFPS does FPS {\n    has FPS $.realized is rw;\n    method coeffs { $.realized.coeffs }\n}\n\n# some arithmetic operations for formal power series\nmulti infix:<+>(FPS $x, FPS $y) { SumFPS.new(:$x, :$y) }\nmulti infix:<->(FPS $x, FPS $y) { DifFPS.new(:$x, :$y) }\nmulti infix:<*>(FPS $x, FPS $y) { ProFPS.new(:$x, :$y) }\nmulti infix:</>(FPS $x, FPS $y) { $x * InvFPS.new(:x($y)) }\n\n# an example of a mixed-type operator:\nmulti infix:<->(Numeric $x, FPS $y) { ExplicitFPS.new(:coeffs(lazy flat $x, 0 xx *)) - $y }\n\n# define sine and cosine in terms of each other\nmy $sin       = DeferredFPS.new;\nmy $cos       = 1 - $sin.integrate;\n$sin.realized = $cos.integrate;\n\n# define tangent in terms of sine and cosine\nmy $tan       = $sin / $cos;\n\nsay 'sin(x) ≈ ' ~ $sin.pretty(10);\nsay 'cos(x) ≈ ' ~ $cos.pretty(10);\nsay 'tan(x) ≈ ' ~ $tan.pretty(10);\n\n```\n\nOutput:\n\n```\nsin(x) ≈ 0 + 1/1∙x¹ - 1/6∙x³ + 1/120∙x⁵ - 1/5040∙x⁷ + 1/362880∙x⁹\ncos(x) ≈ 1 - 1/2∙x² + 1/24∙x⁴ - 1/720∙x⁶ + 1/40320∙x⁸ - 1/3628800∙x¹⁰\ntan(x) ≈ 0 + 1/1∙x¹ + 1/3∙x³ + 2/15∙x⁵ + 17/315∙x⁷ + 62/2835∙x⁹\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nExpress a number in decimal as a fixed-length string with leading zeros.\n\nFor example, the number   **7.125**   could be expressed as   **00007.125**."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsay 7.125.fmt('%09.3f');\n\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nA Fortunate number is the smallest integer **m > 1** such that for a given positive integer **n**, **primorial(n) + m** is a prime number, where **primorial(n)** is the product of the first **n** prime numbers.\n\nFor example the first fortunate number is 3 because primorial(1) is 2 and 2 + 3 = 5 which is prime whereas 2 + 2 = 4 is composite.\n\nTask\n\nAfter sorting and removal of any duplicates, compute and show on this page the first **8** Fortunate numbers or, if your language supports *big integers*, the first **50** Fortunate numbers.\n\nRelated task\n\n* Primorial numbers\n\nSee also\n\n* oeis:A005235 Fortunate numbers\n* oeis:A046066 Fortunate numbers, sorted with duplicates removed"}, {"role": "assistant", "content": "Limit of 75 primorials to get first 50 unique fortunates is arbitrary, found through trial and error.\n\n```\nmy @primorials = [\\*] grep *.is-prime, ^∞;\n\nsay display :title(\"First 50 distinct fortunate numbers:\\n\"),\n   (squish sort @primorials[^75].hyper.map: -> $primorial {\n       (2..∞).first: (* + $primorial).is-prime\n   })[^50];\n\nsub display ($list, :$cols = 10, :$fmt = '%6d', :$title = \"{+$list} matching:\\n\") {\n    cache $list;\n    $title ~ $list.batch($cols)».fmt($fmt).join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\nFirst 50 distinct fortunate numbers:\n     3      5      7     13     17     19     23     37     47     59\n    61     67     71     79     89    101    103    107    109    127\n   151    157    163    167    191    197    199    223    229    233\n   239    271    277    283    293    307    311    313    331    353\n   373    379    383    397    401    409    419    421    439    443\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nProvide code that produces a list of numbers which is the   nth  order forward difference, given a non-negative integer (specifying the order) and a list of numbers.\n\nThe first-order forward difference of a list of numbers   **A**   is a new list   **B**,   where   **B**n = **A**n+1 - **A**n.\n\nList   **B**   should have one fewer element as a result.\n\nThe second-order forward difference of   **A**   will be:\n\n```\ntdefmodule Diff do\n\tdef forward(arr,i\\\\1) do\n\t\tforward(arr,[],i)\n\tend\n\n\tdef forward([_|[]],diffs,i) do\n\t\tif i == 1 do\n\t\t\tIO.inspect diffs\n\t\telse \n\t\t\tforward(diffs,[],i-1)\n\t\tend\n\tend\n\n\tdef forward([val1|[val2|vals]],diffs,i) do\n\t\tforward([val2|vals],diffs++[val2-val1],i) \n\tend\nend \n\n```\n\nThe same as the first-order forward difference of   **B**.\n\nThat new list will have two fewer elements than   **A**   and one less than   **B**.\n\nThe goal of this task is to repeat this process up to the desired order.\n\nFor a more formal description, see the related   Mathworld article.\n\nAlgorithmic options\n\n* Iterate through all previous forward differences and re-calculate a new array each time.\n* Use this formula (from Wikipedia):\n\n:   :   :   Δ\n\n            n\n            [\n            f\n            ]\n            (\n            x\n            )\n            =\n\n            ∑\n\n            k\n            =\n            0\n\n            n\n\n            (\n\n            n\n            k\n\n            )\n            (\n            −\n            1\n\n            )\n\n            n\n            −\n            k\n            f\n            (\n            x\n            +\n            k\n            )\n            {\\displaystyle {\\displaystyle \\Delta ^{n}[f](x)=\\sum \\_{k=0}^{n}{n \\choose k}(-1)^{n-k}f(x+k)}}\n\n:   :   :   (Pascal's Triangle   may be useful for this option.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo Star version 2010-07\n\nHere we use signature matching to bind both an entire array and a version missing the head.\nThe Z- operator is a zip metaoperator with a minus to subtract the two lists pairwise.\nIt's almost a shame to define difn, since the series and subscript are hardly longer than the call itself would be, and arguably more self-documenting than the name of the function would be.\n\n```\nsub dif(@array [$, *@tail]) { @tail Z- @array }\nsub difn($array, $n) { ($array, &dif ... *)[$n] }\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n\"*Simulate*\" a four-bit adder.\n\nThis design can be realized using four 1-bit full adders.\nEach of these 1-bit full adders can be built with two half adders and an   *or*   gate. ;\n\nFinally a half adder can be made using an   *xor*   gate and an   *and*   gate.\n\nThe   *xor*   gate can be made using two   *not*s,   two   *and*s   and one   *or*.\n\n**Not**,   **or**   and   **and**,   the only allowed \"gates\" for the task, can be \"imitated\" by using the bitwise operators of your language.\n\nIf there is not a *bit type* in your language, to be sure that the   *not*   does not \"invert\" all the other bits of the basic type   (e.g. a byte)   we are not interested in,   you can use an extra   *nand*   (*and*   then   *not*)   with the constant   **1**   on one input.\n\nInstead of optimizing and reducing the number of gates used for the final 4-bit adder,   build it in the most straightforward way,   *connecting* the other \"constructive blocks\",   in turn made of \"simpler\" and \"smaller\" ones.\n\nSchematics of the \"constructive blocks\"\n\n| (Xor gate with ANDs, ORs and NOTs) | (A half adder) | (A full adder) | (A 4-bit adder) |\n| --- | --- | --- | --- |\n|  |  |  |  |\n\nSolutions should try to be as descriptive as possible, making it as easy as possible to identify \"connections\" between higher-order \"blocks\".\n\nIt is not mandatory to replicate the syntax of higher-order blocks in the atomic \"gate\" blocks, i.e. basic \"gate\" operations can be performed as usual bitwise operations, or they can be \"wrapped\" in a *block* in order to expose the same syntax of higher-order blocks, at implementers' choice.\n\nTo test the implementation, show the sum of two four-bit numbers (in binary)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub xor ($a, $b) { (($a and not $b) or (not $a and $b)) ?? 1 !! 0 }\n\nsub half-adder ($a, $b) {\n    return xor($a, $b), ($a and $b);\n}\n\nsub full-adder ($a, $b, $c0) {\n    my ($ha0_s, $ha0_c) = half-adder($c0, $a);\n    my ($ha1_s, $ha1_c) = half-adder($ha0_s, $b);\n    return $ha1_s, ($ha0_c or $ha1_c);\n}\n\nsub four-bit-adder ($a0, $a1, $a2, $a3, $b0, $b1, $b2, $b3) {\n    my ($fa0_s, $fa0_c) = full-adder($a0, $b0, 0);\n    my ($fa1_s, $fa1_c) = full-adder($a1, $b1, $fa0_c);\n    my ($fa2_s, $fa2_c) = full-adder($a2, $b2, $fa1_c);\n    my ($fa3_s, $fa3_c) = full-adder($a3, $b3, $fa2_c);\n\n    return $fa0_s, $fa1_s, $fa2_s, $fa3_s, $fa3_c;\n}\n\n{\n    use Test;\n\n    is four-bit-adder(1, 0, 0, 0, 1, 0, 0, 0), (0, 1, 0, 0, 0), '1 + 1 == 2';\n    is four-bit-adder(1, 0, 1, 0, 1, 0, 1, 0), (0, 1, 0, 1, 0), '5 + 5 == 10';\n    is four-bit-adder(1, 0, 0, 1, 1, 1, 1, 0)[4], 1, '7 + 9 == overflow';\n}\n\n```\n\nOutput:\n\n```\nok 1 - 1 + 1 == 2\nok 2 - 5 + 5 == 10\nok 3 - 7 + 9 == overflow\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a subroutine, function, whatever it may be called in your language, that takes an integer number and returns an English text sequence starting with the English cardinal representation of that integer, the word 'is' and then the English cardinal representation of the count of characters that made up the first word, followed by a comma.\n\nContinue the sequence by using the previous count word as the first word of the next phrase, append 'is' and the cardinal count of the letters in *that* word.\n\nContinue until you reach four. Since four has four characters, finish by adding the words 'four is magic' and a period. All integers will eventually wind up at four.\n\nFor instance, suppose your are given the integer **3**. Convert **3** to **Three**, add  **is** , then the cardinal character count of three, or **five**, with a comma to separate if from the next phrase. Continue the sequence **five is four,** (five has four letters), and finally, **four is magic.**\n\n```\n     Three is five, five is four, four is magic.\n\n```\n\nFor reference, here are outputs for 0 through 9.\n\n```\n     Zero is four, four is magic.\n     One is three, three is five, five is four, four is magic.\n     Two is three, three is five, five is four, four is magic.\n     Three is five, five is four, four is magic.\n     Four is magic.\n     Five is four, four is magic.\n     Six is three, three is five, five is four, four is magic.\n     Seven is five, five is four, four is magic.\n     Eight is five, five is four, four is magic.\n     Nine is four, four is magic.\n\n```\n\nSome task guidelines\n:   * You may assume the input will only contain integer numbers.\n    * Cardinal numbers between 20 and 100 may use either hyphens or spaces as word separators but they must use a word separator. (**23** is **twenty three** or **twenty-three** not **twentythree**.)\n    * Cardinal number conversions should follow the English short scale. (billion is 1e9, trillion is 1e12, etc.)\n    * Cardinal numbers should not include commas. (**20140** is **twenty thousand one hundred forty** not **twenty thousand, one hundred forty**.)\n    * When converted to a string, **100** should be **one hundred**, not **a hundred** or **hundred**, **1000** should be **one thousand**, not **a thousand** or **thousand**.\n    * When converted to a string, there should be no **and** in the cardinal string. **130** should be **one hundred thirty** not **one hundred and thirty**.\n    * When counting characters, count *all* of the characters in the cardinal number including spaces and hyphens. **One hundred fifty-one** should be **21** not **18**.\n    * The output should follow the format \"N is K, K is M, M is ... four is magic.\" (unless the input is 4, in which case the output should simply be \"four is magic.\")\n    * The output can either be the return value from the function, or be displayed from within the function.\n    * You are encouraged, though not mandated to use proper sentence capitalization.\n    * You may optionally support negative numbers. **-7** is **negative seven**.\n    * Show the output here for a small representative sample of values, at least 5 but no more than 25. You are free to choose which which numbers to use for output demonstration.\n\nYou can choose to use a library, (module, external routine, whatever) to do the cardinal conversions as long as the code is easily and freely available to the public.\n\nIf you roll your own, make the routine accept at minimum any integer from 0 up to 999999. If you use a pre-made library, support at least up to unsigned 64 bit integers. (or the largest integer supported in your language if it is less.)\n\nFour is magic is a popular code-golf task. **This is not code golf.** Write legible, idiomatic and well formatted code.\n\nRelated tasks\n:   * Four is the number of\\_letters in the ...\n    * Look-and-say sequence\n    * Number names\n    * Self-describing numbers\n    * Summarize and say sequence\n    * Spelling of ordinal numbers\n    * De Bruijn sequences"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nLingua::EN::Numbers module available from the Raku ecosystem.\n\n```\nuse Lingua::EN::Numbers; # Version 2.4.0 or higher\n\nsub card ($n) { cardinal($n).subst(/','/, '', :g) }\n\nsub magic (Int $int is copy) {\n    my $string;\n    loop {\n       $string ~= \"{ card($int) } is \";\n       if $int = ($int == 4) ?? 0 !! card($int).chars {\n           $string ~= \"{ card($int) }, \"\n       } else {\n           $string ~= \"magic.\\n\";\n           last\n       }\n   }\n   $string.tc\n}\n\n.&magic.say for 0, 4, 6, 11, 13, 75, 337, -164, 9876543209, 2**256;\n\n```\n\nOutput:\n\n```\nZero is four, four is magic.\n\nFour is magic.\n\nSix is three, three is five, five is four, four is magic.\n\nEleven is six, six is three, three is five, five is four, four is magic.\n\nThirteen is eight, eight is five, five is four, four is magic.\n\nSeventy-five is twelve, twelve is six, six is three, three is five, five is four, four is magic.\n\nThree hundred thirty-seven is twenty-six, twenty-six is ten, ten is three, three is five, five is four, four is magic.\n\nNegative one hundred sixty-four is thirty-one, thirty-one is ten, ten is three, three is five, five is four, four is magic.\n\nNine billion eight hundred seventy-six million five hundred forty-three thousand two hundred nine is ninety-seven, ninety-seven is twelve, twelve is six, six is three, three is five, five is four, four is magic.\n\nOne hundred fifteen quattuorvigintillion seven hundred ninety-two trevigintillion eighty-nine duovigintillion two hundred thirty-seven unvigintillion three hundred sixteen vigintillion one hundred ninety-five novemdecillion four hundred twenty-three octodecillion five hundred seventy septendecillion nine hundred eighty-five sexdecillion eight quindecillion six hundred eighty-seven quattuordecillion nine hundred seven tredecillion eight hundred fifty-three duodecillion two hundred sixty-nine undecillion nine hundred eighty-four decillion six hundred sixty-five nonillion six hundred forty octillion five hundred sixty-four septillion thirty-nine sextillion four hundred fifty-seven quintillion five hundred eighty-four quadrillion seven trillion nine hundred thirteen billion one hundred twenty-nine million six hundred thirty-nine thousand nine hundred thirty-six is eight hundred sixty-nine, eight hundred sixty-nine is twenty-four, twenty-four is eleven, eleven is six, six is three, three is five, five is four, four is magic.\n```"}]}
{"messages": [{"role": "user", "content": "The      **Four is ...**      sequence is based on the counting of the number of\nletters in the words of the (never─ending) sentence:\n\n```\n  Four is the number of letters in the first word of this sentence, two in the second,\n  three in the third, six in the fourth, two in the fifth, seven in the sixth, ··· \n\n```\n\nDefinitions and directives\n:   * English is to be used in spelling numbers.\n    * **Letters**   are defined as the upper─ and lowercase letters in the Latin alphabet   (**A──►Z**   and   **a──►z**).\n    * Commas are not counted,   nor are hyphens (dashes or minus signs).\n    * **twenty─three**   has eleven letters.\n    * **twenty─three**   is considered one word   (which is hyphenated).\n    * no    ***and***    words are to be used when spelling a (English) word for a number.\n    * The short scale numbering system (i.e. 2,000,000,000 is two billion) will be used here. wp:Long and short scales\n\n```\n         2,000,000,000   is two billion,   not   two milliard.\n\n```\n\nTask\n:   * Write a driver (invoking routine) and a function (subroutine/routine···) that returns the sequence (for any positive integer) of the number of letters in the first   **N**   words in the never─ending sentence.   For instance, the portion of the never─ending sentence shown above (2nd sentence of this task's preamble),   the sequence would be:\n\n```\n         4  2  3  6  2  7\n\n```\n\n:   * Only construct as much as is needed for the never─ending sentence.\n    * Write a driver (invoking routine) to show the number of letters in the   Nth   word,   *as well as*   showing the   Nth   word itself.\n    * After each test case, show the total number of characters   (including blanks, commas, and punctuation)   of the sentence that was constructed.\n    * Show all output here.\n\nTest cases\n\n```\n Display the first  201  numbers in the sequence   (and the total number of characters in the sentence).\n Display the number of letters  (and the word itself)  of the       1,000th  word.\n Display the number of letters  (and the word itself)  of the      10,000th  word.\n Display the number of letters  (and the word itself)  of the     100,000th  word.\n Display the number of letters  (and the word itself)  of the   1,000,000th  word.\n Display the number of letters  (and the word itself)  of the  10,000,000th  word  (optional).\n\n```\n\nRelated tasks\n:   * Four is magic\n    * Look-and-say sequence\n    * Number names\n    * Self-describing numbers\n    * Self-referential sequence\n    * Spelling of ordinal numbers\n\nAlso see\n:   * See the OEIS sequence A72425 \"Four is the number of letters...\".\n    * See the OEIS sequence A72424 \"Five's the number of letters...\""}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nUses the Lingua::EN::Numbers module to generate both cardinal and ordinal numbers. This module places commas in number words between 3-orders-of-magnitude clusters. E.G. `12345678.&ordinal` becomes: twelve million, three hundred forty-five thousand, six hundred seventy-eighth. Uses a custom 'no-commas' routine to filter them out for accurate character counts. Generates the 'sentence' lazily so only the words needed are ever calculated and reified.\n\n```\nuse Lingua::EN::Numbers;\nno-commas(True);\n\nmy $index = 1;\nmy @sentence = flat 'Four is the number of letters in the first word of this sentence, '.words,\n  { @sentence[$index++].&alpha.&cardinal, 'in', 'the', |($index.&ordinal ~ ',').words } ... * ;\n\nsub alpha ( $str ) { $str.subst(/\\W/, '', :g).chars }\nsub count ( $index ) { @sentence[^$index].join(' ').chars ~ \" characters in the sentence, up to and including this word.\\n\" }\n\nsay 'First 201 word lengths in the sequence:';\nput ' ', map { @sentence[$_].&alpha.fmt(\"%2d\") ~ (((1+$_) %% 25) ?? \"\\n\" !! '') }, ^201;\nsay 201.&count;\n\nfor 1e3, 1e4, 1e5, 1e6, 1e7 {\n    say \"{.&ordinal.tc} word, '{@sentence[$_ - 1]}', has {@sentence[$_ - 1].&alpha} characters. \", .&count\n}\n\n```\n\nOutput:\n\n```\nFirst 201 word lengths in the sequence:\n  4  2  3  6  2  7  2  3  5  4  2  4  8  3  2  3  6  5  2  3  5  3  2  3  6\n  3  2  3  5  5  2  3  5  3  2  3  7  5  2  3  6  4  2  3  5  4  2  3  5  3\n  2  3  8  4  2  3  7  5  2  3 10  5  2  3 10  3  2  3  9  5  2  3  9  3  2\n  3 11  4  2  3 10  3  2  3 10  5  2  3  9  4  2  3 11  5  2  3 12  3  2  3\n 11  5  2  3 12  3  2  3 11  5  2  3 11  3  2  3 13  5  2  3 12  4  2  3 11\n  4  2  3  9  3  2  3 11  5  2  3 12  4  2  3 11  5  2  3 12  3  2  3 11  5\n  2  3 11  5  2  3 13  4  2  3 12  3  2  3 11  5  2  3  8  3  2  3 10  4  2\n  3 11  3  2  3 10  5  2  3 11  4  2  3 10  4  2  3 10  3  2  3 12  5  2  3\n 11\n1203 characters in the sentence, up to and including this word.\n\nOne thousandth word, 'in', has 2 characters. 6249 characters in the sentence, up to and including this word.\n\nTen thousandth word, 'in', has 2 characters. 64097 characters in the sentence, up to and including this word.\n\nOne hundred thousandth word, 'one', has 3 characters. 659455 characters in the sentence, up to and including this word.\n\nOne millionth word, 'the', has 3 characters. 7113560 characters in the sentence, up to and including this word.\n\nTen millionth word, 'thousand', has 8 characters. 70995729 characters in the sentence, up to and including this word.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFill with 1's the four sides of square. The rest of the square should be filled with 0's.\n  \nIf you can please use GUI\n  \nFour sides of square - image\n\n### See also\n\n* Matrix with two diagonals\n* Mosaic matrix"}, {"role": "assistant", "content": "This isn't a matrix, especially if it is supposed to be graphical; it's a very small (or extremely low resolution) bitmap.\n\n```\nsub hollow ($n) { [1 xx $n], |(0 ^..^ $n).map( { [flat 1, 0 xx $n - 2, 1] } ), [1 xx $n] }\n\n.put for hollow 7;\nput '';\n.put for hollow 10;\n\n```\n\nOutput:\n\n```\n1 1 1 1 1 1 1\n1 0 0 0 0 0 1\n1 0 0 0 0 0 1\n1 0 0 0 0 0 1\n1 0 0 0 0 0 1\n1 0 0 0 0 0 1\n1 0 0 0 0 0 1\n1 1 1 1 1 1 1\n\n1 1 1 1 1 1 1 1 1 1\n1 0 0 0 0 0 0 0 0 1\n1 0 0 0 0 0 0 0 0 1\n1 0 0 0 0 0 0 0 0 1\n1 0 0 0 0 0 0 0 0 1\n1 0 0 0 0 0 0 0 0 1\n1 0 0 0 0 0 0 0 0 1\n1 0 0 0 0 0 0 0 0 1\n1 0 0 0 0 0 0 0 0 1\n1 0 0 0 0 0 0 0 0 1\n1 1 1 1 1 1 1 1 1 1\n```"}]}
{"messages": [{"role": "user", "content": "Generate and draw a fractal tree.\n\n1. Draw the trunk\n2. At the end of the trunk, split by some angle and draw two branches\n3. Repeat at the end of each branch until a sufficient level of branching is reached\n\nRelated tasks\n\n* Pythagoras Tree"}, {"role": "assistant", "content": "(formerly Perl 6)\nImage is created in SVG format.\n\n```\nmy ($width, $height) = (1000,1000); # image dimension\nmy $scale = 6/10; # branch scale relative to trunk\nmy $length = 400; # trunk size\n\nsay \"<?xml version='1.0' encoding='utf-8' standalone='no'?>\n<!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' \n'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'>\n<svg width='100%' height='100%' version='1.1'\nxmlns='http://www.w3.org/2000/svg'>\";\n\ntree($width/2, $height, $length, 3*pi/2);\n\nsay \"</svg>\";\n\nmulti tree($, $, $length where { $length < 1}, $) {}\nmulti tree($x, $y, $length, $angle)\n{\n\tmy ($x2, $y2) = ( $x + $length * $angle.cos, $y + $length * $angle.sin);\n\tsay \"<line x1='$x' y1='$y' x2='$x2' y2='$y2' style='stroke:rgb(0,0,0);stroke-width:1'/>\";\n\ttree($x2, $y2, $length*$scale, $angle + pi/5);\n\ttree($x2, $y2, $length*$scale, $angle - pi/5);\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "```\n              There is a fine line between numerator and denominator.       ─── anonymous\n\n```\n\nA method to   \"reduce\"   some reducible fractions is to   *cross out*   a digit from the\nnumerator and the denominator.   An example is:\n\n```\n       16                                                  16\n      ────     and then (simply) cross─out the sixes:      ────\n       64                                                  64\n\n```\n\nresulting in:\n\n```\n        1\n       ───    \n        4\n\n```\n\nNaturally,   this \"method\" of reduction must reduce to the proper value   (shown as a fraction).\n\nThis \"method\" is also known as   *anomalous cancellation*   and also   *accidental cancellation*.\n\n(Of course,   this \"method\" shouldn't be taught to impressionable or gullible minds.)        😇\n\nTask\n\nFind and show some fractions that can be reduced by the above \"method\".\n\n:   * show 2-digit fractions found   (like the example shown above)\n    * show 3-digit fractions\n    * show 4-digit fractions\n    * show 5-digit fractions   (and higher)       *(optional)*\n    * show each (above) n-digit fractions separately from other different n-sized fractions, don't mix different \"sizes\" together\n    * for each \"size\" fraction,   only show a dozen examples   (the 1st twelve found)\n    * (it's recognized that not every programming solution will have the same generation algorithm)\n    * for each \"size\" fraction:\n\n    :   :   * show a count of how many reducible fractions were found.   The example (above) is size **2**\n            * show a count of which digits were crossed out   (one line for each different digit)\n\n    * for each \"size\" fraction,   show a count of how many were found.   The example (above) is size **2**\n    * show each n-digit example   (to be shown on one line):\n\n    :   :   * show each n-digit fraction\n            * show each reduced n-digit fraction\n            * show what digit was crossed out for the numerator and the denominator\n\nTask requirements/restrictions\n:   * only proper fractions and their reductions   (the result)   are to be used   (no vulgar fractions)\n    * only positive fractions are to be used   (no negative signs anywhere)\n    * only base ten integers are to be used for the numerator and denominator\n    * no zeros   (decimal digit)   can be used within the numerator or the denominator\n    * the numerator and denominator should be composed of the same number of digits\n    * no digit can be repeated in the numerator\n    * no digit can be repeated in the denominator\n    * (naturally)   there should be a shared decimal digit in the numerator   *and*   the denominator\n    * fractions can be shown as   16/64   (for example)\n\nShow all output here, on this page.\n\nSomewhat related task\n:   * Farey sequence       (It concerns fractions.)\n\nReferences\n:   * Wikipedia entry:   proper and improper fractions.\n    * Wikipedia entry:   anomalous cancellation and/or accidental cancellation."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nAnomalous Cancellation\n\n```\nmy %reduced;\nmy $digits = 2..4;\n\nfor $digits.map: * - 1 -> $exp {\n    my $start = sum (0..$exp).map( { 10 ** $_ * ($exp - $_ + 1) });\n    my $end   = 10**($exp+1) - sum (^$exp).map( { 10 ** $_ * ($exp - $_) } ) - 1;\n\n    ($start ..^ $end).race(:8degree, :3batch).map: -> $den {\n        next if $den.contains: '0';\n        next if $den.comb.unique <= $exp;\n\n        for $start ..^ $den -> $num {\n            next if $num.contains: '0';\n            next if $num.comb.unique <= $exp;\n\n            my $set = ($den.comb.head(* - 1).Set ∩ $num.comb.skip(1).Set);\n            next if $set.elems < 1;\n\n            for $set.keys {\n                my $ne = $num.trans: $_ => '', :delete;\n                my $de = $den.trans: $_ => '', :delete;\n                if $ne / $de == $num / $den {\n                    print \"\\b\" x 40, \"$num/$den:$_ => $ne/$de\";\n                    %reduced{\"$num/$den:$_\"} = \"$ne/$de\";\n                }\n            }\n        }\n    }\n\n\n    print \"\\b\" x 40, ' ' x 40, \"\\b\" x 40;\n\n    my $digit = $exp +1;\n    my %d = %reduced.pairs.grep: { .key.chars == ($digit * 2 + 3) };\n    say \"\\n({+%d}) $digit digit reduceable fractions:\";\n    for 1..9 {\n        my $cnt = +%d.pairs.grep( *.key.contains: \":$_\" );\n        next unless $cnt;\n        say \"  $cnt with removed $_\";\n    }\n    say \"\\n  12 Random (or all, if less) $digit digit reduceable fractions:\";\n    say \"    {.key.substr(0, $digit * 2 + 1)} => {.value} removed {.key.substr(* - 1)}\"\n      for %d.pairs.pick(12).sort;\n}\n\n```\n\nSample output:\n\n```\n(4) 2 digit reduceable fractions:\n  2 with removed 6\n  2 with removed 9\n\n  12 Random (or all, if less) 2 digit reduceable fractions:\n    16/64 => 1/4 removed 6\n    19/95 => 1/5 removed 9\n    26/65 => 2/5 removed 6\n    49/98 => 4/8 removed 9\n\n(122) 3 digit reduceable fractions:\n  9 with removed 3\n  1 with removed 4\n  6 with removed 5\n  15 with removed 6\n  16 with removed 7\n  15 with removed 8\n  60 with removed 9\n\n  12 Random (or all, if less) 3 digit reduceable fractions:\n    149/298 => 14/28 removed 9\n    154/352 => 14/32 removed 5\n    165/264 => 15/24 removed 6\n    176/275 => 16/25 removed 7\n    187/286 => 17/26 removed 8\n    194/291 => 14/21 removed 9\n    286/385 => 26/35 removed 8\n    286/682 => 26/62 removed 8\n    374/572 => 34/52 removed 7\n    473/572 => 43/52 removed 7\n    492/984 => 42/84 removed 9\n    594/693 => 54/63 removed 9\n\n(660) 4 digit reduceable fractions:\n  14 with removed 1\n  25 with removed 2\n  92 with removed 3\n  14 with removed 4\n  29 with removed 5\n  63 with removed 6\n  16 with removed 7\n  17 with removed 8\n  390 with removed 9\n\n  12 Random (or all, if less) 4 digit reduceable fractions:\n    1348/4381 => 148/481 removed 3\n    1598/3196 => 158/316 removed 9\n    1783/7132 => 178/712 removed 3\n    1978/5934 => 178/534 removed 9\n    2971/5942 => 271/542 removed 9\n    2974/5948 => 274/548 removed 9\n    3584/4592 => 384/492 removed 5\n    3791/5798 => 391/598 removed 7\n    3968/7936 => 368/736 removed 9\n    4329/9324 => 429/924 removed 3\n    4936/9872 => 436/872 removed 9\n    6327/8325 => 627/825 removed 3\n```"}]}
{"messages": [{"role": "user", "content": "**FRACTRAN** is a Turing-complete esoteric programming language invented by the mathematician John Horton Conway.\n\nA FRACTRAN program is an ordered list of positive fractions \n\nP\n=\n(\n\nf\n\n1\n,\n\nf\n\n2\n,\n…\n,\n\nf\n\nm\n)\n{\\displaystyle {\\displaystyle P=(f\\_{1},f\\_{2},\\ldots ,f\\_{m})}}\n, together with an initial positive integer input \n\nn\n{\\displaystyle {\\displaystyle n}}\n.\n\nThe program is run by updating the integer \n\nn\n{\\displaystyle {\\displaystyle n}}\n as follows:\n\n* for the first fraction, \n\n  f\n\n  i\n  {\\displaystyle {\\displaystyle f\\_{i}}}\n  , in the list for which \n\n  n\n\n  f\n\n  i\n  {\\displaystyle {\\displaystyle nf\\_{i}}}\n   is an integer, replace \n\n  n\n  {\\displaystyle {\\displaystyle n}}\n   with \n\n  n\n\n  f\n\n  i\n  {\\displaystyle {\\displaystyle nf\\_{i}}}\n   ;\n* repeat this rule until no fraction in the list produces an integer when multiplied by \n\n  n\n  {\\displaystyle {\\displaystyle n}}\n  , then halt.\n\nConway gave a program for primes in FRACTRAN:\n\n:   17\n\n    /\n    91\n    {\\displaystyle {\\displaystyle 17/91}}\n    , \n\n    78\n\n    /\n    85\n    {\\displaystyle {\\displaystyle 78/85}}\n    , \n\n    19\n\n    /\n    51\n    {\\displaystyle {\\displaystyle 19/51}}\n    , \n\n    23\n\n    /\n    38\n    {\\displaystyle {\\displaystyle 23/38}}\n    , \n\n    29\n\n    /\n    33\n    {\\displaystyle {\\displaystyle 29/33}}\n    , \n\n    77\n\n    /\n    29\n    {\\displaystyle {\\displaystyle 77/29}}\n    , \n\n    95\n\n    /\n    23\n    {\\displaystyle {\\displaystyle 95/23}}\n    , \n\n    77\n\n    /\n    19\n    {\\displaystyle {\\displaystyle 77/19}}\n    , \n\n    1\n\n    /\n    17\n    {\\displaystyle {\\displaystyle 1/17}}\n    , \n\n    11\n\n    /\n    13\n    {\\displaystyle {\\displaystyle 11/13}}\n    , \n\n    13\n\n    /\n    11\n    {\\displaystyle {\\displaystyle 13/11}}\n    , \n\n    15\n\n    /\n    14\n    {\\displaystyle {\\displaystyle 15/14}}\n    , \n\n    15\n\n    /\n    2\n    {\\displaystyle {\\displaystyle 15/2}}\n    , \n\n    55\n\n    /\n    1\n    {\\displaystyle {\\displaystyle 55/1}}\n\nStarting with \n\nn\n=\n2\n{\\displaystyle {\\displaystyle n=2}}\n, this FRACTRAN program will change \n\nn\n{\\displaystyle {\\displaystyle n}}\n to \n\n15\n=\n2\n×\n(\n15\n\n/\n2\n)\n{\\displaystyle {\\displaystyle 15=2\\times (15/2)}}\n, then \n\n825\n=\n15\n×\n(\n55\n\n/\n1\n)\n{\\displaystyle {\\displaystyle 825=15\\times (55/1)}}\n, generating the following sequence of integers:\n\n:   2\n    {\\displaystyle {\\displaystyle 2}}\n    , \n\n    15\n    {\\displaystyle {\\displaystyle 15}}\n    , \n\n    825\n    {\\displaystyle {\\displaystyle 825}}\n    , \n\n    725\n    {\\displaystyle {\\displaystyle 725}}\n    , \n\n    1925\n    {\\displaystyle {\\displaystyle 1925}}\n    , \n\n    2275\n    {\\displaystyle {\\displaystyle 2275}}\n    , \n\n    425\n    {\\displaystyle {\\displaystyle 425}}\n    , \n\n    390\n    {\\displaystyle {\\displaystyle 390}}\n    , \n\n    330\n    {\\displaystyle {\\displaystyle 330}}\n    , \n\n    290\n    {\\displaystyle {\\displaystyle 290}}\n    , \n\n    770\n    {\\displaystyle {\\displaystyle 770}}\n    , \n\n    …\n    {\\displaystyle {\\displaystyle \\ldots }}\n\nAfter 2, this sequence contains the following powers of 2:\n\n:   2\n\n    2\n    =\n    4\n    {\\displaystyle {\\displaystyle 2^{2}=4}}\n    , \n\n    2\n\n    3\n    =\n    8\n    {\\displaystyle {\\displaystyle 2^{3}=8}}\n    , \n\n    2\n\n    5\n    =\n    32\n    {\\displaystyle {\\displaystyle 2^{5}=32}}\n    , \n\n    2\n\n    7\n    =\n    128\n    {\\displaystyle {\\displaystyle 2^{7}=128}}\n    , \n\n    2\n\n    11\n    =\n    2048\n    {\\displaystyle {\\displaystyle 2^{11}=2048}}\n    , \n\n    2\n\n    13\n    =\n    8192\n    {\\displaystyle {\\displaystyle 2^{13}=8192}}\n    , \n\n    2\n\n    17\n    =\n    131072\n    {\\displaystyle {\\displaystyle 2^{17}=131072}}\n    , \n\n    2\n\n    19\n    =\n    524288\n    {\\displaystyle {\\displaystyle 2^{19}=524288}}\n    , \n\n    …\n    {\\displaystyle {\\displaystyle \\ldots }}\n\nwhich are the prime powers of 2.\n\nTask\n\nWrite a program that reads a list of fractions in a *natural* format from the keyboard or from a string,\nto parse it into a sequence of fractions (*i.e.* two integers),\nand runs the FRACTRAN starting from a provided integer, writing the result at each step.\nIt is also required that the number of steps is limited (by a parameter easy to find).\n\nExtra credit\n\nUse this program to derive the first **20** or so prime numbers.\n\nSee also\n\nFor more on how to program FRACTRAN as a universal programming language, see:\n\n* J. H. Conway (1987). Fractran: A Simple Universal Programming Language for Arithmetic. In: Open Problems in Communication and Computation, pages 4–26. Springer.\n\n* J. H. Conway (2010). \"FRACTRAN: A simple universal programming language for arithmetic\". In Jeffrey C. Lagarias. The Ultimate Challenge: the 3x+1 problem. American Mathematical Society. pp. 249–264. ISBN 978-0-8218-4940-8. Zbl 1216.68068.\n\n* Number Pathology: Fractran by Mark C. Chu-Carroll; October 27, 2006."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-11-03\n\nA Fractran program potentially returns an infinite list, and infinite lists are a common data structure in Raku. The limit is therefore enforced only by slicing the infinite list.\n\n```\nsub fractran(@program) {\n    2, { first Int, map (* * $_).narrow, @program } ... 0\n}\nsay fractran(<17/91 78/85 19/51 23/38 29/33 77/29 95/23 77/19 1/17 11/13 13/11\n        15/14 15/2 55/1>)[^100];\n\n```\n\nOutput:\n\n```\n(2 15 825 725 1925 2275 425 390 330 290 770 910 170 156 132 116 308 364 68 4 30 225 12375 10875 28875 25375 67375 79625 14875 13650 2550 2340 1980 1740 4620 4060 10780 12740 2380 2184 408 152 92 380 230 950 575 2375 9625 11375 2125 1950 1650 1450 3850 4550 850 780 660 580 1540 1820 340 312 264 232 616 728 136 8 60 450 3375 185625 163125 433125 380625 1010625 888125 2358125 2786875 520625 477750 89250 81900 15300 14040 11880 10440 27720 24360 64680 56840 150920 178360 33320 30576 5712 2128 1288)\n```\n\n**Extra credit:**\nWe can weed out all the powers of two into another infinite constant list based on the first list. In this case the sequence is limited only by our patience, and a ^C from the terminal. The .msb method finds the most significant bit of an integer, which conveniently is the base-2 log of the power-of-two in question.\n\n```\nsub fractran(@program) {\n    2, { first Int, map (* * $_).narrow, @program } ... 0\n}\nfor fractran <17/91 78/85 19/51 23/38 29/33 77/29 95/23 77/19 1/17 11/13 13/11\n        15/14 15/2 55/1> {\n        say $++, \"\\t\", .msb, \"\\t\", $_ if 1 +< .msb == $_;\n}\n\n```\n\nOutput:\n\n```\n0       1       2\n1\t2\t4\n2\t3\t8\n3\t5\t32\n4\t7\t128\n5\t11\t2048\n6\t13\t8192\n7\t17\t131072\n8\t19\t524288\n9\t23\t8388608\n^C\n```"}]}
{"messages": [{"role": "user", "content": "Write a program to convert dates between the Gregorian calendar and the French Republican calendar.\n\nThe year 1 of the Republican calendar began on 22 September 1792. There were twelve months (Vendémiaire, Brumaire, Frimaire, Nivôse, Pluviôse, Ventôse, Germinal, Floréal, Prairial, Messidor, Thermidor, and Fructidor) of 30 days each, followed by five intercalary days or *Sansculottides* (*Fête de la vertu* / Virtue Day, *Fête du génie* / Talent Day, *Fête du travail* / Labour Day, *Fête de l'opinion* / Opinion Day, and *Fête des récompenses* / Honours Day). In leap years (the years 3, 7, and 11) a sixth *Sansculottide* was added: *Fête de la Révolution* / Revolution Day.\n\nAs a minimum, your program should give correct results for dates in the range from 1 Vendémiaire 1 = 22 September 1792 to 10 Nivôse 14 = 31 December 1805 (the last day when the Republican calendar was officially in use). If you choose to accept later dates, be aware that there are several different methods (described on the Wikipedia page) about how to determine leap years after the year 14. You should indicate which method you are using. (Because of these different methods, correct programs may sometimes give different results for dates after 1805.)\n\nTest your program by converting the following dates both from Gregorian to Republican and from Republican to Gregorian:\n\n• 1 Vendémiaire 1 = 22 September 1792\n\n• 1 Prairial 3 = 20 May 1795\n\n• 27 Messidor 7 = 15 July 1799 *(Rosetta Stone discovered)*\n\n• Fête de la Révolution 11 = 23 September 1803\n\n• 10 Nivôse 14 = 31 December 1805"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nuse v6;\nconstant @month_names = <\n    Vendémiaire Brumaire Frimaire  Nivôse   Pluviôse  Ventôse\n    Germinal    Floréal  Prairial  Messidor Thermidor Fructidor\n>;\nconstant @intercalary =\n    'Fête de la vertu',  'Fête du génie',        'Fête du travail',\n    \"Fête de l'opinion\", 'Fête des récompenses', 'Fête de la Révolution',\n;\nconstant %month_nums  = %( @month_names Z=> 1..12 );\nconstant %i_cal_nums  = %( @intercalary Z=> 1.. 6 );\nconstant $i_cal_month = 13;\nconstant $epoch       = Date.new: '1792-09-22';\n\nsub is_republican_leap_year ( Int:D $year --> Bool ) {\n    my $y := $year + 1;\n    return ?( $y %% 4 and ($y !%% 100 or $y %% 400) );\n}\n\nsub Republican_to_Gregorian ( Str:D $rep_date --> Date ) {\n    grammar Republican_date_text {\n        token day   { \\d+ }\n        token year  { \\d+ }\n        token ic    { @intercalary }\n        token month { @month_names }\n        rule TOP    { ^ [ <ic> | <day> <month> ] <year> $ }\n    }\n    \n    Republican_date_text.parse($rep_date)\n        orelse die \"Republican date not recognized: '$rep_date'\";\n\n    my $day1   := $/<ic>    ?? %i_cal_nums{~$/<ic>}    !! +$/<day>;\n    my $month1 := $/<month> ?? %month_nums{~$/<month>} !! $i_cal_month;\n\n    my @ymd0 := ($/<year>, $month1, $day1) »-» 1;\n    my $days_since_epoch := [+] @ymd0 Z* (365, 30, 1);\n\n    my $leap_days := +grep &is_republican_leap_year, 1 ..^ $/<year>;\n    return $epoch + $days_since_epoch + $leap_days;\n}\n\nsub Gregorian_to_Republican ( Date:D $greg_date --> Str ) {\n    my $days_since_epoch := $greg_date - $epoch;\n    die if $days_since_epoch < 0;\n\n    my ( $year, $days ) = 1, $days_since_epoch;\n    loop {\n        my $year_length = 365 + (1 if $year.&is_republican_leap_year);\n        last if $days < $year_length;\n        $days -= $year_length;\n        $year += 1;\n    }\n\n    my ( $day0, $month0 ) = $days.polymod( 30 );\n    my ( $day1, $month1 ) = ($day0, $month0) X+ 1;\n\n    return $month1 == $i_cal_month\n        ??       \"@intercalary[$day0  ] $year\"\n        !! \"$day1 @month_names[$month0] $year\";\n}\n\nmy @test_data =\n    ( '1792-09-22', '1 Vendémiaire 1' ),\n    ( '1795-05-20', '1 Prairial 3' ),\n    ( '1799-07-15', '27 Messidor 7' ),\n    ( '1803-09-23', 'Fête de la Révolution 11' ),\n    ( '1805-12-31', '10 Nivôse 14' ),\n\n    ( '1871-03-18', '27 Ventôse 79' ),\n    ( '1944-08-25', '7 Fructidor 152' ),\n    ( '2016-09-19', 'Fête du travail 224' ),\n\n    ( '1871-05-06', '16 Floréal 79'  ), # Paris Commune begins\n    ( '1871-05-23', '3 Prairial 79'  ), # Paris Commune ends\n    ( '1799-11-09', '18 Brumaire 8'  ), # Revolution ends by Napoléon coup\n    ( '1804-12-02', '11 Frimaire 13' ), # Republic   ends by Napoléon coronation\n    ( '1794-10-30', '9 Brumaire 3'   ), # École Normale Supérieure established\n    ( '1794-07-27', '9 Thermidor 2'  ), # Robespierre falls\n    ( '1799-05-27', '8 Prairial 7'   ), # Fromental Halévy born\n\n    ( '1792-09-22', '1 Vendémiaire 1'   ),\n    ( '1793-09-22', '1 Vendémiaire 2'   ),\n    ( '1794-09-22', '1 Vendémiaire 3'   ),\n    ( '1795-09-23', '1 Vendémiaire 4'   ),\n    ( '1796-09-22', '1 Vendémiaire 5'   ),\n    ( '1797-09-22', '1 Vendémiaire 6'   ),\n    ( '1798-09-22', '1 Vendémiaire 7'   ),\n    ( '1799-09-23', '1 Vendémiaire 8'   ),\n    ( '1800-09-23', '1 Vendémiaire 9'   ),\n    ( '1801-09-23', '1 Vendémiaire 10'  ),\n    ( '1802-09-23', '1 Vendémiaire 11'  ),\n    ( '1803-09-24', '1 Vendémiaire 12'  ),\n    ( '1804-09-23', '1 Vendémiaire 13'  ),\n    ( '1805-09-23', '1 Vendémiaire 14'  ),\n    ( '1806-09-23', '1 Vendémiaire 15'  ),\n    ( '1807-09-24', '1 Vendémiaire 16'  ),\n    ( '1808-09-23', '1 Vendémiaire 17'  ),\n    ( '1809-09-23', '1 Vendémiaire 18'  ),\n    ( '1810-09-23', '1 Vendémiaire 19'  ),\n    ( '1811-09-24', '1 Vendémiaire 20'  ),\n    ( '2015-09-23', '1 Vendémiaire 224' ),\n    ( '2016-09-22', '1 Vendémiaire 225' ),\n    ( '2017-09-22', '1 Vendémiaire 226' ),\n;\n\nfor @test_data -> ( $g_text, $r ) {\n    my $g = Date.new: $g_text;\n\n    die if Republican_to_Gregorian($r) != $g\n        or Gregorian_to_Republican($g) ne $r;\n\n    die if Gregorian_to_Republican(Republican_to_Gregorian($r)) ne $r\n        or Republican_to_Gregorian(Gregorian_to_Republican($g)) != $g;\n}\nsay 'All tests successful.';\n\n```\n\nOutput:\n\n```\nAll tests successful.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and display here on this page the Frobenius numbers that are    <    10,000.\n\nThe series is defined by:\n\n```\n     FrobeniusNumber(n)  =  prime(n) * prime(n+1)   -   prime(n)   -   prime(n+1)\n\n```\n\nwhere:\n\n:   :   :   :   prime(1)   =   2\n            :   prime(2)   =   3\n            :   prime(3)   =   5\n            :   prime(4)   =   7\n\n                :   •\n                :   •\n                :   •"}, {"role": "assistant", "content": "```\nsay \"{+$_} matching numbers\\n{.batch(10)».fmt('%4d').join: \"\\n\"}\\n\"\n    given (^1000).grep( *.is-prime ).rotor(2 => -1)\n    .map( { (.[0] * .[1] - .[0] - .[1]) } ).grep(* < 10000);\n\n```\n\nOutput:\n\n```\n25 matching numbers\n   1    7   23   59  119  191  287  395  615  839\n1079 1439 1679 1931 2391 3015 3479 3959 4619 5039\n5615 6395 7215 8447 9599\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nConnect to a server, change directory, list its contents and download a file as binary using the FTP protocol. Use passive mode if available."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.04\n\n```\nuse Net::FTP;\n\nmy $host = 'speedtest.tele2.net';\nmy $user = 'anonymous';\nmy $password = '';\n\nmy $ftp = Net::FTP.new( host => $host, :passive );\n\n$ftp.login( user => $user, pass => $password );\n\n$ftp.cwd( 'upload' );\n\n$ftp.cwd( '/' );\n\nsay $_<name> for $ftp.ls;\n\n$ftp.get( '1KB.zip', :binary );\n\n```\n\nOutput:\n\n```\n1000GB.zip\n100GB.zip\n100KB.zip\n100MB.zip\n10GB.zip\n10MB.zip\n1GB.zip\n1KB.zip\n1MB.zip\n200MB.zip\n20MB.zip\n2MB.zip\n3MB.zip\n500MB.zip\n50MB.zip\n512KB.zip\n5MB.zip\nupload\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a function, compose,   whose two arguments   *f*   and   *g*,   are both functions with one argument.\n\nThe result of compose is to be a function of one argument, (lets call the argument   *x*),   which works like applying function    *f*    to the result of applying function    *g*    to    *x*.\n\nExample\n\n```\n compose(f, g) (x) = f(g(x))\n\n```\n\nReference: Function composition\n\nHint: In some languages, implementing compose correctly requires creating a closure."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\nThe function composition operator is ∘, U+2218 RING OPERATOR (with a \"Texas\" version o for the Unicode challenged). Here we compose a routine, an operator, and a lambda:\n\n```\nsub triple($n) { 3 * $n }\nmy &f = &triple ∘ &prefix:<-> ∘ { $^n + 2 };\nsay &f(5); # prints \"-21\".\n```"}]}
{"messages": [{"role": "user", "content": "A function is a body of code that returns a value.\n\nThe value returned may depend on arguments provided to the function.\n\nTask\n\nWrite a definition of a function called \"multiply\" that takes two arguments and returns their product.\n\n(Argument types should be chosen so as not to distract from showing how functions are created and values returned).\n\nRelated task\n\n* Function prototype"}, {"role": "assistant", "content": "(formerly Perl 6)\nWithout a signature:\n\n```\nsub multiply { return @_[0] * @_[1]; }\n```\n\nThe return is optional on the final statement, since the last expression would return its value anyway. The final semicolon in a block is also optional.\n(Beware that a subroutine without an explicit signature, like this one, magically becomes variadic (rather than nullary) only if `@_` or `%_` appear in the body.) In fact, we can define the variadic version explicitly, which still works for two arguments:\n\n```\nsub multiply { [*] @_ }\n```\n\nWith formal parameters and a return type:\n\n```\nsub multiply (Rat $a, Rat $b --> Rat) { $a * $b }\n```\n\nSame thing:\n\n```\nmy Rat sub multiply (Rat $a, Rat $b) { $a * $b }\n```\n\nIt is possible to define a function in \"lambda\" notation and then bind that into a scope, in which case it works like any function:\n\n```\nmy &multiply := -> $a, $b { $a * $b };\n```\n\nAnother way to write a lambda is with internal placeholder parameters:\n\n```\nmy &multiply := { $^a * $^b };\n```\n\n(And, in fact, our original @\\_ above is just a variadic self-declaring placeholder argument. And the famous Perl \"topic\", $\\_, is just a self-declared parameter to a unary block.)\n\nYou may also curry both built-in and user-defined operators by supplying a \\* (known as \"whatever\") in place of the argument that is *not* to be curried:\n\n```\nmy &multiply := * * *;\n```\n\nThis is not terribly readable in this case due to the visual confusion between the whatever star and the multiplication operator, but Perl knows when it's expecting terms instead of infixes, so only the middle star is multiplication.\nIt tends to work out much better with other operators. In particular, you may\ncurry a cascade of methods with only the original invocant missing:\n\n```\n@list.grep( *.substr(0,1).lc.match(/<[0..9 a..f]>/) )\n```\n\nThis is equivalent to:\n\n```\n@list.grep( -> $obj { $obj.substr(0,1).lc.match(/<[0..9 a..f]>/) } )\n```"}]}
{"messages": [{"role": "user", "content": "Display - for a program or runtime environment (whatever suits the style of your language) - the top ten most frequently occurring functions (or also identifiers or tokens, if preferred).\n\nThis is a static analysis: The question is not how often each function is\nactually executed at runtime, but how often it is used by the programmer.\n\nBesides its practical usefulness, the intent of this task is to show how to do self-inspection within the language."}, {"role": "assistant", "content": "(formerly Perl 6)\nHere we just examine the ast of the Raku compiler (which is written in Raku) to look for function calls.\n\n```\nmy $text = qqx[raku --target=ast @*ARGS[]];\nmy %fun;\nfor $text.lines {\n    %fun{$0}++ if / '(call &' (.*?) ')' /\n}\n\nfor %fun.invert.sort.reverse[^10] { .value.say }\n\n```\n\nOutput:\n\nHere we run it on the strand sort RC entry. Note how Raku considers various operators to really be function calls underneath.\n\n```\n$ ./morefun strand\npop\npostcircumfix:<[ ]>\nunshift\nsucceed\nsplice\nprefix:<->\npush\ninfix:<,>\ninfix:<..>\ninfix:<->\n```"}]}
{"messages": [{"role": "user", "content": "Some languages provide the facility to declare functions and subroutines through the use of function prototyping.\n\nTask\n\nDemonstrate the methods available for declaring prototypes within the language. The provided solutions should include:\n\n* An explanation of any placement restrictions for prototype declarations\n* A prototype declaration for a function that does not require arguments\n* A prototype declaration for a function that requires two arguments\n* A prototype declaration for a function that utilizes varargs\n* A prototype declaration for a function that utilizes optional arguments\n* A prototype declaration for a function that utilizes named parameters\n* Example of prototype declarations for subroutines or procedures (if these differ from functions)\n* An explanation and example of any special forms of prototyping not covered by the above\n\nLanguages that do not provide function prototyping facilities should be omitted from this task."}, {"role": "assistant", "content": "(formerly Perl 6)\nThere is no restriction on placement of prototype declarations. (Actually, we call them \"stub declarations\".) In fact, stub declarations are rarely needed in Raku because post-declaration of functions is allowed, and normal function declarations do not bend the syntax the way they sometimes do in Perl 5.\n\nNote that the ... in all of these stub bodies is literally part of the declaration syntax.\n\nA prototype declaration for a function that does not require arguments (and returns an Int):\n\n```\nsub foo ( --> Int) {...}\n\n```\n\nA prototype declaration for a function that requires two arguments.\nNote that we can omit the variable name and just use the sigil in the stub, since we don't need to reference the argument until the actual definition of the routine. Also, unlike in Perl 5, a sigil like @ defaults to binding a single positional argument.\n\n```\nsub foo (@, $ --> Int) {...}\n\n```\n\nA prototype declaration for a function that utilizes varargs after one required argument.\nNote the \"slurpy\" star turns the @ sigil into a parameter that accepts all the rest of the positional arguments.\n\n```\nsub foo ($, *@ --> Int) {...}\n\n```\n\nA prototype declaration for a function that utilizes optional arguments after one required argument. Optionality is conferred by either a question mark or a default:\n\n```\nsub foo ($, $?, $ = 42 --> Int) {...}\n\n```\n\nA prototype declaration for a function that utilizes named parameters:\n\n```\nsub foo ($, :$faster, :$cheaper --> Int) {...}\n\n```\n\nExample of prototype declarations for subroutines or procedures, which in Raku is done simply by noting that nothing is returned:\n\n```\nsub foo ($, $ --> Nil) {...}\n\n```\n\nA routine may also slurp up all the named arguments that were not bound earlier in the signature:\n\n```\nsub foo ($, :$option, *% --> Int) {...}\n\n```\n\nA routine may make a named parameter mandatory using exclamation mark. (This is more useful in multi subs than in stubs though.)\n\n```\nsub foo ($, :$option! --> Int) {...}\n\n```\n\nA routine may unpack an Array automaticly. Here the first element is stored in a scalar and the rest in an Array. Other buildin types can be unpacked as well.\n\n```\nsub foo ([$, @]) {...}\n\n```\n\nA routine may ask for a closure parameter to implement higher order functions. Typed or untyped signatures can be supplied.\n\n```\nsub foo (@, &:(Str --> Int)) {...}\n\n```"}]}
{"messages": [{"role": "user", "content": "Functional coverage is a measure of how much a particular function of a system\nhas been verified as correct. It is used heavily in tracking the completeness\nof the verification of complex System on Chip (SoC) integrated circuits, where\nit can also be used to track how well the functional *requirements* of the\nsystem have been verified.\n\nThis task uses a sub-set of the calculations sometimes used in tracking\nfunctional coverage but uses a more familiar(?) scenario.\n\nTask Description\n\nThe head of the clean-up crews for \"The Men in a very dark shade of grey when\nviewed at night\" has been tasked with managing the cleansing of two properties\nafter an incident involving aliens.\n\nShe arranges the task hierarchically with a manager for the crews working on\neach house who return with a breakdown of how they will report on progress in\neach house.\n\nThe overall hierarchy of (sub)tasks is as follows,\n\n```\ncleaning\n    house1\n        bedrooms\n        bathrooms\n            bathroom1\n            bathroom2\n            outside lavatory\n        attic\n        kitchen\n        living rooms\n            lounge\n            dining room\n            conservatory\n            playroom\n        basement\n        garage\n        garden\n    house2\n        upstairs\n            bedrooms\n                suite 1\n                suite 2\n                bedroom 3\n                bedroom 4\n            bathroom\n            toilet\n            attics\n        groundfloor\n            kitchen\n            living rooms\n                lounge\n                dining room\n                conservatory\n                playroom\n            wet room & toilet\n            garage\n            garden\n            hot tub suite\n        basement\n            cellars\n            wine cellar\n            cinema\n```\n\nThe head of cleanup knows that her managers will report fractional completion of leaf tasks (tasks with no child tasks of their own), and she knows that she will want to modify the weight of values of completion as she sees fit.\n\nSome time into the cleaning, and some coverage reports have come in and she thinks see needs to weight the big house2 60-40 with respect to coverage from house1 She prefers a tabular view of her data where missing weights are assumed to be 1.0 and missing coverage 0.0.\n\n```\nNAME_HIERARCHY                  |WEIGHT  |COVERAGE  |\ncleaning                        |        |          |\n    house1                      |40      |          |\n        bedrooms                |        |0.25      |\n        bathrooms               |        |          |\n            bathroom1           |        |0.5       |\n            bathroom2           |        |          |\n            outside_lavatory    |        |1         |\n        attic                   |        |0.75      |\n        kitchen                 |        |0.1       |\n        living_rooms            |        |          |\n            lounge              |        |          |\n            dining_room         |        |          |\n            conservatory        |        |          |\n            playroom            |        |1         |\n        basement                |        |          |\n        garage                  |        |          |\n        garden                  |        |0.8       |\n    house2                      |60      |          |\n        upstairs                |        |          |\n            bedrooms            |        |          |\n                suite_1         |        |          |\n                suite_2         |        |          |\n                bedroom_3       |        |          |\n                bedroom_4       |        |          |\n            bathroom            |        |          |\n            toilet              |        |          |\n            attics              |        |0.6       |\n        groundfloor             |        |          |\n            kitchen             |        |          |\n            living_rooms        |        |          |\n                lounge          |        |          |\n                dining_room     |        |          |\n                conservatory    |        |          |\n                playroom        |        |          |\n            wet_room_&_toilet   |        |          |\n            garage              |        |          |\n            garden              |        |0.9       |\n            hot_tub_suite       |        |1         |\n        basement                |        |          |\n            cellars             |        |1         |\n            wine_cellar         |        |1         |\n            cinema              |        |0.75      |\n```\n\nCalculation\n\nThe coverage of a node in the tree is calculated as the weighted average of the coverage of its children evaluated bottom-upwards in the tree.\n\n**The task is to** calculate the overall coverage of the cleaning task and display the coverage at all levels of the hierarchy on this page, in a manner that visually shows the hierarchy, weights and coverage of all nodes.\n\nExtra Credit\n\nAfter calculating the coverage for all nodes, one can also calculate the additional/delta top level coverage that would occur if any (sub)task were to be fully covered from its current fractional coverage. This is done by multiplying the extra coverage that could be gained \n\n1\n−\nc\no\nv\ne\nr\na\ng\ne\n{\\displaystyle {\\displaystyle 1-coverage}}\n for any node, by the product of the `powers` of its parent nodes from the top down to the node.  \nThe power of a direct child of any parent is given by the power of the parent multiplied by the weight of the child divided by the sum of the weights of all the direct children.\n\nThe pseudo code would be:\n\n```\n   method delta_calculation(this, power):\n       sum_of_weights = sum(node.weight for node in children)\n       this.delta  = (1 - this.coverage) * power\n       for node in self.children:\n           node.delta_calculation(power * node.weight / sum_of_weights)\n       return this.delta\n\n```\n\nFollowed by a call to:\n\n```\n   top.delta_calculation(power=1)\n\n```\n\n**Note:** to aid in getting the data into your program you might want to use an alternative, more functional description of the starting data given on the discussion page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nsub walktree ($data) {\n    my (@parts, $cnt);\n\n    while ($data ~~ m:nth(++$cnt)/$<head>=[(\\s*)    \\N+\\n  ]      # split off one level as 'head' (or terminal 'leaf')\n                                  $<body>=[[$0  \\s+ \\N+\\n]*]/ ) { # next sub-level is 'body' (defined by extra depth of indentation)\n\n        my ($head, $body) = ($<head>, $<body>);\n        $head ~~ /'|' $<weight>=[\\S*] \\s* '|' $<coverage>=[\\S*]/; # save values of weight and coverage (if any) for later\n\n        my ($w, $wsum) = (0, 0);\n        $head ~= .[0],\n        $w    += .[1],\n        $wsum += .[1] * .[2]\n            for walktree $body;\n\n        my $weight   = (~$<weight>   or 1).fmt('%-8s');\n        my $coverage = $w == 0\n                    ?? (~$<coverage> or 0).fmt('%-10s')\n                    !! ($wsum/$w)         .fmt('%-10.2g');\n        @parts.push: [$head.subst(/'|' \\N+/, \"|$weight|$coverage|\"), $weight, $coverage ];\n    }\n    return @parts;\n}\n\n(say .[0] for walktree $_) given \n\n    q:to/END/\n    NAME_HIERARCHY                  |WEIGHT  |COVERAGE  |\n    cleaning                        |        |          |\n        house1                      |40      |          |\n            bedrooms                |        |0.25      |\n            bathrooms               |        |          |\n                bathroom1           |        |0.5       |\n                bathroom2           |        |          |\n                outside_lavatory    |        |1         |\n            attic                   |        |0.75      |\n            kitchen                 |        |0.1       |\n            living_rooms            |        |          |\n                lounge              |        |          |\n                dining_room         |        |          |\n                conservatory        |        |          |\n                playroom            |        |1         |\n            basement                |        |          |\n            garage                  |        |          |\n            garden                  |        |0.8       |\n        house2                      |60      |          |\n            upstairs                |        |          |\n                bedrooms            |        |          |\n                    suite_1         |        |          |\n                    suite_2         |        |          |\n                    bedroom_3       |        |          |\n                    bedroom_4       |        |          |\n                bathroom            |        |          |\n                toilet              |        |          |\n                attics              |        |0.6       |\n            groundfloor             |        |          |\n                kitchen             |        |          |\n                living_rooms        |        |          |\n                    lounge          |        |          |\n                    dining_room     |        |          |\n                    conservatory    |        |          |\n                    playroom        |        |          |\n                wet_room_&_toilet   |        |          |\n                garage              |        |          |\n                garden              |        |0.9       |\n                hot_tub_suite       |        |1         |\n            basement                |        |          |\n                cellars             |        |1         |\n                wine_cellar         |        |1         |\n                cinema              |        |0.75      |\n    END\n\n```\n\nOutput:\n\n```\nNAME_HIERARCHY                  |WEIGHT  |COVERAGE  |\n\ncleaning                        |1       |0.41      |\n    house1                      |40      |0.33      |\n        bedrooms                |1       |0.25      |\n        bathrooms               |1       |0.5       |\n            bathroom1           |1       |0.5       |\n            bathroom2           |1       |0         |\n            outside_lavatory    |1       |1         |\n        attic                   |1       |0.75      |\n        kitchen                 |1       |0.1       |\n        living_rooms            |1       |0.25      |\n            lounge              |1       |0         |\n            dining_room         |1       |0         |\n            conservatory        |1       |0         |\n            playroom            |1       |1         |\n        basement                |1       |0         |\n        garage                  |1       |0         |\n        garden                  |1       |0.8       |\n    house2                      |60      |0.46      |\n        upstairs                |1       |0.15      |\n            bedrooms            |1       |0         |\n                suite_1         |1       |0         |\n                suite_2         |1       |0         |\n                bedroom_3       |1       |0         |\n                bedroom_4       |1       |0         |\n            bathroom            |1       |0         |\n            toilet              |1       |0         |\n            attics              |1       |0.6       |\n        groundfloor             |1       |0.32      |\n            kitchen             |1       |0         |\n            living_rooms        |1       |0         |\n                lounge          |1       |0         |\n                dining_room     |1       |0         |\n                conservatory    |1       |0         |\n                playroom        |1       |0         |\n            wet_room_&_toilet   |1       |0         |\n            garage              |1       |0         |\n            garden              |1       |0.9       |\n            hot_tub_suite       |1       |1         |\n        basement                |1       |0.92      |\n            cellars             |1       |1         |\n            wine_cellar         |1       |1         |\n            cinema              |1       |0.75      |\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nThe   **fusc**   integer sequence is defined as:\n\n:   :   * fusc(0) = 0\n        * fusc(1) = 1\n        * for **n**>1,   the   **n**th   term is defined as:\n\n        :   :   * if   **n**   is even;     fusc(n) = fusc(n/2)\n                * if   **n**   is   odd;     fusc(n) = fusc((n-1)/2)   +   fusc((n+1)/2)\n\nNote that MathWorld's definition starts with unity, not zero.   This task will be using the OEIS' version   (above).\n\nAn observation\n:   :   :   :   :   * fusc(A) = fusc(B)\n\nwhere   **A**   is some non-negative integer expressed in binary,   and\nwhere   **B**   is the binary value of   **A**   reversed.\n\nFusc numbers are also known as:\n\n:   :   * fusc function   (named by Dijkstra, 1982)\n        * Stern's Diatomic series   (although it starts with unity, not zero)\n        * Stern-Brocot sequence   (although it starts with unity, not zero)\n\nTask\n:   :   * show the first   **61**   fusc numbers (starting at zero) in a horizontal format.\n        * show the fusc number (and its index) whose length is greater than any previous fusc number length.\n\n        :   :   * (the length is the number of decimal digits when the fusc number is expressed in base ten.)\n\n        * show all numbers with commas   (if appropriate).\n        * show all output here.\n\nRelated task\n:   * Stern-Brocot sequence\n    * Calkin-Wilf sequence.\n\nAlso see\n:   :   * the MathWorld entry:   Stern's Diatomic Series.\n        * the OEIS entry:   A2487."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Recurrence\n\n```\nmy @Fusc = 0, 1, 1, { |(@Fusc[$_ - 1] + @Fusc[$_], @Fusc[$_]) given ++$+1 } ... *;\n\nsub comma { $^i.flip.comb(3).join(',').flip }\n\nput \"First 61 terms of the Fusc sequence:\\n{@Fusc[^61]}\" ~\n    \"\\n\\nIndex and value for first term longer than any previous:\";\n\nfor flat 'Index', 'Value', 0, 0, (1..4).map({\n    my $l = 10**$_;\n    @Fusc.first(* > $l, :kv).map: &comma\n  }) -> $i, $v {\n      printf \"%15s : %s\\n\", $i, $v\n}\n\n```\n\nOutput:\n\n```\nFirst 61 terms of the Fusc sequence:\n0 1 1 2 1 3 2 3 1 4 3 5 2 5 3 4 1 5 4 7 3 8 5 7 2 7 5 8 3 7 4 5 1 6 5 9 4 11 7 10 3 11 8 13 5 12 7 9 2 9 7 12 5 13 8 11 3 10 7 11 4\n\nIndex and value for first term longer than any previous:\n          Index : Value\n              0 : 0\n             37 : 11\n          1,173 : 108\n         35,499 : 1,076\n        699,051 : 10,946\n\n```\n\n### Recursive\n\nAlternative version using Raku's multiple-dispatch feature. This version is significantly slower than the one above, but it's definitely prettier.\n\n```\nmulti fusc( 0 ) { 0 }\nmulti fusc( 1 ) { 1 }\nmulti fusc( $n where $n %% 2 ) { fusc $n div 2 }\nmulti fusc( $n ) { [+] map *.&fusc, ( $n - 1 ) div 2, ( $n + 1 ) div 2 }\nput map *.&fusc, 0..60;\n\n```\n\nOutput:\n\n```\n0 1 1 2 1 3 2 3 1 4 3 5 2 5 3 4 1 5 4 7 3 8 5 7 2 7 5 8 3 7 4 5 1 6 5 9 4 11 7 10 3 11 8 13 5 12 7 9 2 9 7 12 5 13 8 11 3 10 7 11 4\n```"}]}
{"messages": [{"role": "user", "content": "Problem Statement\n\nGabow's algorithm is an algorithm used to find strongly connected components (SCCs) in a digraph.\n\nGiven a directed graph (digraph) with *V* vertices and *E* edges, where vertices are represented as integers from 0 to *V-1* and edges are directed from one vertex to another, design an algorithm to identify all **strongly connected components (SCCs)**. A strongly connected component is a maximal subset of vertices in the digraph such that for every pair of vertices *v* and *w* in the subset, there exists a directed path from *v* to *w* and from *w* to *v*. The algorithm should:\n\n1. Compute the number of SCCs in the digraph.\n2. Assign each vertex to its corresponding SCC.\n3. Provide a way to query whether two vertices belong to the same SCC.\n4. Return the component identifier for any given vertex.\n\nInput\n\n* A directed graph *G* represented as an adjacency list, where:\n  + *V* is the number of vertices (non-negative integer).\n  + Edges are provided as pairs *(v, w)*, indicating a directed edge from vertex *v* to vertex *w*.\n* The vertices are integers in the range [0, *V-1*].\n\nOutput\n\n* The total number of strongly connected components in the digraph.\n* An assignment of each vertex to a unique component identifier (an integer ≥ 0).\n* A mechanism to check if two vertices *v* and *w* are strongly connected (i.e., belong to the same SCC).\n* The ability to retrieve the component ID of any vertex *v*.\n\nConstraints\n\n* *V* ≥ 0 (the graph can be empty).\n* Edges *(v, w)* must satisfy 0 ≤ *v*, *w* < *V*.\n* The graph may contain cycles, self-loops, or parallel edges (though parallel edges are effectively ignored in this implementation as duplicates in adjacency lists are allowed but not explicitly handled).\n\nExample\n\nConsider a digraph with *V = 13* vertices and the following edges:\n\n```\n(4, 2), (2, 3), (3, 2), (6, 0), (0, 1), (2, 0), (11, 12), (12, 9), (9, 10), \n(9, 11), (8, 9), (10, 12), (0, 5), (5, 4), (3, 5), (6, 4), (6, 9), (7, 6), \n(7, 8), (8, 7), (5, 3), (0, 6)\n\n```\n\n* Compute the SCCs.\n* Determine how many SCCs exist.\n* List the vertices in each SCC.\n* Check if specific pairs of vertices (e.g., 0 and 3, 0 and 7) are strongly connected."}, {"role": "assistant", "content": "**Translation of**: Rust\n\n```\n# 20250415 Raku programming solution\n\nmy subset Vertex      of UInt;\nmy subset ComponentId of UInt;\n\nclass Digraph {\n   has Int $.vertex-count is readonly;\n   has Int $.edge-count is rw = 0;\n   has     @.adjacency-lists;\n\n   method new(Int $vertex-count where * >= 0) { # Constructor\n      self.bless( vertex-count    => $vertex-count,\n                  adjacency-lists => [ [] xx $vertex-count ] )\n   }\n\n   method add-edge(Vertex $from, Vertex $to) { # Add a directed edge\n      self!validate-vertex($from);\n      self!validate-vertex($to);\n      @!adjacency-lists[$from].push($to);\n      $!edge-count++;\n   }\n\n   method adjacency-list(Vertex $vertex) { # Get adjacency list for a vertex\n      self!validate-vertex($vertex);\n      @!adjacency-lists[$vertex];\n   }\n\n   method !validate-vertex(Vertex $vertex) { # Validate vertex index\n      if $vertex >= $!vertex-count {\n         die \"Vertex $vertex is not between 0 and {$!vertex-count - 1}\";\n      }\n   }\n\n   method gist { # String representation\n      return [~] [ \n         \"Digraph has $!vertex-count vertices and $!edge-count edges\\n\",\n         \"Adjacency lists:\\n\"\n      ].append( gather for ^$!vertex-count -> $vertex {\n         take sprintf(\"%2d: \", $vertex);\n         take @!adjacency-lists[$vertex].sort.Str ~ \"\\n\"\n      })\n   }\n}\n\nclass GabowSCC {\n   has Bool   @.visited;\n   has Int    @.component-ids; # Using Int with -1 as None equivalent\n   has Int    @.preorders;     # Using Int with -1 as None equivalent\n   has Int    $.preorder-count is rw = 0;\n   has Int    $.scc-count is rw = 0;\n   has Vertex @.visited-vertices-stack;\n   has Vertex @.auxiliary-stack;\n\n   method new(Digraph $digraph) { # Constructor\n      my $n    = $digraph.vertex-count;\n      my $self = self.bless(\n         visited                => False xx $n,\n         component-ids          => (-1) xx $n,\n         preorders              => (-1) xx $n,\n         visited-vertices-stack => [],\n         auxiliary-stack        => []\n      );\n\n      for ^$n -> $vertex {\n         $self!depth-first-search($digraph, $vertex) unless $self.visited[$vertex]\n      }\n      $self;\n   }\n\n   # Depth-first search for Gabow's algorithm\n   method !depth-first-search(Digraph $digraph, Vertex $vertex) {\n      @!visited[$vertex]   = True;\n      @!preorders[$vertex] = $!preorder-count++;\n      @!visited-vertices-stack.push($vertex);\n      @!auxiliary-stack.push($vertex);\n\n      for $digraph.adjacency-list($vertex).List -> $adjacent {\n         if !@!visited[$adjacent] {\n            self!depth-first-search($digraph, $adjacent)\n         } else {\n            if @!component-ids[$adjacent] == -1 {\n               my $adjacent-preorder = @!preorders[$adjacent];\n               while @!auxiliary-stack && @!preorders[@!auxiliary-stack[*-1]] > $adjacent-preorder {\n                  @!auxiliary-stack.pop;\n               }\n            }\n         }\n      }\n\n      if @!auxiliary-stack && @!auxiliary-stack[*-1] == $vertex {\n         @!auxiliary-stack.pop;\n         loop {\n            my $scc-member = @!visited-vertices-stack.pop // die \"Visited stack empty\";\n            @!component-ids[$scc-member] = $!scc-count;\n            last if $scc-member == $vertex;\n         }\n         $!scc-count++;\n      }\n   }\n\n   method get-component-id(Vertex $vertex) { # Get component ID for a vertex\n       self!validate-vertex($vertex);\n       @!component-ids[$vertex] == -1 ?? Nil !! @!component-ids[$vertex];\n   }\n\n   # Check if two vertices are strongly connected\n   method is-strongly-connected(Vertex $v, Vertex $w) {\n      self!validate-vertex($v);\n      self!validate-vertex($w);\n      @!component-ids[$v] != -1 && @!component-ids[$w] != -1 && @!component-ids[$v] == @!component-ids[$w];\n   }\n\n   method get-components() { # Get all components\n      my @components = [] xx $!scc-count;\n      for @!component-ids.kv -> $vertex, $id {\n         if $id != -1 {\n            $id < $!scc-count\n               ?? @components[$id].push($vertex)\n               !! note \"Warning: Vertex $vertex has invalid SCC ID $id\"\n         }\n      }\n      @components.map: *.sort \n   }\n\n   method !validate-vertex(Vertex $vertex) { # Validate vertex index\n      given my $n = @!visited.elems {\n         die \"Vertex $vertex is not between 0 and {$n - 1}\" if $vertex >= $n\n      }\n   }\n}\n\nmy @edges = [ <4 2>, <2 3>, <3 2>, <6 0>, <0 1>, <2 0>, <11 12>, <12 9>, \n              <9 10>, <9 11>, <8 9>, <10 12>, <0 5>, <5 4>, <3 5>, <6 4>, \n              <6 9>, <7 6>, <7 8>, <8 7>, <5 3>, <0 6>\n            ].map: { ( from => .[0], to => .[1] ).Hash };\nmy $vertex-count = 13;\nmy $digraph = Digraph.new($vertex-count);\n\nfor @edges -> $edge { $digraph.add-edge($edge<from>, $edge<to>) }\n\nprint \"Constructed digraph:\" ~ $digraph.gist;\n\nmy $gabow-scc = GabowSCC.new($digraph);\nsay \"It has $gabow-scc.scc-count() strongly connected components.\";\n\nmy @components = $gabow-scc.get-components();\nsay \"\\nComponents:\";\nfor @components.kv -> $i, @component {\n   say \"Component $i: \" ~ @component.Str if @component.Bool;\n}\n\nsay \"\\nExample connectivity checks:\";\nfor ( <0 3>, <0 7>, <9 12> ) -> ($i,$j) {\n   say \"Vertices $i and $j strongly connected? {$gabow-scc.is-strongly-connected($i, $j)}\"\n}\n\nsay \"Component ID of vertex 5: {$gabow-scc.get-component-id(5) // 'None'}\";\nsay \"Component ID of vertex 8: {$gabow-scc.get-component-id(8) // 'None'}\";\n\n(my $id = $gabow-scc.get-component-id(5)).defined\n   ?? say \"Component ID of vertex 5 (explicit handling): $id\"\n   !! say \"Vertex 5 has no assigned component ID.\";\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Example of a Galton Box at the end of animation.\n\nA   **Galton device**   Sir Francis Galton's device   is also known as a   **bean machine**,   a   **Galton Board**,   or a   **quincunx**.\n\nDescription of operation\n\nIn a Galton box, there are a set of pins arranged in a triangular pattern.   A number of balls are dropped so that they fall in line with the top pin, deflecting to the left or the right of the pin.   The ball continues to fall to the left or right of lower pins before arriving at one of the collection points between and to the sides of the bottom row of pins.\n\nEventually the balls are collected into bins at the bottom   (as shown in the image),   the ball column heights in the bins approximate a   bell curve.   Overlaying   Pascal's triangle   onto the pins shows the number of different paths that can be taken to get to each bin.\n\nTask\n\nGenerate an animated simulation of a Galton device.\n\nTask requirements\n:   :   * The box should have at least 5 pins on the bottom row.\n        * A solution can use graphics or ASCII animation.\n        * Provide a sample of the output/display such as a screenshot.\n        * There can be one or more balls in flight at the same time.\n        * If multiple balls are in flight, ensure they don't interfere with each other.\n        * A solution should allow users to specify the number of balls, or it should run until full or a preset limit.\n        * Optionally,   display the number of balls."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUPPER HALF BLOCK and LOWER HALF BLOCK alternate to give a somewhat smooth animation.\n\n**Works with**: rakudo version 2015-09-12\n\n```\nmy $row-count = 6;\n \nconstant $peg = \"*\";\nconstant @coin-icons = \"\\c[UPPER HALF BLOCK]\", \"\\c[LOWER HALF BLOCK]\";\n \nsub display-board(@positions, @stats is copy, $halfstep) {\n    my $coin = @coin-icons[$halfstep.Int];\n \n    state @board-tmpl = {\n        # precompute a board\n        my @tmpl;\n        sub out(*@stuff) {\n            @tmpl.push: $[@stuff.join>>.ords.flat];\n        }\n        # three lines of space above\n        for 1..3 {\n            out \"  \", \" \" x (2 * $row-count);\n        }\n        # $row-count lines of pegs\n        for flat ($row-count...1) Z (1...$row-count) -> $spaces, $pegs {\n            out \"  \", \" \" x $spaces, ($peg xx $pegs).join(\" \"), \" \" x $spaces;\n        }\n        # four lines of space below\n        for 1..4 {\n            out \"  \", \" \" x (2 * $row-count);\n        }\n        @tmpl\n    }();\n \n    my $midpos = $row-count + 2;\n \n    my @output;\n    {\n        # collect all the output and output it all at once at the end\n        sub say(Str $foo) {\n            @output.push: $foo, \"\\n\";\n        }\n        sub print(Str $foo) {\n            @output.push: $foo;\n        }\n \n        # make some space above the picture\n        say \"\" for ^10;\n \n        my @output-lines = map { [ @$_ ] }, @board-tmpl;\n        # place the coins\n        for @positions.kv -> $line, $pos {\n            next unless $pos.defined;\n            @output-lines[$line][$pos + $midpos] = $coin.ord;\n        }\n        # output the board with its coins\n        for @output-lines -> @line {\n            say @line.chrs;\n        }\n \n        # show the statistics\n        my $padding = 0;\n        while any(@stats) > 0 {\n            $padding++;\n            print \"  \";\n            @stats = do for @stats -> $stat {\n                given $stat {\n                    when 1 {\n                        print \"\\c[UPPER HALF BLOCK]\";\n                        $stat - 1;\n                    }\n                    when * <= 0 {\n                        print \" \";\n                        0\n                    }\n                    default {\n                        print \"\\c[FULL BLOCK]\";\n                        $stat - 2;\n                    }\n                }\n            }\n            say \"\";\n        }\n        say \"\" for $padding...^10;\n    }\n    say @output.join(\"\");\n}\n \nsub simulate($coins is copy) {\n    my $alive = True;\n \n    sub hits-peg($x, $y) {\n        if 3 <= $y < 3 + $row-count and -($y - 2) <= $x <= $y - 2 {\n            return not ($x - $y) %% 2;\n        }\n        return False;\n    }\n \n    my @coins = Int xx (3 + $row-count + 4);\n    my @stats = 0 xx ($row-count * 2);\n    # this line will dispense coins until turned off.\n    @coins[0] = 0;\n    while $alive {\n        $alive = False;\n        # if a coin falls through the bottom, count it\n        given @coins[*-1] {\n            when *.defined {\n                @stats[$_ + $row-count]++;\n            }\n        }\n \n        # move every coin down one row\n        for ( 3 + $row-count + 3 )...1 -> $line {\n            my $coinpos = @coins[$line - 1];\n \n            @coins[$line] = do if not $coinpos.defined {\n                Nil\n            } elsif hits-peg($coinpos, $line) {\n                # when a coin from above hits a peg, it will bounce to either side.\n                $alive = True;\n                ($coinpos - 1, $coinpos + 1).pick;\n            } else {\n                # if there was a coin above, it will fall to this position.\n                $alive = True;\n                $coinpos;\n            }\n        }\n        # let the coin dispenser blink and turn it off if we run out of coins\n        if @coins[0].defined {\n            @coins[0] = Nil\n        } elsif --$coins > 0 {\n            @coins[0] = 0 \n        }\n \n        # smooth out the two halfsteps of the animation\n        my $start-time;\n        ENTER { $start-time = now }\n        my $wait-time = now - $start-time;\n \n        sleep 0.1 - $wait-time if $wait-time < 0.1;\n        for @coin-icons.keys {\n            sleep $wait-time max 0.1;\n            display-board(@coins, @stats, $_);\n        }\n    }\n}\n \nsub MAIN($coins = 20, $peg-lines = 6) {\n    $row-count = $peg-lines;\n    simulate($coins);\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement one algorithm (or more) to compute the Gamma (\n\nΓ\n{\\displaystyle {\\displaystyle \\Gamma }}\n) function (in the real field only).\n\nIf your language has the function as built-in or you know a library which has it, compare your implementation's results with the results of the built-in/library function.\n\nThe Gamma function can be defined as:\n\n:   :   :   :   :   :   Γ\n                        (\n                        x\n                        )\n                        =\n\n\n                        ∫\n\n                        0\n\n                        ∞\n\n                        t\n\n                        x\n                        −\n                        1\n\n                        e\n\n                        −\n                        t\n                        d\n                        t\n                        {\\displaystyle {\\displaystyle \\Gamma (x)=\\displaystyle \\int \\_{0}^{\\infty }t^{x-1}e^{-t}dt}}\n\nThis suggests a straightforward (but inefficient) way of computing the \n\nΓ\n{\\displaystyle {\\displaystyle \\Gamma }}\n through numerical integration.\n\nBetter suggested methods:\n\n* Lanczos approximation\n* Stirling's approximation"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub Γ(\\z) {\n    constant g = 9;\n    z < .5 ?? pi/ sin(pi * z) / Γ(1 - z) !!\n    sqrt(2*pi) *\n    (z + g - 1/2)**(z - 1/2) *\n    exp(-(z + g - 1/2)) *\n    [+] <\n        1.000000000000000174663\n     5716.400188274341379136\n   -14815.30426768413909044\n    14291.49277657478554025\n    -6348.160217641458813289\n     1301.608286058321874105\n     -108.1767053514369634679\n        2.605696505611755827729\n       -0.7423452510201416151527e-2\n        0.5384136432509564062961e-7\n       -0.4023533141268236372067e-8\n    > Z* 1, |map 1/(z + *), 0..*\n}\n\nsay Γ($_) for 1/3, 2/3 ... 10/3;\n\n```\n\nOutput:\n\n```\n2.67893853470775\n1.3541179394264\n1\n0.892979511569248\n0.902745292950934\n1\n1.190639348759\n1.50457548825155\n2\n2.77815848043766\n```"}]}
{"messages": [{"role": "user", "content": "Numbers   (positive integers expressed in base ten)   that are (evenly) divisible by the number formed by the\nfirst and last digit are known as   **gapful numbers**.\n\n*Evenly divisible*   means divisible with   no   remainder.\n\nAll   one─   and two─digit   numbers have this property and are trivially excluded.   Only\nnumbers    ≥  **100**   will be considered for this Rosetta Code task.\n\nExample\n\n**187**   is a   **gapful**   number because it is evenly divisible by the\nnumber   **17**   which is formed by the first and last decimal digits\nof    **187**.\n\nAbout   7.46%   of positive integers are   *gapful*.\n\nTask\n:   * Generate and show all sets of numbers (below) on one line (horizontally) with a title,   here on this page\n    * Show the first   **30**   gapful numbers\n    * Show the first   **15**   gapful numbers    ≥           **1,000,000**\n    * Show the first   **10**   gapful numbers    ≥    **1,000,000,000**\n\nRelated tasks\n:   * Harshad or Niven series.\n    * palindromic gapful numbers.\n    * largest number divisible by its digits.\n\nAlso see\n:   * The OEIS entry:   A108343 gapful numbers.\n    * numbersaplenty gapful numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nAlso test starting on a number that *doesn't* start with 1. Required to have titles, may as well make 'em noble. :-)\n\n```\nuse Lingua::EN::Numbers;\n\nfor (1e2, 30, 1e6, 15, 1e9, 10, 7123, 25)».Int -> $start, $count {\n    put \"\\nFirst $count gapful numbers starting at {comma $start}:\\n\" ~\n    <Sir Lord Duke King>.pick ~ \": \", ~\n    ($start..*).grep( { $_ %% .comb[0, *-1].join } )[^$count];\n}\n\n```\n\nOutput:\n\n```\nFirst 30 gapful numbers starting at 100:\nSir: 100 105 108 110 120 121 130 132 135 140 143 150 154 160 165 170 176 180 187 190 192 195 198 200 220 225 231 240 242 253\n\nFirst 15 gapful numbers starting at 1,000,000:\nDuke: 1000000 1000005 1000008 1000010 1000016 1000020 1000021 1000030 1000032 1000034 1000035 1000040 1000050 1000060 1000065\n\nFirst 10 gapful numbers starting at 1,000,000,000:\nKing: 1000000000 1000000001 1000000005 1000000008 1000000010 1000000016 1000000020 1000000027 1000000030 1000000032\n\nFirst 25 gapful numbers starting at 7,123:\nKing: 7125 7140 7171 7189 7210 7272 7275 7280 7296 7350 7373 7420 7425 7474 7488 7490 7560 7575 7630 7632 7676 7700 7725 7770 7777\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nInvert matrix   **A**   using Gauss-Jordan method.\n\n**A**   being an   **n** × **n**   matrix."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUses bits and pieces from other tasks, Reduced row echelon form primarily.\n\n```\nsub gauss-jordan-invert (@m where &is-square) {\n    ^@m .map: { @m[$_].append: identity(+@m)[$_] };\n    @m.&rref[*]»[+@m .. *];\n}\n\nsub is-square (@m) { so @m == all @m[*] }\n\nsub identity ($n) { [ 1, |(0 xx $n-1) ], *.rotate(-1).Array ... *.tail }\n\n# reduced row echelon form (from 'Gauss-Jordan elimination' task)\nsub rref (@m) {\n    my ($lead, $rows, $cols) = 0, @m, @m[0];\n\n    for ^$rows -> $r {\n        $lead < $cols or return @m;\n        my $i = $r;\n        until @m[$i;$lead] {\n            ++$i == $rows or next;\n            $i = $r;\n            ++$lead == $cols and return @m;\n        }\n        @m[$i, $r] = @m[$r, $i] if $r != $i;\n        @m[$r] »/=» $ = @m[$r;$lead];\n        for ^$rows -> $n {\n            next if $n == $r;\n            @m[$n] »-=» @m[$r] »×» (@m[$n;$lead] // 0);\n        }\n        ++$lead;\n    }\n    @m\n}\nsub rat-or-int ($num) {\n    return $num unless $num ~~ Rat|FatRat;\n    return $num.narrow if $num.narrow ~~ Int;\n    $num.nude.join: '/';\n}\n\nsub say_it ($message, @array) {\n    my $max;\n    @array.map: {$max max= max $_».&rat-or-int.comb(/\\S+/)».chars};\n    say \"\\n$message\";\n    $_».&rat-or-int.fmt(\" %{$max}s\").put for @array;\n}\n\nmulti to-matrix ($str) { [$str.split(';').map(*.words.Array)] }\nmulti to-matrix (@array) { @array }\n\nsub hilbert-matrix ($h) {\n    [ (1..$h).map( -> $n { [ ($n ..^ $n + $h).map: { (1/$_).FatRat } ] } ) ]\n}\n\nmy @tests =\n    '1 2 3; 4 1 6; 7 8 9',\n    '2 -1 0; -1 2 -1; 0 -1 2',\n    '-1 -2 3 2; -4 -1 6 2; 7 -8 9 1; 1 -2 1 3',\n    '1 2 3 4; 5 6 7 8; 9 33 11 12; 13 14 15 17',\n    '3 1 8 9 6; 6 2 8 10 1; 5 7 2 10 3; 3 2 7 7 9; 3 5 6 1 1',\n\n    # Test with a Hilbert matrix\n    hilbert-matrix 10;\n\n@tests.map: {\n    my @matrix = .&to-matrix;\n    say_it( \" {'=' x 20} Original Matrix: {'=' x 20}\", @matrix );\n    say_it( ' Gauss-Jordan Inverted:', my @invert = gauss-jordan-invert @matrix );\n    say_it( ' Re-inverted:', gauss-jordan-invert @invert».Array );\n}\n\n```\n\nOutput:\n\n```\n ==================== Original Matrix: ====================\n 1  2  3\n 4  1  6\n 7  8  9\n\n Gauss-Jordan Inverted:\n -13/16     1/8    3/16\n    1/8    -1/4     1/8\n  25/48     1/8   -7/48\n\n Re-inverted:\n 1  2  3\n 4  1  6\n 7  8  9\n\n ==================== Original Matrix: ====================\n  2  -1   0\n -1   2  -1\n  0  -1   2\n\n Gauss-Jordan Inverted:\n 3/4  1/2  1/4\n 1/2    1  1/2\n 1/4  1/2  3/4\n\n Re-inverted:\n  2  -1   0\n -1   2  -1\n  0  -1   2\n\n ==================== Original Matrix: ====================\n -1  -2   3   2\n -4  -1   6   2\n  7  -8   9   1\n  1  -2   1   3\n\n Gauss-Jordan Inverted:\n -21/23   17/69  13/138   19/46\n -38/23   15/23    1/23   15/23\n -16/23   25/69  11/138    9/46\n -13/23   16/69   -2/69   13/23\n\n Re-inverted:\n -1  -2   3   2\n -4  -1   6   2\n  7  -8   9   1\n  1  -2   1   3\n\n ==================== Original Matrix: ====================\n  1   2   3   4\n  5   6   7   8\n  9  33  11  12\n 13  14  15  17\n\n Gauss-Jordan Inverted:\n   19/184  -199/184     -1/46       1/2\n     1/23     -2/23      1/23         0\n -441/184   813/184     -1/46      -3/2\n        2        -3         0         1\n\n Re-inverted:\n  1   2   3   4\n  5   6   7   8\n  9  33  11  12\n 13  14  15  17\n\n ==================== Original Matrix: ====================\n  3   1   8   9   6\n  6   2   8  10   1\n  5   7   2  10   3\n  3   2   7   7   9\n  3   5   6   1   1\n\n Gauss-Jordan Inverted:\n -4525/6238   2529/6238   -233/3119   1481/3119   -639/6238\n  1033/6238  -1075/6238    342/3119   -447/3119    871/6238\n  1299/6238   -289/6238   -204/3119   -390/3119    739/6238\n   782/3119   -222/3119    237/3119   -556/3119   -177/3119\n  -474/3119    -17/3119    -24/3119    688/3119   -140/3119\n\n Re-inverted:\n  3   1   8   9   6\n  6   2   8  10   1\n  5   7   2  10   3\n  3   2   7   7   9\n  3   5   6   1   1\n\n ==================== Original Matrix: ====================\n    1   1/2   1/3   1/4   1/5   1/6   1/7   1/8   1/9  1/10\n  1/2   1/3   1/4   1/5   1/6   1/7   1/8   1/9  1/10  1/11\n  1/3   1/4   1/5   1/6   1/7   1/8   1/9  1/10  1/11  1/12\n  1/4   1/5   1/6   1/7   1/8   1/9  1/10  1/11  1/12  1/13\n  1/5   1/6   1/7   1/8   1/9  1/10  1/11  1/12  1/13  1/14\n  1/6   1/7   1/8   1/9  1/10  1/11  1/12  1/13  1/14  1/15\n  1/7   1/8   1/9  1/10  1/11  1/12  1/13  1/14  1/15  1/16\n  1/8   1/9  1/10  1/11  1/12  1/13  1/14  1/15  1/16  1/17\n  1/9  1/10  1/11  1/12  1/13  1/14  1/15  1/16  1/17  1/18\n 1/10  1/11  1/12  1/13  1/14  1/15  1/16  1/17  1/18  1/19\n\n Gauss-Jordan Inverted:\n            100           -4950           79200         -600600         2522520        -6306300         9609600        -8751600         4375800         -923780\n          -4950          326700        -5880600        47567520      -208107900       535134600      -832431600       770140800      -389883780        83140200\n          79200        -5880600       112907520      -951350400      4281076800    -11237826600     17758540800    -16635041280      8506555200     -1829084400\n        -600600        47567520      -951350400      8245036800    -37875637800    101001700800   -161602721280    152907955200    -78843164400     17071454400\n        2522520      -208107900      4281076800    -37875637800    176752976400   -477233036280    771285715200   -735869534400    382086104400    -83223340200\n       -6306300       535134600    -11237826600    101001700800   -477233036280   1301544644400  -2121035716800   2037792556800  -1064382719400    233025352560\n        9609600      -832431600     17758540800   -161602721280    771285715200  -2121035716800   3480673996800  -3363975014400   1766086882560   -388375587600\n       -8751600       770140800    -16635041280    152907955200   -735869534400   2037792556800  -3363975014400   3267861442560  -1723286307600    380449555200\n        4375800      -389883780      8506555200    -78843164400    382086104400  -1064382719400   1766086882560  -1723286307600    912328045200   -202113826200\n        -923780        83140200     -1829084400     17071454400    -83223340200    233025352560   -388375587600    380449555200   -202113826200     44914183600\n\n Re-inverted:\n    1   1/2   1/3   1/4   1/5   1/6   1/7   1/8   1/9  1/10\n  1/2   1/3   1/4   1/5   1/6   1/7   1/8   1/9  1/10  1/11\n  1/3   1/4   1/5   1/6   1/7   1/8   1/9  1/10  1/11  1/12\n  1/4   1/5   1/6   1/7   1/8   1/9  1/10  1/11  1/12  1/13\n  1/5   1/6   1/7   1/8   1/9  1/10  1/11  1/12  1/13  1/14\n  1/6   1/7   1/8   1/9  1/10  1/11  1/12  1/13  1/14  1/15\n  1/7   1/8   1/9  1/10  1/11  1/12  1/13  1/14  1/15  1/16\n  1/8   1/9  1/10  1/11  1/12  1/13  1/14  1/15  1/16  1/17\n  1/9  1/10  1/11  1/12  1/13  1/14  1/15  1/16  1/17  1/18\n 1/10  1/11  1/12  1/13  1/14  1/15  1/16  1/17  1/18  1/19\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSolve   **Ax=b**   using Gaussian elimination then backwards substitution.\n\n**A**   being an   **n** by **n**   matrix.\n\nAlso,   **x** and **b**   are   **n** by **1**   vectors.\n\nTo improve accuracy, please use partial pivoting and scaling.\n\nSee also\n:   * the Wikipedia entry:   Gaussian elimination"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nGaussian elimination results in a matrix in row echelon form. Gaussian elimination with back-substitution (also known as Gauss-Jordan elimination) results in a matrix in reduced row echelon form. That being the case, we can reuse much of the code from the Reduced row echelon form task. Raku stores and does calculations on decimal numbers within its limit of precision using Rational numbers by default, meaning the calculations are exact.\n\n```\nsub gauss-jordan-solve (@a, @b) {\n    @b.kv.map: { @a[$^k].append: $^v };\n    @a.&rref[*]»[*-1];\n}\n\n# reduced row echelon form\nsub rref (@m) {\n    my ($lead, $rows, $cols) = 0, @m, @m[0];\n\n    for ^$rows -> $r {\n        $lead < $cols or return @m;\n        my $i = $r;\n        until @m[$i;$lead] {\n            ++$i == $rows or next;\n            $i = $r;\n            ++$lead == $cols and return @m;\n        }\n        @m[$i, $r] = @m[$r, $i] if $r != $i;\n        @m[$r] »/=» $ = @m[$r;$lead];\n        for ^$rows -> $n {\n            next if $n == $r;\n            @m[$n] »-=» @m[$r] »×» (@m[$n;$lead] // 0);\n        }\n        ++$lead;\n    }\n    @m\n}\n\nsub rat-or-int ($num) {\n    return $num unless $num ~~ Rat;\n    return $num.narrow if $num.narrow ~~ Int;\n    $num.nude.join: '/';\n}\n\nsub say-it ($message, @array, $fmt = \" %8s\") {\n    say \"\\n$message\";\n    $_».&rat-or-int.fmt($fmt).put for @array;\n}\n\nmy @a = (\n    [ 1.00, 0.00, 0.00,  0.00,  0.00,   0.00 ],\n    [ 1.00, 0.63, 0.39,  0.25,  0.16,   0.10 ],\n    [ 1.00, 1.26, 1.58,  1.98,  2.49,   3.13 ],\n    [ 1.00, 1.88, 3.55,  6.70, 12.62,  23.80 ],\n    [ 1.00, 2.51, 6.32, 15.88, 39.90, 100.28 ],\n    [ 1.00, 3.14, 9.87, 31.01, 97.41, 306.02 ],\n);\nmy @b = ( -0.01, 0.61, 0.91, 0.99, 0.60, 0.02 );\n\nsay-it 'A matrix:', @a, \"%6.2f\";\nsay-it 'or, A in exact rationals:', @a;\nsay-it 'B matrix:', @b, \"%6.2f\";\nsay-it 'or, B in exact rationals:', @b;\nsay-it 'x matrix:', (my @gj = gauss-jordan-solve @a, @b), \"%16.12f\";\nsay-it 'or, x in exact rationals:', @gj, \"%28s\";\n\n```\n\nOutput:\n\n```\nA matrix:\n  1.00   0.00   0.00   0.00   0.00   0.00\n  1.00   0.63   0.39   0.25   0.16   0.10\n  1.00   1.26   1.58   1.98   2.49   3.13\n  1.00   1.88   3.55   6.70  12.62  23.80\n  1.00   2.51   6.32  15.88  39.90 100.28\n  1.00   3.14   9.87  31.01  97.41 306.02\n\nor, A in exact rationals:\n        1         0         0         0         0         0\n        1    63/100    39/100       1/4      4/25      1/10\n        1     63/50     79/50     99/50   249/100   313/100\n        1     47/25     71/20     67/10    631/50     119/5\n        1   251/100    158/25    397/25    399/10   2507/25\n        1    157/50   987/100  3101/100  9741/100  15301/50\n\nB matrix:\n -0.01\n  0.61\n  0.91\n  0.99\n  0.60\n  0.02\n\nor, B in exact rationals:\n   -1/100\n   61/100\n   91/100\n   99/100\n      3/5\n     1/50\n\nx matrix:\n -0.010000000000\n  1.602790394502\n -1.613203059906\n  1.245494121371\n -0.490989719585\n  0.065760696175\n\nor, x in exact rationals:\n                      -1/100\n   655870882787/409205648497\n  -660131804286/409205648497\n   509663229635/409205648497\n  -200915766608/409205648497\n    26909648324/409205648497\n\n```"}]}
{"messages": [{"role": "user", "content": "A Gaussian Integer is a complex number such that its real and imaginary parts are both integers.\n\n```\n   a + bi where a and b are integers and i is √-1.\n\n```\n\nThe norm of a Gaussian integer is its product with its conjugate.\n\n```\n   N(a + bi) = (a + bi)(a − bi) = a² + b²\n\n```\n\nA Gaussian integer is a Gaussian prime if and only if either: both **a** and **b** are non-zero and its **norm** is a prime number, or, one of **a** or **b** is zero and it is the product of a unit **(±1, ±i)** and a prime integer of the form **4n + 3**.\n\nPrime integers that are *not* of the form **4n + 3** can be factored into a Gaussian integer and its complex conjugate so are not a Gaussian prime.\n\n```\n   E.G. 5 = (2 + i)(2 − i) So 5 is not a Gaussian prime\n\n```\n\nGaussian primes are octogonally symmetrical on a real / imaginary Cartesian field. If a particular complex norm **a² + b²** is prime, since addition is commutative, **b² + a²** is also prime, as are the complex conjugates and negated instances of both.\n\nTask\n\nFind and show, here on this page, the Gaussian primes with a norm of less than 100, (within a radius of 10 from the origin **0 + 0i** on a complex plane.)\n\nPlot the points corresponding to the Gaussian primes on a Cartesian real / imaginary plane at least up to a radius of 50.\n\nSee also\n\n* Wikipedia: Gaussian integers * Wikipedia: Gaussian primes * OEIS: Gaussian primes"}, {"role": "assistant", "content": "Plotting the points up to a radius of 150.\n\n```\nuse List::Divvy;\n\nmy @next = { :1x, :1y, :2n },;\n\nsub next-interval (Int $int) {\n     @next.append: (^$int).map: { %( :x($int), :y($_), :n($int² + .²) ) };\n     @next = |@next.sort: *.<n>;\n}\n\nmy @gaussian = lazy gather {\n    my $interval = 1;\n    loop {\n        my @this = @next.shift;\n        @this.push: @next.shift while @next and @next[0]<n> == @this[0]<n>;\n        for @this {\n            .take if .<n>.is-prime || (!.<y> && .<x>.is-prime && (.<x> - 3) %% 4);\n            next-interval(++$interval) if $interval == .<x>\n        }\n    }\n}\n\n# Primes within a radius of 10 from origin\nsay \"Gaussian primes with a norm less than 100 sorted by norm:\";\nsay @gaussian.&before(*.<n> > 10²).map( {\n     my (\\i, \\j) = .<x y>;\n    flat ((i,j),(-i,j),(-i,-j),(i,-j),(j,i),(-j,i),(-j,-i),(j,-i)).map: {\n        .[0] ?? .[1] ?? (sprintf \"%d%s%di\", .[0], (.[1] ≥ 0 ?? '+' !! ''), .[1]) !! .[0] !! \"{.[1]}i\"\n    }} )».subst('1i', 'i', :g)».fmt(\"%6s\")».unique.flat.batch(10).join: \"\\n\" ;\n\n\n# Plot points within a 150 radius\nuse SVG;\n\nmy @points = unique flat @gaussian.&before(*.<n> > 150²).map: {\n    my (\\i, \\j) = .<x y>;\n    do for (i,j),(-i,j),(-i,-j),(i,-j),(j,i),(-j,i),(-j,-i),(j,-i) {\n        :use['xlink:href'=>'#point', 'transform'=>\"translate({500 + 3 × .[0]},{500 + 3 × .[1]})\"]\n    }\n}\n\n'gaussian-primes-raku.svg'.IO.spurt: SVG.serialize(\n    svg => [\n        :width<1000>, :height<1000>,\n        :rect[:width<100%>, :height<100%>, :style<fill:black;>],\n        :defs[:g[:id<point>, :circle[:0cx, :0cy, :2r, :fill('gold')]]],\n        |@points\n    ],\n);\n\n```\n\nOutput:\n\n```\nGaussian primes with a norm less than 100 sorted by norm:\n   1+i   -1+i   -1-i    1-i    2+i   -2+i   -2-i    2-i   1+2i  -1+2i\n -1-2i   1-2i      3     -3     3i    -3i   3+2i  -3+2i  -3-2i   3-2i\n  2+3i  -2+3i  -2-3i   2-3i    4+i   -4+i   -4-i    4-i   1+4i  -1+4i\n -1-4i   1-4i   5+2i  -5+2i  -5-2i   5-2i   2+5i  -2+5i  -2-5i   2-5i\n   6+i   -6+i   -6-i    6-i   1+6i  -1+6i  -1-6i   1-6i   5+4i  -5+4i\n -5-4i   5-4i   4+5i  -4+5i  -4-5i   4-5i      7     -7     7i    -7i\n  7+2i  -7+2i  -7-2i   7-2i   2+7i  -2+7i  -2-7i   2-7i   6+5i  -6+5i\n -6-5i   6-5i   5+6i  -5+6i  -5-6i   5-6i   8+3i  -8+3i  -8-3i   8-3i\n  3+8i  -3+8i  -3-8i   3-8i   8+5i  -8+5i  -8-5i   8-5i   5+8i  -5+8i\n -5-8i   5-8i   9+4i  -9+4i  -9-4i   9-4i   4+9i  -4+9i  -4-9i   4-9i\n```\n\nOff-site SVG image: gaussian-primes-raku.svg"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a generalized version of FizzBuzz that works for any list of factors, along with their words.\n\nThis is basically a \"fizzbuzz\" implementation where the user supplies the parameters.\n\nThe user will enter the max number, then they will enter the factors to be calculated along with the corresponding word to be printed.\n\nFor simplicity's sake, assume the user will input an integer as the max number and 3 factors, each with a word associated with them.\n\nFor example, given:\n\n```\n>20      #This is the maximum number, supplied by the user\n>3 Fizz  #The user now enters the starting factor (3) and the word they want associated with it (Fizz)\n>5 Buzz  #The user now enters the next factor (5) and the word they want associated with it (Buzz)\n>7 Baxx  #The user now enters the next factor (7) and the word they want associated with it (Baxx)\n\n```\n\nIn other words: For this example, print the numbers **1** through **20**, replacing every multiple of **3** with \"Fizz\", every multiple of **5** with \"Buzz\", and every multiple of **7** with \"Baxx\".\n\nIn the case where a number is a multiple of at least two factors, print each of the words associated with those factors in the order of least to greatest factor.\n\nFor instance, the number **15** is a multiple of both **3** and **5**; print \"FizzBuzz\".\n\nIf the max number was **105** instead of **20**, you would print \"FizzBuzzBaxx\" because it's a multiple of **3**, **5**, and **7**.\n\nOutput:\n\n```\n1\n2\nFizz\n4\nBuzz\nFizz\nBaxx\n8\nFizz\nBuzz\n11\nFizz\n13\nBaxx\nFizzBuzz\n16\n17\nFizz\n19\nBuzz\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-20\n\n```\n# General case implementation of a \"FizzBuzz\" class.\n# Defaults to standard FizzBuzz unless a new schema is passed in.\nclass FizzBuzz {\n    has $.schema is rw = < 3 Fizz 5 Buzz >.hash;\n    method filter (Int $this) {\n        my $fb;\n        for $.schema.sort: { +.key } -> $p { $fb ~= $this %% +$p.key ?? $p.value !! ''};\n        return $fb || $this;\n    }\n}\n\n\n# Sub implementing the specific requirements of the task.\nsub GeneralFizzBuzz (Int $upto, @schema?) {\n    my $ping = FizzBuzz.new;\n    $ping.schema = @schema.hash if @schema;\n    map { $ping.filter: $_ }, 1 .. $upto;\n}\n\n# The task\nsay 'Using: 20 ' ~ <3 Fizz 5 Buzz 7 Baxx>;\n.say for GeneralFizzBuzz(20, <3 Fizz 5 Buzz 7 Baxx>);\n\nsay '';\n\n# And for fun\nsay 'Using: 21 ' ~ <2 Pip 4 Squack 5 Pocketa 7 Queep>;\nsay join ', ', GeneralFizzBuzz(21, <2 Pip 4 Squack 5 Pocketa 7 Queep>);\n\n```\n\nOutput:\n\n```\nUsing: 20 3 Fizz 5 Buzz 7 Baxx\n1\n2\nFizz\n4\nBuzz\nFizz\nBaxx\n8\nFizz\nBuzz\n11\nFizz\n13\nBaxx\nFizzBuzz\n16\n17\nFizz\n19\nBuzz\n\nUsing: 21 2 Pip 4 Squack 5 Pocketa 7 Queep\n1, Pip, 3, PipSquack, Pocketa, Pip, Queep, PipSquack, 9, PipPocketa, 11, PipSquack, 13, PipQueep, Pocketa, PipSquack, 17, Pip, 19, PipSquackPocketa, Queep\n```\n\nHere's the same program in a more functional idiom:\n\n```\nsub genfizzbuzz($n, +@fb) {\n    [Z~](\n        do for @fb || <3 fizz 5 buzz> -> $i, $s {\n            flat ('' xx $i-1, $s) xx *;\n        }\n    ) Z|| 1..$n\n}\n\n.say for genfizzbuzz(20, <3 Fizz 5 Buzz 7 Baxx>);\n\n```"}]}
{"messages": [{"role": "user", "content": "It is possible to implement floating point arithmetic in many different ways; though the standard IEEE arithmetic implementation on modern hardware usually uses a fixed-width binary implementation (using a total of 32 bits for single-precision floats — `float` in a number of languages — and 64 bits for double-precision floats — `double`) many other schemes can be used. For example, the base need not be binary (alternatives include decimal, binary-coded decimal, and even balanced ternary) and there is no requirement that a fixed number of digits be used.\n\nDefine addition for floating point numbers where the digits are stored in an arbitrary base; e.g. the digits can be stored as binary, decimal, binary-coded decimal, or even balanced ternary.\nYou should implement the code in a generalised form (such as a Template, Module or Mixin etc) that permits reusing of the code for different Bases.\n\nIf it is not possible to implement code by providing an implementation that uses the *syntax* of the specific language then:\n\n* Note the reason why this is.\n* Demonstrate that the language still supports the semantics of generalised floating point by implementing the *test case* using built-in code or a library.\n\n**Test case:**\n\nDefine arbitrary precision addition on floating point numbers (e.g., encoding those numbers using Binary Coded Decimal, or using an arbitrary precision integer arithmetic library). Calculate the terms for -7 to 21 in this sequence of calculations:\n\nCalculate the terms for -7 to 21 in this sequence of calculations\n\n| Number | Term calculation | Result |\n| --- | --- | --- |\n| -7 | 12345679e63 × 81 + 1e63 | 1e72 |\n| -6 | 12345679012345679e54 × 81 + 1e54 | 1e72 |\n| -5 | 12345679012345679012345679e45 × 81 + 1e45 | 1e72 |\n| -4 | 12345679012345679012345679012345679e36 × 81 + 1e36 | 1e72 |\n| etc. | The final calculation will be over 256 digits wide | 1e72 |\n\nYou will either need to implement multiplication, or perform the multiplication by 81 by using repeated additions. The results will always be 1e72.\n\nBonus\n\nMake the template (module, class, mixing, etc.) able to successfully handle using other bases to perform the above test case. Demonstrate using balanced ternary."}, {"role": "assistant", "content": "(formerly Perl 6)\nAs long as all values are kept as rationals (type `Rat`) calculations are done full precision.\n\n```\nmy $e = 63;\nfor -7..21 -> $n {\n    my $num = '12345679' ~ '012345679' x ($n+7);\n    my $sum = $_ + ($num * $_) * 81 given $e > -20 ?? 10**$e !! Rat.new(1,10**abs $e);\n    printf \"$n:%s \", 10**72 == $sum ?? 'Y' !! 'N';\n    $e -= 9;\n}\n\n```\n\nOutput:\n\n```\n-7:Y -6:Y -5:Y -4:Y -3:Y -2:Y -1:Y 0:Y 1:Y 2:Y 3:Y 4:Y 5:Y 6:Y 7:Y 8:Y 9:Y 10:Y 11:Y 12:Y 13:Y 14:Y 15:Y 16:Y 17:Y 18:Y 19:Y 20:Y 21:Y\n\n```"}]}
{"messages": [{"role": "user", "content": "**Chess960** is a variant of chess created by world champion Bobby Fischer. Unlike other variants of the game, Chess960 does not require a different material, but instead relies on a random initial position, with a few constraints:\n\n* as in the standard chess game, all eight white pawns must be placed on the second rank.\n* White pieces must stand on the first rank as in the standard game, in random column order but with the two following constraints:\n  + the bishops must be placed on opposite color squares (i.e. they must be an odd number of spaces apart or there must be an even number of spaces between them)\n  + the King must be between two rooks (with any number of other pieces between them all)\n* Black pawns and pieces must be placed respectively on the seventh and eighth ranks, mirroring the white pawns and pieces, just as in the standard game. (That is, their positions are not independently randomized.)\n\nWith those constraints there are **960** possible starting positions, thus the name of the variant.\n\nTask\n\nThe purpose of this task is to write a program that can randomly generate any one of the 960 Chess960 initial positions. You will show the result as the first rank displayed using either the chess symbols in Unicode (♔♕♖♗♘), the letters **K**ing **Q**ueen **R**ook **B**ishop k**N**ight, or the corresponding letters in a language other than English."}, {"role": "assistant", "content": "(formerly Perl 6)\nFirst, using a list with three rooks and no king, we keep generating a random piece order until the two bishops are on opposite colors. Then we sneakily promote the second of the three rooks to a king.\n\n```\nrepeat until m/ '♗' [..]* '♗' / { $_ = < ♖ ♖ ♖ ♕ ♗ ♗ ♘ ♘ >.pick(*).join }\ns:2nd['♖'] = '♔';\nsay .comb;\n\n```\n\nOutput:\n\n```\n♕ ♗ ♖ ♘ ♔ ♖ ♗ ♘\n```\n\nHere's a more \"functional\" solution that avoids side effects\n\n```\nsub chess960 {\n    .subst(:nth(2), /'♜'/, '♚') given\n    first rx/ '♝' [..]* '♝' /,\n    < ♛ ♜ ♜ ♜ ♝ ♝ ♞ ♞ >.pick(*).join xx *;\n}\n\nsay chess960;\n\n```\n\nOutput:\n\n```\n♛♝♜♚♝♞♞♜\n```\n\nWe can also pregenerate the list of 960 positions, though the method we use below is a bit wasteful, since it\ngenerates 40320 candidates only to throw most of them away. This is essentially the same filtering algorithm\nbut written in the form of a list comprehension rather than nested map and grep. (The list comprehension is actually faster currently.) Note that the constant is calculated at compile time, because, well, it's a constant. Just a big fancy one.\n\n```\nconstant chess960 =\n   < ♛ ♜ ♜ ♜ ♝ ♝ ♞ ♞ >.permutations».join.unique.grep( / '♝' [..]* '♝' / )».subst(:nth(2), /'♜'/, '♚');\n\n.say for chess960;\n\n```\n\nHere's a much faster way (about 30x) to generate all 960 variants by construction. No need to filter for uniqueness, since it produces exactly 960 entries.\n\n```\nconstant chess960 = gather for 0..3 -> $q {\n    (my @q = <♜ ♚ ♜>).splice($q, 0, '♛');\n    for 0 .. @q -> $n1 {\n        (my @n1 = @q).splice($n1, 0, '♞');\n        for $n1 ^.. @n1 -> $n2 {\n            (my @n2 = @n1).splice($n2, 0, '♞');\n            for 0 .. @n2 -> $b1 {\n                (my @b1 = @n2).splice($b1, 0, '♝');\n                for $b1+1, $b1+3 ...^ * > @b1 -> $b2 {\n                    (my @b2 = @b1).splice($b2, 0, '♝');\n                    take @b2.join;\n                }\n            }\n        }\n    }\n}\n\nCHECK { note \"done compiling\" }\nnote +chess960;\nsay chess960.pick;\n\n```\n\nOutput:\n\n```\ndone compiling\n960\n♜♚♝♜♞♛♞♝\n```\n\nIf you run this you'll see that most of the time is spent in compilation, so in the case of separate precompilation the table of 960 entries merely needs to be deserialized back into memory. Picking from those entries guarantees uniform distribution over all possible boards.\n\n```\n♛♝♜♚♝♞♞♜\n```\n\n### Raku: Generate from SP-ID\n\nThere is a standard numbering scheme for Chess960 positions, assigning each an index in the range 0..959. This function will generate the corresponding position from a given index number (or fall back to a random one if no index is specified, making it yet another solution to the general problem).\n\n```\nsubset Pos960 of Int where { $_ ~~ ^960 };\nsub chess960(Pos960 $position = (^960).pick) {\n\n  # We remember the remainder used to place first bishop in order to place the\n  # second\n  my $b1;\n  \n  # And likewise remember the chosen combination for knights between those\n  # placements\n  my @n;\n  \n  # Piece symbols and positioning rules in order.  Start with the position\n  # number. At each step, divide by the divisor; the quotient becomes the\n  # dividend for the next step.  Feed the remainder into the specified code block\n  # to get a space number N, then place the piece in the Nth empty space left in\n  # the array.\n  my @rules = (\n    #divisor, mapping function,                      piece\n    ( 4,      { $b1 = $_; 2 * $_ + 1 },              '♝'  ),\n    ( 4,      { 2 * $_ - ($_ > $b1 ?? 1 !! 0) },     '♝'  ),\n    ( 6,      { $_ },                                '♛'  ),\n    (10,      { @n = combinations(5,2)[$_]; @n[0] }, '♞'  ),\n    ( 1,      { @n[1]-1 },                           '♞'  ),\n    ( 1,      { 0 },                                 '♜'  ),\n    ( 1,      { 0 },                                 '♚'  ),\n    ( 1,      { 0 },                                 '♜'  )\n  \n  );\n  \n  # Initial array, using '-' to represent empty spaces\n  my @array = «-» xx 8;\n  \n  # Working value that starts as the position number but is divided by the\n  # divisor at each placement step.\n  my $p = $position;\n  \n  # Loop over the placement rules\n  for @rules -> ($divisor, $block, $piece) {\n  \n    # get remainder when divided by divisor\n    (my $remainder, $p) = $p.polymod($divisor);\n  \n    # apply mapping function\n    my $space = $block($remainder);\n  \n    # find index of the $space'th element of the array that's still empty\n    my $index = @array.kv.grep(-> $i,$v { $v eq '-' })[$space][0];\n  \n    # and place the piece\n    @array[$index] = $piece;\n  }\n  return @array;\n}\n\n# demo code\nsay chess960(518); #standard optning position\nsay chess960; # (it happened to pick #300)\n\n```\n\nOutput:\n\n```\n♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜\n♛ ♝ ♞ ♜ ♚ ♜ ♝ ♞\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGenerate an array, list, lazy sequence, or even an indexable string of all the lower case ASCII characters, from  a  to  z. If the standard library contains such a sequence, show how to access it, but don't fail to show how to generate a similar sequence.\n\nFor this basic task use a reliable style of coding, a style fit for a very large program, and use strong typing if available. It's bug prone to enumerate all the lowercase characters manually in the code.\n\nDuring code review it's not immediate obvious to spot the bug in a Tcl line like this contained in a page of code:\n\n```\nset alpha {a b c d e f g h i j k m n o p q r s t u v w x y z}\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-10-21\n\n```\nsay my @letters = 'a'..'z';\n```\n\n* `'a'..'z'` is a range literal, it constructs an immutable `Range` object.\n* Assigning to an `@` variable flattens it into an `Array`."}]}
{"messages": [{"role": "user", "content": "Task\n\nGenerate a random chess position in FEN format.\n\nThe position does not have to be realistic or even balanced,  but it must comply to the following rules:\n\n:   * there is one and only one king of each color  (one black king and one white king);\n    * the kings must not be placed on adjacent squares;\n    * there can not be any pawn in the promotion square  (no white pawn in the eighth rank, and no black pawn in the first rank);\n    * including the kings, up to 32 pieces of either color can be placed.\n    * There is no requirement for material balance between sides.\n    * The picking of pieces does not have to comply to a regular chess set --- there can be five knights, twenty rooks, whatever ... as long as the total number of pieces do not exceed thirty-two.\n    * it is white's turn.\n    * It's assumed that both sides have lost castling rights and that there is no possibility for   *en passant*   (the FEN should thus end in w - - 0 1).\n\nNo requirement is made regarding the probability distribution of your method, but your program should be able to span a reasonably representative sample of all possible positions. For instance, programs that would always generate positions with say five pieces on the board, or with kings on a corner, would not be considered truly random."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub pick-FEN {\n    # First we chose how many pieces to place\n    my $n = (2..32).pick;\n\n    # Then we pick $n squares\n    my @n = (^64).pick($n);\n\n    # We try to find suitable king positions on non-adjacent squares.\n    # If we could not find any, we return recursively\n    return pick-FEN() unless\n    my @kings[2] = first -> [$a, $b] {\n        $a !== $b && abs($a div 8 - $b div 8) | abs($a mod 8 - $b mod 8) > 1\n    }, (@n X @n);\n\n    # We make a list of pieces we can pick (apart from the kings)\n    my @pieces = <p P n N b B r R q Q>;\n\n    # We make a list of two king symbols to pick randomly a black or white king\n    my @k = <K k>.pick(*);\n\n    return (gather for ^64 -> $sq {\n        if $sq == @kings.any { take @k.shift }\n        elsif $sq == @n.any {\n            my $row = 7 - $sq div 8;\n            take\n            $row == 7 ?? @pieces.grep(none('P')).pick !!\n            $row == 0 ?? @pieces.grep(none('p')).pick !!\n            @pieces.pick;\n        }\n        else { take 'ø' }\n    }).rotor(8)».join».subst(/ø+/,{ .chars }, :g).join('/') ~ ' w - - 0 1';\n}\n\nsay pick-FEN();\n\n```\n\nOutput:\n\n```\nq2n1n2/1Qpk3Q/1r3bP1/1b1b4/2pRBR2/4P1bN/2R3K1/N1r2rPB w - - 0 1\n```"}]}
{"messages": [{"role": "user", "content": "Many puzzle games such as the 15 puzzle game need a way to randomize the order of the pieces. One way to do this is to create an array and fill it with random values, with each element's index in that array being its position. Unfortunately, most random number generators can produce the same value more than once, which in this case isn't what we want.\n\nTask\n\nCreate a random number generator and have it output the numbers 1 through 20 (inclusive), in a random order. It cannot produce the same value more than once.\n\nOr\n\nGiven the output of an existing random number generator that *does* produce repeated output, create a function that constrains the output to numbers 1 through 20 (inclusive), and no number is output more than once. (Technically it stops being \"random\" at that point, but that's beyond the scope of this task.) Try your best not to make the process take too long at runtime.\n\nFor the second version of the task, the random number generator itself need not be implemented; however you must specify its possible range of values before your constraint function is applied. (e.g \"Assume the random number generator creates a value from 0 to 255, and values are allowed to repeat\")\n\nRelated Tasks\n:   * 15 Puzzle Solver\n    * 16 Puzzle Game\n    * Random numbers"}, {"role": "assistant", "content": "Raku has three distinct \"random\" functions built in. rand() for when you want some fraction between 0 and 1. roll() when you want to select elements from a collection with replacement (rolls of a die). And pick() for when you want to select some elements from a collection *without* replacement. (pick a card, any card, or two cards or 10 cards...). If you want to select *all* the elements in random order, just pick 'whatever'. Here we'll pick all from 1 to 20, 5 times using the repetition operator.\n\nPick random elements *without* replacement\n\n```\n.put for (1..20).pick(*) xx 5\n\n```\n\nSample output:\n\n```\n20 4 5 7 15 19 2 16 8 6 3 12 14 13 10 18 9 17 1 11\n4 5 18 10 13 3 1 11 6 2 19 8 12 7 16 17 14 20 15 9\n14 8 15 11 17 4 3 10 18 7 16 13 1 20 12 9 6 5 19 2\n7 5 15 11 12 18 17 3 20 6 13 19 14 2 16 10 4 9 8 1\n19 12 4 7 3 20 13 17 5 8 6 15 10 18 1 11 2 14 16 9\n```\n\nPick random elements *with* replacement\n\n```\n.put for (1..20).roll(20) xx 5\n\n```\n\nSample output:\n\n```\n16 20 15 17 13 4 19 1 3 8 4 12 13 4 4 5 14 17 10 14\n12 6 8 8 9 6 2 4 16 8 4 3 14 8 19 20 5 12 7 15\n20 4 20 16 14 6 15 15 16 18 5 19 20 3 14 11 2 7 13 12\n3 19 11 13 9 4 5 11 2 20 16 17 14 18 12 10 4 1 13 2\n17 20 12 17 19 4 20 20 14 8 2 19 2 12 18 14 4 14 10 8\n```"}]}
{"messages": [{"role": "user", "content": "A generator is an executable entity (like a function or procedure) that contains code that yields a sequence of values, one at a time, so that each time you call the generator, the next value in the sequence is provided.\n\nGenerators are often built on top of coroutines or objects so that the internal state of the object is handled “naturally”.\n\nGenerators are often used in situations where a sequence is potentially infinite, and where it is possible to construct the next value of the sequence with only minimal state.\n\nTask\n\n* Create a function that returns a generation of the m'th powers of the positive integers starting from zero, in order, and without obvious or simple upper limit. (Any upper limit to the generator should not be stated in the source but should be down to factors such as the languages natural integer size limit or computational time/size).\n* Use it to create a generator of:\n\n:   :   :   * Squares.\n            * Cubes.\n\n* Create a new generator that filters all cubes from the generator of squares.\n* Drop the first 20 values from this last generator of filtered results, and then show the next 10 values.\n\nNote that this task *requires* the use of generators in the calculation of the result.\n\nAlso see\n\n* Generator"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nAs with Haskell, generators are disguised as lazy lists in Raku.\n\n```\nsub powers($m) { 0..* X** $m }\n\nmy @squares = powers(2);\nmy @cubes   = powers(3);\n\nsub infix:<with-out> (@orig, @veto) {\n    gather for @veto -> $veto {\n        take @orig.shift while @orig[0] before $veto;\n        @orig.shift if @orig[0] eqv $veto;\n    }\n}\n\nsay (@squares with-out @cubes)[20 ..^ 20+10].join(', ');\n\n```\n\nOutput:\n\n```\n529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a generic swap function or operator which exchanges the values of two variables (or, more generally, any two storage places that can be assigned), regardless of their types.\n\nIf your solution language is statically typed please describe the way your language provides genericity.\n\nIf variables are typed in the given language, it is permissible that the two variables be constrained to having a mutually compatible type, such that each is permitted to hold the value previously stored in the other without a type violation.\nThat is to say, solutions do not have to be capable of exchanging, say, a string and integer value, if the underlying storage locations are not attributed with types that permit such an exchange.\n\nGeneric swap is a task which brings together a few separate issues in programming language semantics.\n\nDynamically typed languages deal with values in a generic way quite readily, but do not necessarily make it easy to write a function to destructively swap two variables, because this requires indirection upon storage places or upon the syntax designating storage places.\n\nFunctional languages, whether static or dynamic, do not necessarily allow a destructive operation such as swapping two variables regardless of their generic capabilities.\n\nSome static languages have difficulties with generic programming due to a lack of support for (Parametric Polymorphism).\n\nDo your best!"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nSimilar to Perl 5. Raku supports type constraints for variables and subroutines, unlike Perl 5, but the default is still to permit all values.\n\nAlternatively, you can write it like this:\n\n```\n($x, $y) .= reverse;\n```"}]}
{"messages": [{"role": "user", "content": "Geohashes are used to represent standard latitude and longitude coordinates as single values in the form of a simple string -- using the digits (0-9) and the letters (B-Z excluding I, L, O). They can vary in length, with more characters in the string representing more precision.\n\nTask\n\nGenerate a Geohash with a desired precision from a coordinate represented as an array of two floating point numbers, latitude and longitude. (Ideally double precision).\n\n**Example 1:**\n:   print (encodeGeohash (for: [51.433718, -0.214126], withPrecision: 2))\n:   // Result: \"gc\" (all of Ireland, most of England and Wales, small part of Scotland)\n\n**Example 2:**\n:   print (encodeGeohash (for: [51.433718, -0.214126], withPrecision: 9))\n:   // Result: \"gcpue5hp4\" (the umpire's chair on Center Court at Wimbledon)\n\nFrom the Wikipedia page, geohashes can be \"useful in database systems where queries on a single index are much easier or faster than multiple-index queries.\"\n\nExtra credit\n\nProvide a decode function to convert a geohash code back to latitude and longitude, expressed either as ranges or in median +/- deviation format.\n\nReference\n\n* Wikipedia article - Geohash."}, {"role": "assistant", "content": "### Module based\n\nReference: Used this for verification.\n\n```\n#20200615 Raku programming solution\n\nuse Geo::Hash;\n\n# task example 1 : Ireland, most of England and Wales, small part of Scotland\nsay geo-encode(51.433718e0, -0.214126e0, 2);\n\n# task example 2 : the umpire's chair on Center Court at Wimbledon\nsay geo-encode(51.433718e0, -0.214126e0, 9);\n\n# Lake Raku is an artificial lake in Tallinn, Estonia\n# https://goo.gl/maps/MEBXXhiFbN8WMo5z8\nsay geo-encode(59.358639e0, 24.744778e0, 4);\n\n# Village Raku is a development committee in north-western Nepal\n# https://goo.gl/maps/33s7k2h3UrHCg8Tb6\nsay geo-encode(29.2021188e0, 81.5324561e0, 4);\n\n```\n\nOutput:\n\n```\ngc\ngcpue5hp4\nud99\ntv1y\n\n```\n\n### Roll your own\n\nAlternately, a roll-your-own version that will work with any Real coordinate, not just floating point values, and thus can return ridiculous precision.\nThe geo-decode routine returns the range in which the actual value will be found; converted here to the mid-point with the interval size. Probably better\nto specify an odd precision so the error interval ends up the same for both latitude and longitude.\n\n```\nmy @Geo32 = <0 1 2 3 4 5 6 7 8 9 b c d e f g h j k m n p q r s t u v w x y z>;\n\nsub geo-encode ( Rat(Real) $latitude, Rat(Real) $longitude, Int $precision = 9 ) {\n    my @coord = $latitude, $longitude;\n    my @range = [-90, 90], [-180, 180];\n    my $which = 1;\n    my $value = '';\n    while $value.chars < $precision * 5 {\n        my $mid = @range[$which].sum / 2;\n        $value ~= my $upper = +(@coord[$which] > $mid);\n        @range[$which][not $upper] = $mid;\n        $which = not $which;\n    }\n    @Geo32[$value.comb(5)».parse-base(2)].join;\n}\n\nsub geo-decode ( Str $geo ) {\n     my @range = [-90, 90], [-180, 180];\n     my $which = 1;\n     my %Geo32 = @Geo32.antipairs;\n     for %Geo32{$geo.comb}».fmt('%05b').join.comb {\n         @range[$which][$_] = @range[$which].sum / 2;\n         $which = not $which;\n     }\n     @range\n}\n\n# TESTING\n\nfor 51.433718,   -0.214126,  2, # Ireland, most of England and Wales, small part of Scotland\n    51.433718,   -0.214126,  9, # the umpire's chair on Center Court at Wimbledon\n    51.433718,   -0.214126, 17, # likely an individual molecule of the chair\n    57.649110,   10.407440, 11, # Wikipedia test value - Råbjerg Mile in Denmark\n    59.358639,   24.744778,  7, # Lake Raku in Estonia\n    29.2021188, 81.5324561,  7  # Village Raku in Nepal\n  -> $lat, $long, $precision {\n     say \"$lat, $long, $precision:\\ngeo-encoded: \",\n     my $enc = geo-encode $lat, $long, $precision;\n     say 'geo-decoded: ', geo-decode($enc).map( {-.sum/2 ~ ' ± ' ~\n          (abs(.[0]-.[1])/2).Num.fmt('%.3e')} ).join(',  ') ~ \"\\n\";\n}\n\n```\n\n```\n51.433718, -0.214126, 2:\ngeo-encoded: gc\ngeo-decoded: 53.4375 ± 2.813e+00,  -5.625 ± 5.625e+00\n\n51.433718, -0.214126, 9:\ngeo-encoded: gcpue5hp4\ngeo-decoded: 51.4337182 ± 2.146e-05,  -0.21412611 ± 2.146e-05\n\n51.433718, -0.214126, 17:\ngeo-encoded: gcpue5hp4ebnf8unc\ngeo-decoded: 51.43371800000523 ± 2.046e-11,  -0.21412600000303 ± 2.046e-11\n\n57.64911, 10.40744, 11:\ngeo-encoded: u4pruydqqvj\ngeo-decoded: 57.64911063 ± 6.706e-07,  10.407439694 ± 6.706e-07\n\n59.358639, 24.744778, 7:\ngeo-encoded: ud99ejf\ngeo-decoded: 59.358444 ± 6.866e-04,  24.744644 ± 6.866e-04\n\n29.2021188, 81.5324561, 7:\ngeo-encoded: tv1ypk4\ngeo-decoded: 29.202347 ± 6.866e-04,  81.532974 ± 6.866e-04\n\n```"}]}
{"messages": [{"role": "user", "content": "**Geometric algebra** is another name for Clifford algebras and it's basically an algebra containing a vector space \n\nV\n{\\displaystyle {\\displaystyle {\\mathcal {V}}}}\n and obeying the following axioms:\n\n:   (\n    a\n    b\n    )\n    c\n    =\n    a\n    (\n    b\n    c\n    )\n\n\n    a\n    (\n    b\n    +\n    c\n    )\n    =\n    a\n    b\n    +\n    a\n    c\n\n\n    (\n    a\n    +\n    b\n    )\n    c\n    =\n    a\n    c\n    +\n    b\n    c\n\n\n    ∀\n\n    x\n    ∈\n\n\n    V\n    ,\n\n    x\n\n    2\n    ∈\n\n    R\n    {\\displaystyle {\\displaystyle {\\begin{array}{c}(ab)c=a(bc)\\\\a(b+c)=ab+ac\\\\(a+b)c=ac+bc\\\\\\forall \\mathbf {x} \\in {\\mathcal {V}},\\,\\mathbf {x} ^{2}\\in \\mathbb {R} \\end{array}}}}\n\nThe product operation in such algebra is called the *geometric product*. Elements are called *multivectors*, while multivectors in \n\nV\n{\\displaystyle {\\displaystyle {\\mathcal {V}}}}\n are just called *vectors*.\n\nThere are a few simple examples of geometric algebras. A trivial one for instance is simply \n\nR\n{\\displaystyle {\\displaystyle \\mathbb {R} }}\n, where \n\nV\n=\n\nR\n{\\displaystyle {\\displaystyle {\\mathcal {V}}=\\mathbb {R} }}\n. The complex numbers also form a geometric algebra, where the vector space is the one-dimensional space of all purely imaginary numbers. Another example is the space of quaternions, where the vector space is the three-dimensional space of all linear combinations of \n\n(\ni\n,\nj\n,\nk\n)\n{\\displaystyle {\\displaystyle (i,j,k)}}\n.\n\nThe purpose of this task is to implement a geometric algebra with a vector space \n\nV\n{\\displaystyle {\\displaystyle {\\mathcal {V}}}}\n of dimension *n* of at least five, but for extra-credit you can implement a version with *n* arbitrary large. Using a dimension five is useful as it is the dimension required for the so-called *conformal model* which will be the subject of a derived task.\n\nTo ensure the unicity of the solution (that is, up to some isomorphism), we will also restrict ourselves to the so-called euclidean case, where the square of a non-zero vector is positive:\n\n∀\n\nx\n∈\n\n\nV\n,\n\n\nx\n≠\n0\n\n⟹\n\nx\n\n2\n>\n0\n{\\displaystyle {\\displaystyle \\forall \\mathbf {x} \\in {\\mathcal {V}},\\,\\mathbf {x} \\neq 0\\implies \\mathbf {x} ^{2}>0}}\n.\n\nYou can of course, for extra credit, implement the general case. This would require the definition of a parameter for the *signature* of the metric.\n\nIn order to show that your solution uses a vector space of dimension at least five, you will create a function n -> e(n) such that the vectors e(0), e(1), e(2), e(3), e(4) are linearly independent. To do so you will make them orthonormal with the following scalar product:\n\nx\n⋅\n\ny\n=\n(\n\nx\n\ny\n+\n\ny\n\nx\n)\n\n/\n2\n{\\displaystyle {\\displaystyle \\mathbf {x} \\cdot \\mathbf {y} =(\\mathbf {x} \\mathbf {y} +\\mathbf {y} \\mathbf {x} )/2}}\n\nThe fact that this so-called *inner product* defines a scalar product is a consequence of the fourth axiom. To see it one just needs to notice the relation:\n\nx\n\ny\n+\n\ny\n\nx\n=\n(\n\nx\n+\n\ny\n\n)\n\n2\n−\n\n\nx\n\n2\n−\n\n\ny\n\n2\n{\\displaystyle {\\displaystyle \\mathbf {x} \\mathbf {y} +\\mathbf {y} \\mathbf {x} =(\\mathbf {x} +\\mathbf {y} )^{2}-\\mathbf {x} ^{2}-\\mathbf {y} ^{2}}}\n\nOnce you'll have shown that your vector space is at least of dimension five, you will show that the axioms are satisfied. For this purpose you will pick three random multivectors *a*, *b* and *c*, along with a random vector \n\nx\n{\\displaystyle {\\displaystyle \\mathbf {x} }}\n.\n\nProducing a random vector is easy. Just use a pseudo-random generation function rand and create a vector:\n\nr\na\nn\nd\no\nm\nV\ne\nc\nt\no\nr\n(\n)\n=\n\n∑\n\ni\n=\n0\n\n4\n\nr\na\nn\nd\n(\n)\n\n\ne\n\ni\n{\\displaystyle {\\displaystyle \\mathrm {randomVector} ()=\\sum \\_{i=0}^{4}\\mathrm {rand} ()\\mathbf {e} \\_{i}}}\n\nProducing a random multivector is slightly more involved. It is known that when the dimension of \n\nV\n{\\displaystyle {\\displaystyle {\\mathcal {V}}}}\n is *n*, then the dimension of the algebra (seen as a vector space with its natural scalar multiplication) is 2n. This means that for n=5 there is a basis of 25 = 32 basis multivectors from which any multivector can be written as a linear combination. Create such a basis \n\nm\n\n0\n,\n\nm\n\n1\n,\n…\n,\n\nm\n\n31\n{\\displaystyle {\\displaystyle m\\_{0},m\\_{1},\\ldots ,m\\_{31}}}\n along with a function producting a random multivector:\n\nr\na\nn\nd\no\nm\nM\nu\nl\nt\ni\nv\ne\nc\nt\no\nr\n(\n)\n=\n\n∑\n\ni\n=\n0\n\n31\n\nr\na\nn\nd\n(\n)\n\nm\n\ni\n{\\displaystyle {\\displaystyle \\mathrm {randomMultivector} ()=\\sum \\_{i=0}^{31}\\mathrm {rand} ()m\\_{i}}}\n\nTo summarize, to solve this task you will:\n\n* define the inner product of two vectors : \n\n  x\n  ⋅\n\n  y\n  =\n  (\n\n  x\n  y\n  +\n\n  y\n  x\n  )\n\n  /\n  2\n  {\\displaystyle {\\displaystyle \\mathbf {x} \\cdot \\mathbf {y} =(\\mathbf {xy} +\\mathbf {yx} )/2}}\n  .\n* define the function e\n* verify the orthonormality \n\n  e\n\n  i\n  ⋅\n\n\n  e\n\n  j\n  =\n\n  δ\n\n  i\n  ,\n  j\n  {\\displaystyle {\\displaystyle \\mathbf {e} \\_{i}\\cdot \\mathbf {e} \\_{j}=\\delta \\_{i,j}}}\n   for i, j in \n\n  {\n  0\n  ,\n  1\n  ,\n  2\n  ,\n  3\n  ,\n  4\n  }\n  {\\displaystyle {\\displaystyle \\{0,1,2,3,4\\}}}\n  .\n* create a function returning a random multivector\n* create a function returning a random vector\n* verify the axioms for three rarndom multivectors *a*, *b*, *c* and a random vector **x**.\n\nOptionally, you will repeat the last step a large number of times, in order to increase confidence in the result."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nHere we write a simplified version of the Clifford module. It is very general as it is of infinite dimension and also contains an anti-euclidean basis @ē in addition to the euclidean basis @e.\n\n```\nclass MultiVector is Mix {\n  subset Vector of ::?CLASS is export where *.grades.all == 1;\n\n  method narrow { self.keys.any > 0 ?? self !!  (self{0} // 0) }\n  method grades { self.keys.map: *.base(2).comb.sum }\n\n  multi method new(Real $x) returns ::?CLASS { self.new-from-pairs: 0 => $x }\n  multi method new(Str $ where /^^e(\\d+)$$/) { self.new-from-pairs: (1 +< (2*$0)) => 1 }\n\n  our @e is export = map { ::?CLASS.new: \"e$_\" }, ^Inf;\n\n  my sub order(UInt:D $i is copy, UInt:D $j) {\n    (state %){$i}{$j} //= do {\n      my $n = 0;\n      repeat {\n\t$i +>= 1;\n\t$n += [+] ($i +& $j).polymod(2 xx *);\n      } until $i == 0;\n      $n +& 1 ?? -1 !! 1;\n    }\n  }\n\n  sub infix:<·>(Vector $x, Vector $y) returns Real is export { (($x*$y + $y*$x)/2){0} }\n \n  multi infix:<+>(::?CLASS $A, ::?CLASS $B) returns ::?CLASS is export {\n    return ::?CLASS.new-from-pairs: |$A.pairs, |$B.pairs;\n  }\n  multi infix:<+>(Real $s, ::?CLASS $B) returns ::?CLASS is export {\n    samewith $B.new($s), $B\n  }\n  multi infix:<+>(::?CLASS $A, Real $s) returns ::?CLASS is export {\n    samewith $s, $A\n  }\n\n  multi infix:<*>(::?CLASS $,  0) is export { 0  }\n  multi infix:<*>(::?CLASS $A, 1) returns ::?CLASS is export { $A }\n  multi infix:<*>(::?CLASS $A, Real $s) returns ::?CLASS is export {\n    ::?CLASS.new-from-pairs: $A.pairs.map({Pair.new: .key, $s*.value})\n  }\n  multi infix:<*>(::?CLASS $A, ::?CLASS $B) returns ::?CLASS is export {\n    ::?CLASS.new-from-pairs: gather\n      for $A.pairs -> $a {\n\tfor $B.pairs -> $b {\n\t  take ($a.key +^ $b.key) => [*]\n\t    $a.value, $b.value,\n\t    order($a.key, $b.key),\n\t    |grep +*, (\n\t\t|(1, -1) xx * Z*\n\t\t($a.key +& $b.key).polymod(2 xx *)\n\t    )\n\t}\n      }\n  }\n  multi infix:<**>(::?CLASS $ , 0) returns ::?CLASS is export { ::?CLASS.new: (0 => 1).Mix }\n  multi infix:<**>(::?CLASS $A, 1) returns ::?CLASS is export { $A }\n  multi infix:<**>(::?CLASS $A, 2) returns ::?CLASS is export { $A * $A }\n  multi infix:<**>(::?CLASS $A, UInt $n where $n %% 2) returns ::?CLASS is export { ($A ** ($n div 2)) ** 2 }\n  multi infix:<**>(::?CLASS $A, UInt $n) returns ::?CLASS is export { $A * ($A ** ($n div 2)) ** 2 }\n\n  multi infix:<*>(Real $s, ::?CLASS $A) returns ::?CLASS is export { $A * $s }\n  multi infix:</>(::?CLASS $A, Real $s) returns ::?CLASS is export { $A * (1/$s) }\n  multi prefix:<->(::?CLASS $A) returns ::?CLASS is export { return -1 * $A }\n  multi infix:<->(::?CLASS $A, ::?CLASS $B) returns ::?CLASS is export { $A + -$B }\n  multi infix:<->(::?CLASS $A, Real $s) returns ::?CLASS is export { $A + -$s }\n  multi infix:<->(Real $s, ::?CLASS $A) returns ::?CLASS is export { $s + -$A }\n\n  multi infix:<==>(::?CLASS $A, 0) returns Bool is export { $A.elems == 0 }\n  multi infix:<==>(::?CLASS $A, ::?CLASS $B) returns Bool is export { samewith $A - $B, 0 }\n  multi infix:<==>(Real $x, ::?CLASS $A) returns Bool is export { samewith $A, $x }\n  multi infix:<==>(::?CLASS $A, Real $x) returns Bool is export { samewith $A, $A.new($x); }\n\n  sub random is export {\n      [+] map {\n\t  ::?CLASS.new-from-pairs: $_ => rand.round(.01)\n      }, ^32;\n  }\n}\n\n#########################################\n##  Test code to verify the solution:  ##\n#########################################\n\nimport MultiVector;\nuse Test;\n \nconstant N = 10;\nplan 5;\n \nsubtest \"Orthonormality\", {\n  for ^N X ^N -> ($i, $j) {\n    my $s = $i == $j ?? 1 !! 0;\n    ok @e[$i]·@e[$j] == $s, \"e$i·e$j = $s\";\n  }\n}\n \nmy ($a, $b, $c) = random() xx 3;\n \nok ($a*$b)*$c == $a*($b*$c), 'associativity';\nok $a*($b + $c) == $a*$b + $a*$c, 'left distributivity';\nok ($a + $b)*$c == $a*$c + $b*$c, 'right distributivity';\nmy @coeff = (.5 - rand) xx 5;\nmy $v = [+] @coeff Z* @e[^5];\nok ($v**2).narrow ~~ Real, 'contraction';\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nExecute a system command and get its output into the program. The output may be stored in any kind of collection (array, list, etc.).\n\nRelated task\n\n* Execute a system command"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nIf you don't want to execute it in shell (and you probably don't), then use this:\n\n```\nsay run($command, $arg1, $arg2, :out).out.slurp;\n\n```\n\nUnfortunately, it is very long to type, but that is the only way to pass your variables as arguments safely.\n\nYou might be tempted to start using shell when you have to pipe something, but even in that case there is no need to do so. See this code:\n\n```\nmy $p1 = run 'echo', 'Hello, world', :out;\nmy $p2 = run 'cat', '-n', :in($p1.out), :out;\nsay $p2.out.slurp-rest;\n\n```\n\nSee docs for more info.\n\nIf you really want to run something in shell and you understand potential security problems, then you can use `qx//` (interpolates environment variables) or `qqx//` (interpolates normally). See the docs for more info.\n\n```\nsay qx[dir]\n\n```\n\nOutput:\n\n```\nFind_URI_in_text.p6  History_variables.p6  K-d_tree.pl\nFractran.pl\t     History_variables.pl  XML_Input.p6\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program (function) to get the number of decimal places in a given number.\n\nExamples\n:   * for num = 12.345         decimals = 3,     and\n    * for num = 12.3450       decimals = 4\n\n(Note that the reference implementation – in the **Ring** language – shows a function over a given **number** rather than a given numeric string, and that the sample values shown above are not enclosed in quotes)."}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.07\n\nRaku does not specifically have a \"decimal\" number type, however we can\neasily determine the fractional precision of a rational number. It is somewhat\ntouchy-feely for floating point numbers; (what is the fractional precision for\n2.45e-12?), it's pretty pointless for Integers; (zero, aalllways zero...), but\nRats (rationals) are doable. Note that these are (mostly) actual numerics, not\nnumeric strings. The exception is '12.3450'. That is a numeric string since\nactual numerics automatically truncate non-significant trailing zeros. If you\nwant to retain them, you need to pass the value as a string. (As below.)\n\n```\nuse Rat::Precise;\n\nprintf \"Fractional precision: %-2s || Number: %s\\n\", (.split('.')[1] // '').chars, $_\n    for 9, 12.345, '12.3450', 0.1234567890987654321, (1.5**63).precise;\n\n```\n\nOutput:\n\n```\nFractional precision: 0  || Number: 9\nFractional precision: 3  || Number: 12.345\nFractional precision: 4  || Number: 12.3450\nFractional precision: 19 || Number: 0.1234567890987654321\nFractional precision: 63 || Number: 124093581919.648947697827373650380188008224280338254175148904323577880859375\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nA **Giuga number** is a composite number **n** which is such that each of its distinct prime factors\n**f** divide (n/f - 1) exactly.\n\nAll known Giuga numbers are even though it is not known for certain that there are no odd examples.\n\nExample\n\n30 is a Giuga number because its distinct prime factors are 2, 3 and 5 and:\n\n* 30/2 - 1 = 14 is divisible by 2\n* 30/3 - 1 = 9 is divisible by 3\n* 30/5 - 1 = 5 is divisible by 5\n\nTask\n\nDetermine and show here the first four Giuga numbers.\n\nStretch\n\nDetermine the fifth Giuga number and any more you have the patience for.\n\nReferences\n\n* Wikipedia: Giuga number\n* OEIS:A007850 - Giuga numbers"}, {"role": "assistant", "content": "```\nmy @primes = (3..60).grep: &is-prime;\n\nprint 'First four Giuga numbers: ';\n\nput sort flat (2..4).map: -> $c {\n    @primes.combinations($c).map: {\n        my $n = [×] 2,|$_;\n        $n if all .map: { ($n / $_ - 1) %% $_ };\n    }\n}\n\n```\n\nOutput:\n\n```\nFirst 4 Giuga numbers: 30 858 1722 66198\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nReplace every occurring instance of a piece of text in a group of text files with another one.\n\nFor this task we want to replace the text   \"**Goodbye London!**\"   with   \"**Hello New York!**\"   for a list of files."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nCurrent Raku implementations do not yet support the -i flag for editing files in place, so we roll our own (rather unsafe) version:\n\n```\nslurp($_).subst('Goodbye London!', 'Hello New York!', :g) ==> spurt($_)\n    for <a.txt b.txt c.txt>;\n\n```"}]}
{"messages": [{"role": "user", "content": "Write a program to let the user play Go Fish against a computer opponent. Use the following rules:\n\n* Each player is dealt nine cards to start with.\n* On their turn, a player asks their opponent for a given rank (such as threes or kings). A player must already have at least one card of a given rank to ask for more.\n  + If the opponent has any cards of the named rank, they must hand over all such cards, and the requester can ask again.\n  + If the opponent has no cards of the named rank, the requester draws a card and ends their turn.\n* A *book* is a collection of every card of a given rank. Whenever a player completes a book, they may remove it from their hand.\n* If at any time a player's hand is empty, they may immediately draw a new card, so long as any new cards remain in the deck.\n* The game ends when every book is complete. The player with the most books wins.\n\nThe game's AI need not be terribly smart, but it should use at least some strategy. That is, it shouldn't choose legal moves entirely at random.\n\nYou may want to use code from Playing Cards.\n\nRelated tasks:\n\n* Playing cards\n* Card shuffles\n* Deal cards\\_for\\_FreeCell\n* War Card\\_Game\n* Poker hand\\_analyser"}, {"role": "assistant", "content": "(formerly Perl 6)\nSee Go Fish/Raku"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Goldbach's comet. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\n**Goldbach's comet** is the name given to a plot of the function **g(E)**, the so-called **Goldbach function**.\n\nThe Goldbach function is studied in relation to Goldbach's conjecture. The function **g(E)** is defined for all *even* integers **E>2** to be the number of different ways in which E can be expressed as the sum of two primes.\n\nExamples\n\n* G(4) = 1, since 4 can only be expressed as the sum of one distinct pair of primes (4 = 2 + 2)\n* G(22) = 3, since 22 can be expressed as the sum of 3 distinct pairs of primes (22 = 11 + 11 = 5 + 17 = 3 + 19)\n\nTask\n\n* Find and show (preferably, in a neat 10x10 table) the first 100 G numbers (that is: the result of the G function described above, for the first 100 even numbers >= 4)\n* Find and display the value of G(1000000)\n\nStretch\n\n* Calculate the values of G up to 2000 (inclusive) and display the results in a scatter 2d-chart, aka the Goldbach's Comet\n\nSee also\n\n* Wikipedia: Goldbach's conjecture * OEIS: A045917 - From Goldbach problem: number of decompositions of 2n into unordered sums of two primes"}, {"role": "assistant", "content": "For the stretch, actually generates a plot, doesn't just calculate values to be plotted by a third party application. Deviates slightly from the stretch goal, plots the first two thousand defined values rather than the values up to two thousand that happen to be defined. (More closely matches the wikipedia example image.)\n\n```\nsub G (Int $n) { +(2..$n/2).grep: { .is-prime && ($n - $_).is-prime } }\n\n# Task\nput \"The first 100 G values:\\n\", (^100).map({ G 2 × $_ + 4 }).batch(10)».fmt(\"%2d\").join: \"\\n\";\n\nput \"\\nG 1_000_000 = \", G 1_000_000;\n\n# Stretch\nuse SVG;\nuse SVG::Plot;\n\nmy @x = map 2 × * + 4, ^2000;\nmy @y = @x.map: &G;\n\n'Goldbachs-Comet-Raku.svg'.IO.spurt: SVG.serialize: SVG::Plot.new(\n    width       => 1000,\n    height      => 500,\n    background  => 'white',\n    title       => \"Goldbach's Comet\",\n    x           => @x,\n    values      => [@y,],\n).plot: :points;\n\n```\n\nOutput:\n\n```\nThe first 100 G values:\n 1  1  1  2  1  2  2  2  2  3\n 3  3  2  3  2  4  4  2  3  4\n 3  4  5  4  3  5  3  4  6  3\n 5  6  2  5  6  5  5  7  4  5\n 8  5  4  9  4  5  7  3  6  8\n 5  6  8  6  7 10  6  6 12  4\n 5 10  3  7  9  6  5  8  7  8\n11  6  5 12  4  8 11  5  8 10\n 5  6 13  9  6 11  7  7 14  6\n 8 13  5  8 11  7  9 13  8  9\n\nG 1_000_000 = 5402\n```\n\n**Stretch goal:** (offsite SVG image) Goldbachs-Comet-Raku.svg"}]}
{"messages": [{"role": "user", "content": "The golden ratio can be defined as the continued fraction\n\n:   ϕ\n    =\n    1\n    +\n\n\n    1\n\n    1\n    +\n\n\n    1\n\n    1\n    +\n\n\n    1\n\n    1\n    +\n    ⋯\n    {\\displaystyle {\\displaystyle \\phi =1+{1 \\over {1+{1 \\over {1+{1 \\over {1+\\cdots }}}}}}}}\n\nThus \n\nϕ\n=\n1\n+\n\n1\n\n/\nϕ\n{\\displaystyle {\\displaystyle \\phi =1+{1/\\phi }}}\n. Multiplying both sides by \n\nϕ\n{\\displaystyle {\\displaystyle \\phi }}\n and solving the resulting quadratic equation for its positive solution, one gets \n\nϕ\n=\n(\n1\n+\n\n\n5\n)\n\n/\n2\n≈\n1.61803398875\n{\\displaystyle {\\displaystyle \\phi =(1+{\\sqrt {5}})/2\\approx 1.61803398875}}\n.\n\nThe golden ratio has the slowest convergence of any continued fraction, as one might guess by noting that the denominators are made of the smallest positive integer. This task treats the problem of convergence in a somewhat backwards fashion: we are going to iterate the recursion \n\nϕ\n\nn\n+\n1\n=\n1\n+\n\n1\n\n/\n\nϕ\n\nn\n{\\displaystyle {\\displaystyle \\phi \\_{n+1}=1+{1/\\phi \\_{n}}}}\n, \n\nϕ\n\n0\n=\n1\n{\\displaystyle {\\displaystyle \\phi \\_{0}=1}}\n, and see how long it takes to get an answer.\n\n### Task\n\nIterate \n\nϕ\n\nn\n+\n1\n=\n1\n+\n\n1\n\n/\n\nϕ\n\nn\n{\\displaystyle {\\displaystyle \\phi \\_{n+1}=1+{1/\\phi \\_{n}}}}\n, \n\nϕ\n\n0\n=\n1\n{\\displaystyle {\\displaystyle \\phi \\_{0}=1}}\n, until \n\n|\n\nϕ\n\nn\n+\n1\n−\n\nϕ\n\nn\n\n|\n≤\n1\n×\n\n10\n\n−\n5\n{\\displaystyle {\\displaystyle |\\phi \\_{n+1}-\\phi \\_{n}|\\leq 1\\times 10^{-5}}}\n. Report the final value of \n\nϕ\n\nn\n+\n1\n{\\displaystyle {\\displaystyle \\phi \\_{n+1}}}\n, the number of iterations required, and the error with respect to \n\n(\n1\n+\n\n\n5\n)\n\n/\n2\n{\\displaystyle {\\displaystyle (1+{\\sqrt {5}})/2}}\n.\n\n### See also\n\n* Metallic ratios"}, {"role": "assistant", "content": "```\nconstant phi = 1.FatRat, 1 + 1/* ... { abs($^a-$^b)≤1e-5 };\n\nsay \"It took {phi.elems} iterations to reach {phi.tail}\";\nsay \"The error is {{ ($^a - $^b)/$^b }(phi.tail, (1+sqrt(5))/2)}\"\n\n```\n\nOutput:\n\n```\nIt took 15 iterations to reach 1.618033\nThe error is -7.427932029059675e-07\n```"}]}
{"messages": [{"role": "user", "content": "Background\n\nGoodstein sequences are sequences defined for a given counting number n by applying increasing bases to a representation of n after n has been\nused to construct a *hereditary representation* of that number, originally in base 2.\n\nStart by defining the hereditary base-b representation of a number n. Write n as a sum of powers of b, staring with b = 2. For example, with\nn = 29, write 31 = 16 + 8 + 4 + 1. Now we write each exponent as a sum of powers of n, so as 2^4 + 2^3 + 2^1 + 2^0.\n\nContinue by re-writing all of the current term's exponents that are still > b as a sum of terms that are <= b, using a sum of powers of b: so,\nn = 16 + 8 + 4 + 1 = 2^4 + 2^3 + 2 + 1 = 2^(2^2) + 2^(2 + 1) + 2 + 1.\n\nIf we consider this representation as a representation of a calculation with b = 2, we have the hereditary representation\nb^(b^b) + b^(b + 1) + b + 1.\n\nOther integers and bases are done similarly. Note that an exponential term can be repeated up to (b - 1) times, so that, for example,\nif b = 5, 513 = b^3 + b^3 + b^3 + b^3 + b + b + 3 = 4 \\* b^3 + 2 \\* b + 3.\n\nThe Goodstein sequence for n, G(n) is then defined as follows:\n\nThe first term, considered the zeroeth term or G(n)(0), is always 0. The second term G(n)(1) is always n. For further terms,\nthe m-th term G(n)(m) is defined by the following procedure:\n\n```\n   1. Write G(n)(m - 1) as a hereditary representation with base (m - 1).\n   2. Calculate the results of using the hereditary representation found in step 1 using base m rather than (m - 1)\n   3. Subtract 1 from the result calculated in step 2.\n\n```\n\nTask\n\n* Create a function to calculate the Goodstein sequence for a given integer.\n\n* Use this to show the first 10 values of Goodstein(n) for the numbers from 0 through 7.\n\n* Find the nth term (counting from 0) of Goodstein(n) for n from 0 through 10.\n\nStretch task\n\n* Find the nth term (counting from 0) of Goodstein(n) for n = 11 through 16.\n\nSee also\n\n:   * Wikipedia entry for Goodstein's theorem\n    * OEIS Goodstein numbers such that a(n) = G\\_n(n), where G is the Goodstein function\n    * [| \"Googology site article \" ]"}, {"role": "assistant", "content": "**Translation of**: Phix\n\n```\n# 20240219 Raku programming solution\n\nsub bump($n is copy, $b) {\n   loop ( my ($res, $i) = 0, 0; $n.Bool or return $res; $i++,$n div= $b) {\n      if my $d = $n % $b { $res += $d * ($b+1) ** bump($i,$b) }\n   }\n}\n\nsub goodstein($n, $maxterms = 10) {\n   my @res = $n;\n   while @res.elems < $maxterms && @res[*-1] != 0 {\n      @res.push(bump(@res[*-1], (@res.elems + 1)) - 1)\n   }\n   return @res\n}\n\nsay \"Goodstein(n) sequence (first 10) for values of n from 0 through 7:\";\nfor 0..7 -> $i { say \"Goodstein of $i: \", goodstein($i) }\n\nmy $max = 16;\nsay \"\\nThe Nth term of Goodstein(N) sequence counting from 0, for values of N from 0 through $max :\";\nfor 0..$max -> $i { say \"Term $i of Goodstein($i): {goodstein($i, $i+1)[*-1]}\" }\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "**Gosper's Hack** is an efficient method of computing the next higher integer with the same number of set bits (Hamming weight). It was invented by Bill Gosper. The algorithm is widely used in combinatorics for enumerating combinations.\n\nTask\n\nWrite a function or procedure to compute the next higher integer with the same number of set bits as a given positive integer, using Gosper’s Hack.\n\nShow the result of applying it ten times to each of the numbers 1, 3, 7, and 15.\n\nReference\n\n* Gosper's Hack explained"}, {"role": "assistant", "content": "```\nsub gosper ($x) {\n    my $c = $x +& -$x;\n    my $r = $x + $c;\n    ((($r +^ $x) +> 2) / $c) +| $r\n}\n\nfor 1, 3, 7, 15 -> $start {\n    my @g = $start, { gosper $_ } … *;\n    say @g[^11].fmt('%8d');\n    say @g[^11].fmt('%08b');\n    say '';\n}\n\n```\n\nOutput:\n\n```\n       1        2        4        8       16       32       64      128      256      512     1024\n00000001 00000010 00000100 00001000 00010000 00100000 01000000 10000000 100000000 1000000000 10000000000\n\n       3        5        6        9       10       12       17       18       20       24       33\n00000011 00000101 00000110 00001001 00001010 00001100 00010001 00010010 00010100 00011000 00100001\n\n       7       11       13       14       19       21       22       25       26       28       35\n00000111 00001011 00001101 00001110 00010011 00010101 00010110 00011001 00011010 00011100 00100011\n\n      15       23       27       29       30       39       43       45       46       51       53\n00001111 00010111 00011011 00011101 00011110 00100111 00101011 00101101 00101110 00110011 00110101\n\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nIn programming, a gotcha is a valid construct in a system, program or programming language that works as documented but is counter-intuitive and almost invites mistakes because it is both easy to invoke and unexpected or unreasonable in its outcome.\n\nTask\n\nGive an example or examples of common gotchas in your programming language and what, if anything, can be done to defend against it or them without using special tools."}, {"role": "assistant", "content": "Raku embraces the philosophy of DWIM or \"Do What I Mean\". A DWIMmy\nlanguage tends to avoid lots of boilerplate code, and accept a certain amount of\nimprecision to return the result that, for the vast majority of the time, is\nwhat the user intended.\n\nFor example, a numeric string may be treated as either a numeric value or a\nstring literal, without needing to explicitly coerce it to one or the other.\nThis makes for easy translation of ideas into code, and is generally a good\nthing. HOWEVER, it doesn't always work out. Sometimes it leads to unexpected\nbehavior, commonly referred to as WAT.\n\nIt is something of a running joke in the Raku community that \"For every DWIM,\nthere is an equal and opposite WAT\".\n\nLarry Wall, the author and designer of Perl and\nlead designer of Raku, coined a term to describe this DWIM / WAT\ncontinuum. The Waterbed Theory of Computational Complexity.\n\nThe Waterbed theory is the observation that complicated systems contain a minimum\namount of complexity, and that attempting to \"push down\" the complexity of such\na system in one place will invariably cause complexity to \"pop up\" elsewhere.\n\nMuch like how in a waterbed mattress, it is possible to push down the mattress in one\nplace, but the displaced water will always cause the mattress to rise elsewhere,\nbecause water does not compress. It is impossible to push down the waterbed\neverywhere at once.\n\nThere is a whole chapter in the Raku documentation about\n\"Traps to Avoid\" when beginning in Raku,\nmost of which, at least partially are due to WATs arising from DWIMmy behavior\nsomeplace else.\n\nExpanding on the numeric string example cited above; numeric values and numeric\nstrings may be used almost interchangeably in most cases.\n\n```\nsay 123 ~ 456; # join two integers together\nsay \"12\" + \"5.7\"; # add two numeric strings together\nsay .sqrt for <4 6 8>; # take the square root of several allomorphic numerics\n\n```\n\n```\n123456\n17.7\n2\n2.449489742783178\n2.8284271247461903\n```\n\nYou can run into problems though with certain constructs that are more strict about\nobject typing.\n\nA Bag is a \"counting\" construct. It takes a collection and counts how many of\neach object are within. Works great for strings.\n\n```\nsay my $bag = <a b a c a b d>.Bag;\nsay $bag{'a'}; # a count?\nsay $bag< a >; # another way\n\n```\n\n```\nBag(a(3) b(2) c d)\n3\n3\n```\n\nBut numerics can present unobvious problems.\n\n```\nsay my $bag = (1, '1', '1', <1 1 1>).Bag;\nsay $bag{ 1 }; # how many 1s?\nsay $bag{'1'}; # wait, how many?\nsay $bag< 1 >; # WAT\ndd $bag; # The different numeric types LOOK the same, but are different types behind the scenes\n\n```\n\n```\nBag(1 1(2) 1(3))\n1\n2\n3\nBag $bag = (1=>1,\"1\"=>2,IntStr.new(1, \"1\")=>3).Bag\n```\n\nThe different '1's are distinctive to the type system even if they visually look\nidentical when printing them to the console. They all have a value of 1 but are\nrespectively and Int, a String, and an IntStr allomorph. Many of the \"collective\"\nobjects have this property (Bags, Sets, Maps, etc.) This behavior is correct\nbut can be very jarring when you are used to being able to use numeric strings\nand numeric values nearly interchangeably.\n\nAnother such DWIMmy construct, which can trip up even experienced Raku programmers is\nThe Single Argument Rule.\n\nSingle argument is a special exception to parameterization rules causing an iterable\nobject to be be automatically flattened when passed to an iterator if only a single\nobject is passed.\n\nE.G. Say we have two small list objects; `(1,2,3)` and `(4,5,6)`,\nand we want to print the contents to the console.\n\n```\n.say for (1,2,3), (4,5,6);\n\n```\n\n```\n(1,2,3)\n(4,5,6)\n```\n\nHowever, if we only pass a single list to the iterator (`for`), it will\nflatten the object due to the single argument rule.\n\n```\n.say for (1,2,3);\n\n```\n\n```\n1\n2\n3\n```\n\nIf we want the multiple object non-flattening behavior, we need to \"fake it out\"\nby adding a trailing comma to signal to the compiler that this should be treated\nlike multiple object parameters even if there is only one. (Note the trailing comma after the list.)\n\n```\n.say for (1,2,3),;\n\n```\n\n```\n(1,2,3)\n```\n\nConversely, if we want the flattening behavior when passing multiple objects, we need to manually, explicitly flatten the objects.\n\n```\n.say for flat (1,2,3), (4,5,6);\n\n```\n\n```\n1\n2\n3\n4\n5\n6\n```\n\nSingle argument mostly arose in Raku to make it act more like Perl 5, for which\nit was originally conceived of as a replacement. Perl 5 flattens collective\nobject parameters by default, and the original non-flattening behavior was\n*extremely* confusing to early Perl / Raku crossover programmers. Larry Wall\ncame up with single argument to reduce confusion and increase DWIMiness, and it\nhas overall, but it still leads to the occasional WAT when programmers first bump up against it."}]}
{"messages": [{"role": "user", "content": "Gradient descent (also known as steepest descent) is a first-order iterative optimization algorithm for finding the minimum of a function which is described in this Wikipedia article.\n\nTask\n\nUse this algorithm to search for minimum values of the bi-variate function:\n\n```\n  f(x, y) = (x - 1)(x - 1)e^(-y^2) + y(y+2)e^(-2x^2)\n\n```\n\naround x = 0.1 and y = -1.\n\nThis book excerpt shows sample C# code for solving this task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Go\n\n```\n# 20200904 Updated Raku programming solution\n\nsub steepestDescent(@x, $alpha is copy, $h) {\n\n   my $g0 = g |@x ; # Initial estimate of result.\n\n   my @fi = gradG |@x ; #  Calculate initial gradient\n\n   my $b = $alpha / my $delG = sqrt ( sum @fi»² ) ;  # Calculate initial norm.\n\n   while ( $delG > $h ) {   # Iterate until value is <= tolerance.\n\n      @x «-»= $b «*« @fi; #  Calculate next value.\n\n      @fi = gradG |@x ; # Calculate next gradient and next value\n\n      $b = $alpha / ($delG = sqrt( sum @fi»² ));  # Calculate next norm.\n\n      my $g1 = g |@x ;\n\n      $g1 > $g0 ?? ( $alpha /= 2 ) !! ( $g0 = $g1 )   # Adjust parameter.\n   }\n}\n\nsub gradG(\\x,\\y) { # gives a rough calculation of gradient g(x).\n   2*(x-1)*exp(-y²) - 4*x*exp(-2*x²)*y*(y+2) , -2*(x-1)²*y*exp(-y²) + exp(-2*x²)*(2*y+2)\n}\n\n# Function for which minimum is to be found.\nsub g(\\x,\\y) { (x-1)² * exp(-y²) + y*(y+2) * exp(-2*x²) }\n\nmy $tolerance = 0.0000006 ; my $alpha = 0.1;\n\nmy @x = 0.1, -1; # Initial guess of location of minimum.\n\nsteepestDescent(@x, $alpha, $tolerance);\n\nsay \"Testing steepest descent method:\";\nsay \"The minimum is at x[0] = \", @x[0], \", x[1] = \", @x[1];\n\n```\n\nOutput:\n\n```\nTesting steepest descent method:\nThe minimum is at x[0] = 0.10762682432947938, x[1] = -1.2232596548816097\n\n```"}]}
{"messages": [{"role": "user", "content": "A Graph is a collection of nodes\n(or vertices), connected by edges (or not).\nNodes directly connected by edges are called neighbours.\n\nIn our representation of graphs, nodes are numbered and edges are represented\nby the two node numbers connected by the edge separated by a dash.\nEdges define the nodes being connected. Only unconnected nodes *need* a separate\ndescription.\n\nFor example,\n\n```\n0-1 1-2 2-0 3\n```\n\nDescribes the following graph. Note that node 3 has no neighbours\n\nExample graph\n\n```\n+---+\n| 3 |\n+---+\n\n  +-------------------+\n  |                   |\n+---+     +---+     +---+\n| 0 | --- | 1 | --- | 2 |\n+---+     +---+     +---+\n\n```\n\nA useful internal datastructure for a graph and for later graph algorithms is\nas a mapping between each node and the set/list of its neighbours.\n\nIn the above example:\n\n```\n0 maps-to 1 and 2\n1 maps to 2 and 0\n2 maps-to 1 and 0\n3 maps-to <nothing>\n```\n\nGraph colouring task\n\nColour the vertices of a given graph so that no edge is between verticies of\nthe same colour.\n\n* Integers may be used to denote different colours.\n* Algorithm should do better than just assigning each vertex a separate colour. The idea is to minimise the number of colours used, although no algorithm short of exhaustive search for the minimum is known at present, (and exhaustive search is **not** a requirement).\n* Show for each edge, the colours assigned on each vertex.\n* Show the total number of nodes, edges, and colours used for each graph.\n\nUse the following graphs\n\n\nEx1\n\n```\n       0-1 1-2 2-0 3\n\n```\n\n```\n+---+\n| 3 |\n+---+\n\n  +-------------------+\n  |                   |\n+---+     +---+     +---+\n| 0 | --- | 1 | --- | 2 |\n+---+     +---+     +---+\n\n```\n\nEx2\n\nThe wp articles left-side graph\n\n```\n   1-6 1-7 1-8 2-5 2-7 2-8 3-5 3-6 3-8 4-5 4-6 4-7\n\n```\n\n```\n\n\n  +----------------------------------+\n  |                                  |\n  |                      +---+       |\n  |    +-----------------| 3 | ------+----+\n  |    |                 +---+       |    |\n  |    |                   |         |    |\n  |    |                   |         |    |\n  |    |                   |         |    |\n  |  +---+     +---+     +---+     +---+  |\n  |  | 8 | --- | 1 | --- | 6 | --- | 4 |  |\n  |  +---+     +---+     +---+     +---+  |\n  |    |         |                   |    |\n  |    |         |                   |    |\n  |    |         |                   |    |\n  |    |       +---+     +---+     +---+  |\n  +----+------ | 7 | --- | 2 | --- | 5 | -+\n       |       +---+     +---+     +---+\n       |                   |\n       +-------------------+\n\n```\n\nEx3\n\nThe wp articles right-side graph which is the same graph as Ex2, but with\ndifferent node orderings and namings.\n\n```\n   1-4 1-6 1-8 3-2 3-6 3-8 5-2 5-4 5-8 7-2 7-4 7-6\n\n```\n\n```\n\n\n  +----------------------------------+\n  |                                  |\n  |                      +---+       |\n  |    +-----------------| 5 | ------+----+\n  |    |                 +---+       |    |\n  |    |                   |         |    |\n  |    |                   |         |    |\n  |    |                   |         |    |\n  |  +---+     +---+     +---+     +---+  |\n  |  | 8 | --- | 1 | --- | 4 | --- | 7 |  |\n  |  +---+     +---+     +---+     +---+  |\n  |    |         |                   |    |\n  |    |         |                   |    |\n  |    |         |                   |    |\n  |    |       +---+     +---+     +---+  |\n  +----+------ | 6 | --- | 3 | --- | 2 | -+\n       |       +---+     +---+     +---+\n       |                   |\n       +-------------------+\n\n```\n\nEx4\n\nThis is the same graph, node naming, and edge order as Ex2 except some of the edges x-y are flipped to y-x.\nThis might alter the node order used in the greedy algorithm leading to differing numbers of colours.\n\n```\n   1-6 7-1 8-1 5-2 2-7 2-8 3-5 6-3 3-8 4-5 4-6 4-7\n\n```\n\n```\n\n\n                      +-------------------------------------------------+\n                      |                                                 |\n                      |                                                 |\n  +-------------------+---------+                                       |\n  |                   |         |                                       |\n+---+     +---+     +---+     +---+     +---+     +---+     +---+     +---+\n| 4 | --- | 5 | --- | 2 | --- | 7 | --- | 1 | --- | 6 | --- | 3 | --- | 8 |\n+---+     +---+     +---+     +---+     +---+     +---+     +---+     +---+\n  |         |                             |         |         |         |\n  +---------+-----------------------------+---------+         |         |\n            |                             |                   |         |\n            |                             |                   |         |\n            +-----------------------------+-------------------+         |\n                                          |                             |\n                                          |                             |\n                                          +-----------------------------+\n\n```\n\nReferences\n\n* Greedy coloring Wikipedia.\n* Graph Coloring : Greedy Algorithm & Welsh Powell Algorithm by Priyank Jain."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub GraphNodeColor(@RAW) {\n   my %OneMany = my %NodeColor;\n   for @RAW { %OneMany{$_[0]}.push: $_[1] ; %OneMany{$_[1]}.push: $_[0] }\n   my @ColorPool = \"0\", \"1\" … ^+%OneMany.elems; # as string\n   my %NodePool  = %OneMany.BagHash; # this DWIM is nice\n   if %OneMany<NaN>:exists { %NodePool{$_}:delete for %OneMany<NaN>, NaN } # pending\n   while %NodePool.Bool {\n      my $color = @ColorPool.shift;\n      my %TempPool = %NodePool;\n      while (my \\n = %TempPool.keys.sort.first) {\n         %NodeColor{n} = $color;\n         %TempPool{n}:delete;\n         %TempPool{$_}:delete for @(%OneMany{n}) ; # skip neighbors as well\n         %NodePool{n}:delete;\n      }\n   }\n   if %OneMany<NaN>:exists { # islanders use an existing color\n      %NodeColor{$_} = %NodeColor.values.sort.first for @(%OneMany<NaN>)\n   }\n   return %NodeColor\n}\n\nmy \\DATA = [\n   [<0 1>,<1 2>,<2 0>,<3 NaN>,<4 NaN>,<5 NaN>],\n   [<1 6>,<1 7>,<1 8>,<2 5>,<2 7>,<2 8>,<3 5>,<3 6>,<3 8>,<4 5>,<4 6>,<4 7>],\n   [<1 4>,<1 6>,<1 8>,<3 2>,<3 6>,<3 8>,<5 2>,<5 4>,<5 8>,<7 2>,<7 4>,<7 6>],\n   [<1 6>,<7 1>,<8 1>,<5 2>,<2 7>,<2 8>,<3 5>,<6 3>,<3 8>,<4 5>,<4 6>,<4 7>],\n];\n\nfor DATA {\n   say \"DATA   : \", $_;\n   say \"Result : \";\n   my %out = GraphNodeColor $_;\n   say \"$_[0]-$_[1]:\\t Color %out{$_[0]} \",$_[1].isNaN??''!!%out{$_[1]} for @$_;\n   say \"Nodes  : \", %out.keys.elems;\n   say \"Edges  : \", $_.elems;\n   say \"Colors : \", %out.values.Set.elems;\n}\n\n```\n\nOutput:\n\n```\nDATA   : [(0 1) (1 2) (2 0) (3 NaN) (4 NaN) (5 NaN)]\nResult :\n0-1:     Color 0 1\n1-2:     Color 1 2\n2-0:     Color 2 0\n3-NaN:   Color 0\n4-NaN:   Color 0\n5-NaN:   Color 0\nNodes  : 6\nEdges  : 6\nColors : 3\nDATA   : [(1 6) (1 7) (1 8) (2 5) (2 7) (2 8) (3 5) (3 6) (3 8) (4 5) (4 6) (4 7)]\nResult :\n1-6:     Color 0 1\n1-7:     Color 0 1\n1-8:     Color 0 1\n2-5:     Color 0 1\n2-7:     Color 0 1\n2-8:     Color 0 1\n3-5:     Color 0 1\n3-6:     Color 0 1\n3-8:     Color 0 1\n4-5:     Color 0 1\n4-6:     Color 0 1\n4-7:     Color 0 1\nNodes  : 8\nEdges  : 12\nColors : 2\nDATA   : [(1 4) (1 6) (1 8) (3 2) (3 6) (3 8) (5 2) (5 4) (5 8) (7 2) (7 4) (7 6)]\nResult :\n1-4:     Color 0 1\n1-6:     Color 0 2\n1-8:     Color 0 3\n3-2:     Color 1 0\n3-6:     Color 1 2\n3-8:     Color 1 3\n5-2:     Color 2 0\n5-4:     Color 2 1\n5-8:     Color 2 3\n7-2:     Color 3 0\n7-4:     Color 3 1\n7-6:     Color 3 2\nNodes  : 8\nEdges  : 12\nColors : 4\nDATA   : [(1 6) (7 1) (8 1) (5 2) (2 7) (2 8) (3 5) (6 3) (3 8) (4 5) (4 6) (4 7)]\nResult :\n1-6:     Color 0 1\n7-1:     Color 1 0\n8-1:     Color 1 0\n5-2:     Color 1 0\n2-7:     Color 0 1\n2-8:     Color 0 1\n3-5:     Color 0 1\n6-3:     Color 1 0\n3-8:     Color 0 1\n4-5:     Color 0 1\n4-6:     Color 0 1\n4-7:     Color 0 1\nNodes  : 8\nEdges  : 12\nColors : 2\n```"}]}
{"messages": [{"role": "user", "content": "Gray code is a form of binary encoding where transitions between consecutive numbers differ by only one bit. This is a useful encoding for reducing hardware data hazards with values that change rapidly and/or connect to slower hardware as inputs. It is also useful for generating inputs for Karnaugh maps in order from left to right or top to bottom.\n\nCreate functions to encode a number to and decode a number from Gray code.\n\nDisplay the normal binary representations, Gray code representations, and decoded Gray code values for all 5-bit binary numbers (0-31 inclusive, leading 0's not necessary).\n\nThere are many possible Gray codes. The following encodes what is called \"binary reflected Gray code.\"\n\nEncoding (MSB is bit 0, b is binary, g is Gray code):\n\n```\nif b[i-1] = 1\n   g[i] = not b[i]\nelse\n   g[i] = b[i]\n```\n\nOr:\n\n```\ng = b xor (b logically right shifted 1 time)\n```\n\nDecoding (MSB is bit 0, b is binary, g is Gray code):\n\n```\nb[0] = g[0]\n\nfor other bits:\nb[i] = g[i] xor b[i-1]\n```\n\nReference\n\n* Converting Between Gray and Binary Codes. It includes step-by-step animations."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub gray_encode ( Int $n --> Int ) {\n    return $n +^ ( $n +> 1 );\n}\n\nsub gray_decode ( Int $n is copy --> Int ) {\n    my $mask = 1 +< (32-2);\n    $n +^= $mask +> 1 if $n +& $mask while $mask +>= 1;\n    return $n;\n}\n\nfor ^32 -> $n {\n    my $g = gray_encode($n);\n    my $d = gray_decode($g);\n    printf \"%2d: %5b => %5b => %5b: %2d\\n\", $n, $n, $g, $d, $d;\n    die if $d != $n;\n}\n\n```\n\nOutput:\n\n```\n 0:     0 =>     0 =>     0:  0\n 1:     1 =>     1 =>     1:  1\n 2:    10 =>    11 =>    10:  2\n 3:    11 =>    10 =>    11:  3\n 4:   100 =>   110 =>   100:  4\n 5:   101 =>   111 =>   101:  5\n 6:   110 =>   101 =>   110:  6\n 7:   111 =>   100 =>   111:  7\n 8:  1000 =>  1100 =>  1000:  8\n 9:  1001 =>  1101 =>  1001:  9\n10:  1010 =>  1111 =>  1010: 10\n11:  1011 =>  1110 =>  1011: 11\n12:  1100 =>  1010 =>  1100: 12\n13:  1101 =>  1011 =>  1101: 13\n14:  1110 =>  1001 =>  1110: 14\n15:  1111 =>  1000 =>  1111: 15\n16: 10000 => 11000 => 10000: 16\n17: 10001 => 11001 => 10001: 17\n18: 10010 => 11011 => 10010: 18\n19: 10011 => 11010 => 10011: 19\n20: 10100 => 11110 => 10100: 20\n21: 10101 => 11111 => 10101: 21\n22: 10110 => 11101 => 10110: 22\n23: 10111 => 11100 => 10111: 23\n24: 11000 => 10100 => 11000: 24\n25: 11001 => 10101 => 11001: 25\n26: 11010 => 10111 => 11010: 26\n27: 11011 => 10110 => 11011: 27\n28: 11100 => 10010 => 11100: 28\n29: 11101 => 10011 => 11101: 29\n30: 11110 => 10001 => 11110: 30\n31: 11111 => 10000 => 11111: 31\n\n```\n\nRaku distinguishes numeric bitwise operators with a leading + sign,\nso +< and +> are left and right shift,\nwhile +& is a bitwise AND, while +^ is bitwise XOR\n(here used as part of an assignment metaoperator)."}]}
{"messages": [{"role": "user", "content": "Many image processing algorithms are defined for grayscale (or else monochromatic) images.\n\nTask\n\nExtend the data storage type defined on this page to support grayscale images.\n\nDefine two operations, one to convert a color image to a grayscale image and one for the backward conversion.\n\nTo get luminance of a color use the formula recommended by CIE:\n\n```\n L  =  0.2126 × R   +   0.7152 × G   +   0.0722 × B \n\n```\n\nWhen using floating-point arithmetic make sure that rounding errors would not cause run-time problems or else distorted results when calculated luminance is stored as an unsigned integer."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis script expects to be fed a P6 .ppm file name at the command line. It will convert it to grey scale and save it as a binary portable grey map (P5 .pgm) file.\n\n```\nsub MAIN ($filename = 'default.ppm') {\n\n    my $in = open($filename, :r, :enc<iso-8859-1>) or die $in;\n\n    my ($type, $dim, $depth) = $in.lines[^3];\n\n    my $outfile = $filename.subst('.ppm', '.pgm');\n    my $out = open($outfile, :w, :enc<iso-8859-1>) or die $out;\n\n    $out.say(\"P5\\n$dim\\n$depth\");\n\n    for $in.lines.ords -> $r, $g, $b {\n        my $gs = $r * 0.2126 + $g * 0.7152 + $b * 0.0722;\n        $out.print: chr($gs.floor min 255);\n    }\n\n    $in.close;\n    $out.close;\n}\n\n```\n\nUsing the .ppm file from the Write a PPM file task:\n\nOriginal:  Grey Scale:"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind the greatest common divisor   (**GCD**)   of two integers.\n\n*Greatest common divisor*   is also known as   *greatest common factor* **(gcf)**   and   *greatest common measure*.\n\nRelated task\n:   * least common multiple.\n\nSee also\n:   * MathWorld entry:   greatest common divisor.\n    * Wikipedia entry:     greatest common divisor."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Iterative\n\n```\nsub gcd (Int $a is copy, Int $b is copy) {\n   $a & $b == 0 and fail;\n   ($a, $b) = ($b, $a % $b) while $b;\n   return abs $a;\n}\n```\n\n### Recursive\n\n```\nmulti gcd (0,      0)      { fail }\nmulti gcd (Int $a, 0)      { abs $a }\nmulti gcd (Int $a, Int $b) { gcd $b, $a % $b }\n```\n\n### Recursive(inline coderef)\n\n```\n{ $^b ?? &?BLOCK( $^b, $^a % $^b ) !! $^a }\n```\n\n### Concise\n\n```\nmy &gcd = { ($^a.abs, $^b.abs, * % * ... 0)[*-2] }\n```\n\n### Actually, it's a built-in infix\n\n```\nmy $gcd = $a gcd $b;\n```\n\nBecause it's an infix, you can use it with various meta-operators:\n\n```\n[gcd] @list;         # reduce with gcd\n@alist Zgcd @blist;  # lazy zip with gcd\n@alist Xgcd @blist;  # lazy cross with gcd\n@alist »gcd« @blist; # parallel gcd\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a function that returns the maximum value in a provided set of values,\n  \nwhere the number of values may not be known until run-time."}, {"role": "assistant", "content": "(formerly Perl 6)\nThe built-in function works with any type that defines ordering.\n\n```\nsay max 10, 4, 5, -2, 11;\nsay max <zero one two three four five six seven eight nine>;\n\n# Even when the values and number of values aren't known until runtime\nmy @list = flat(0..9,'A'..'H').roll((^60).pick).rotor(4,:partial)».join.words;\nsay @list, ': ', max @list;\n```\n\nSample output:\n\n```\n11\nzero\n[6808 013C 6D5B 4219 29G9 DC13 CA4F 55F3 AA06 0AGF DAB0 2]: DC13\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nA cubefree number is a positive integer whose prime factorization does not contain any third (or higher) power factors. If follows that all primes are trivially cubefree and the first cubefree number is 1 because it has no prime factors.\n\nLet a[n] be the greatest prime dividing the n-th cubefree number for n >= 2. By convention, let a[1] = 1 even though the first cubefree number, 1, has no prime factors.\n\nExamples\n\na[2] is clearly 2 because it is the second cubefree number and also prime. The fourth cubefree number is 4 and it's highest prime factor is 2, hence a[4] = 2.\n\nTask\n\nCompute and show on this page the first **100** terms of a[n].\nAlso compute and show the **1,000th**, **10,000th** and **100,000th** members of the sequence.\n\nStretch\n\nCompute and show the **1 millionth** and **10 millionth** terms of the sequence.\n\nThis may take a while for interpreted languages.\n\nReference\n\n* OEIS sequence: A370833: a(n) is the greatest prime dividing the n-th cubefree number, for n >= 2; a(1)=1.\n* The number of integers in a given interval which are multiple of at least one of the given numbers"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\n\nsub max_factor_if_cubefree ($i) {\n    my @f = prime-factors($i);\n    return @f.tail if @f.elems          < 3\n                   or @f.Bag.values.all < 3;\n}\n\nconstant @Aₙ = lazy flat 1, map &max_factor_if_cubefree, 2..*;\n\nsay 'The first terms of A370833 are:';\nsay .fmt('%3d') for @Aₙ.head(100).batch(10);\n\nsay '';\n\nfor 10 X** (3..6) -> $k {\n    printf \"The %8dth term of A370833 is %7d\\n\", $k, @Aₙ[$k-1];\n}\n\n```\n\nOutput:\n\n```\nThe first terms of A370833 are:\n  1   2   3   2   5   3   7   3   5  11\n  3  13   7   5  17   3  19   5   7  11\n 23   5  13   7  29   5  31  11  17   7\n  3  37  19  13  41   7  43  11   5  23\n 47   7   5  17  13  53  11  19  29  59\n  5  61  31   7  13  11  67  17  23   7\n 71  73  37   5  19  11  13  79  41  83\n  7  17  43  29  89   5  13  23  31  47\n 19  97   7  11   5 101  17 103   7  53\n107 109  11  37 113  19  23  29  13  59\n\nThe     1000th term of A370833 is     109\nThe    10000th term of A370833 is     101\nThe   100000th term of A370833 is    1693\nThe  1000000th term of A370833 is 1202057\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a sequence of integers, find a continuous subsequence which maximizes the sum of its elements, that is, the elements of no other single subsequence add up to a value larger than this one.\n\nAn empty subsequence is considered to have the sum of   **0**;   thus if all elements are negative, the result must be the empty sequence."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n**Works with**: Rakudo version 2016.12\n\n```\nsub max-subseq (*@a) {\n    my ($start, $end, $sum, $maxsum) = -1, -1, 0, 0;\n    for @a.kv -> $i, $x {\n        $sum += $x;\n        if $maxsum < $sum {\n            ($maxsum, $end) = $sum, $i;\n        }\n        elsif $sum < 0 {\n            ($sum, $start) = 0, $i;\n        }\n    }\n    return @a[$start ^.. $end];\n}\n\n```\n\nAnother solution, not translated from any other language:\n\nFor each starting position, we calculate all the subsets starting at that position.\nThey are combined with the best subset ($max-subset) from previous loops, to form (@subsets).\nThe best of those @subsets is saved at the new $max-subset.\n\nConsuming the array (.shift) allows us to skip tracking the starting point; it is always 0.\n\nThe empty sequence is used to initialize $max-subset, which fulfils the \"all negative\" requirement of the problem.\n\n```\nsub max-subseq ( *@a ) {\n\n    my $max-subset = ();\n    while @a {\n        my @subsets = [\\,] @a;\n        @subsets.push: $max-subset;\n        $max-subset = @subsets.max: { [+] .list };\n        @a.shift;\n    }\n\n    return $max-subset;\n}\n\nmax-subseq( -1, -2,  3,  5,  6, -2, -1,  4, -4,  2, -1 ).say;\nmax-subseq( -2, -2, -1,  3,  5,  6, -1,  4, -4,  2, -1 ).say;\nmax-subseq( -2, -2, -1, -3, -5, -6, -1, -4, -4, -2, -1 ).say;\n\n```\n\nOutput:\n\n```\n(3 5 6 -2 -1 4)\n(3 5 6 -1 4)\n()\n```"}]}
{"messages": [{"role": "user", "content": "This task is about making a clone of the game \"GREED\" by Matthew Day.\n\nThis game is played on a grid of   **79**   column by   **22**   rows of random numbers from   **1**   to   **9**   (inclusive).\n\nThe player location is signified by the   **@**   symbol.\n\nThe object of Greed is to erase as much of the screen as possible by moving around   (all 8 directions are allowed in this grid).\n\nWhen you move in a direction,   **N**   number of grid squares are erased (\"eaten\") in that direction,   **N**   being the first number in that direction.\n\nYour score reflects the total number of squares \"eaten\".\n\nYou may not make a move that places you off the grid or over a previously eaten square.\n\nThe game is over if there is no more valid moves.\n\nVideo on YouTube"}, {"role": "assistant", "content": "**Translation of**: Phix\n\n```\n# 20200913 added Raku programming solution\n\nsrand 123456;\n\nmy @board = [ (1..9).roll xx my \\w = 79 ] xx my \\h = 22 ;\nmy \\X = $ = w.rand.Int ; my \\Y = $ = h.rand.Int;\n@board[Y;X] = '@';\nmy \\score = $ = 0;\n\nsub execute (\\y,\\x) {\n   my \\i = $ = @board[Y+y;X+x];\n   if countSteps(i, x, y) {\n      score += i;\n      @board[ Y +  y*$_ ; X +  x*$_ ] = ' ' for ^i;\n      @board[ Y += y*i  ; X += x*i  ] = '@';\n   }\n}\n\nsub countSteps(\\i, \\x, \\y) {\n   my \\tX = $ = X ; my \\tY = $ = Y;\n   for ^i {\n      tX += x; tY += y;\n      return False if tX < 0 or tY < 0 or tX ≥ w or tY ≥ h or @board[tY;tX] eq ' ' \n   }\n   return True;\n}\n\nsub existsMoves {\n   for (-1 .. 1) X (-1 .. 1) -> (\\x,\\y) {\n      next if x == 0 and y == 0;\n      next if X+x < 0 or X+x > w or Y+y < 0 or Y+y > h ;\n      my \\i = @board[Y+y;X+x];\n      return True if ( i ne ' ' and countSteps(i, x, y) )\n   }\n   return False;\n}\n\nloop {\n   for @board { .join.print ; print \"\\r\\n\" } ;\n   { say \"Game over.\" and last } unless existsMoves();\n   print \"Current score : \", score, \"\\r\\n\";\n   given my $c = $*IN.getc {\n      when 'q' { say \"So long.\" and last}\n      when 'e' { execute(-1,-1) if X > 0 and Y > 0 } # North-West\n      when 'r' { execute(-1, 0) if           Y > 0 } # North\n      when 't' { execute(-1, 1) if X < w and Y > 0 } # North-East\n      when 'd' { execute( 0,-1) if X > 0           } # West\n      when 'g' { execute( 0, 1) if X < w           } # East\n      when 'x' { execute( 1,-1) if X > 0 and Y < h } # South-West\n      when 'c' { execute( 1, 0) if           Y < h } # South\n      when 'v' { execute( 1, 1) if X < w and Y < h } # South-East\n   }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "An   Egyptian fraction   is the sum of distinct unit fractions such as:\n\n:   :   :   :   1\n                2\n                +\n\n                1\n                3\n                +\n\n                1\n                16\n\n                (\n                =\n\n                43\n                48\n                )\n                {\\displaystyle {\\displaystyle {\\tfrac {1}{2}}+{\\tfrac {1}{3}}+{\\tfrac {1}{16}}\\,(={\\tfrac {43}{48}})}}\n\nEach fraction in the expression has a numerator equal to   **1**   (unity)   and a denominator that is a positive integer,   and all the denominators are distinct   (i.e., no repetitions).\n\nFibonacci's   Greedy algorithm for Egyptian fractions   expands the fraction    \n\nx\ny\n{\\displaystyle {\\displaystyle {\\tfrac {x}{y}}}}\n    to be represented by repeatedly performing the replacement\n\n:   :   :   :   x\n                y\n                =\n\n\n                1\n\n                ⌈\n                y\n\n                /\n                x\n                ⌉\n                +\n\n                (\n                −\n                y\n                )\n\n                mod\n\n\n                x\n\n                y\n                ⌈\n                y\n\n                /\n                x\n                ⌉\n                {\\displaystyle {\\displaystyle {\\frac {x}{y}}={\\frac {1}{\\lceil y/x\\rceil }}+{\\frac {(-y)\\!\\!\\!\\!\\mod x}{y\\lceil y/x\\rceil }}}}\n\n(simplifying the 2nd term in this replacement as necessary, and where    \n\n⌈\nx\n⌉\n{\\displaystyle {\\displaystyle \\lceil x\\rceil }}\n    is the   *ceiling*   function).\n\nFor this task,   Proper and improper fractions   must be able to be expressed.\n\nProper  fractions   are of the form    \n\na\nb\n{\\displaystyle {\\displaystyle {\\tfrac {a}{b}}}}\n    where    \n\na\n{\\displaystyle {\\displaystyle a}}\n    and    \n\nb\n{\\displaystyle {\\displaystyle b}}\n    are positive integers, such that    \n\na\n<\nb\n{\\displaystyle {\\displaystyle a<b}}\n,     and\n\nimproper fractions are of the form    \n\na\nb\n{\\displaystyle {\\displaystyle {\\tfrac {a}{b}}}}\n    where    \n\na\n{\\displaystyle {\\displaystyle a}}\n    and    \n\nb\n{\\displaystyle {\\displaystyle b}}\n    are positive integers, such that    *a* ≥ *b*.\n\n(See the REXX programming example to view one method of expressing the whole number part of an improper fraction.)\n\nFor improper fractions, the integer part of any improper fraction should be first isolated and shown preceding the Egyptian unit fractions, and be surrounded by square brackets [*n*].\n\nTask requirements\n\n* show the Egyptian fractions for: \n\n  43\n  48\n  {\\displaystyle {\\displaystyle {\\tfrac {43}{48}}}}\n   and \n\n  5\n  121\n  {\\displaystyle {\\displaystyle {\\tfrac {5}{121}}}}\n   and \n\n  2014\n  59\n  {\\displaystyle {\\displaystyle {\\tfrac {2014}{59}}}}\n* for all proper fractions,    \n\n  a\n  b\n  {\\displaystyle {\\displaystyle {\\tfrac {a}{b}}}}\n      where    \n\n  a\n  {\\displaystyle {\\displaystyle a}}\n      and    \n\n  b\n  {\\displaystyle {\\displaystyle b}}\n      are positive one-or two-digit (decimal) integers, find and show an Egyptian fraction that has:\n\n:   :   * the largest number of terms,\n        * the largest denominator.\n\n* for all one-, two-, and three-digit integers,   find and show (as above).     {extra credit}\n\nAlso see\n\n* Wolfram MathWorld™ entry: Egyptian fraction\n* Numberphile YouTube video: Egyptian Fractions and the Greedy Algorithm"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nrole Egyptian {\n    method gist {\n\tjoin ' + ',\n\t    (\"[{self.floor}]\" if self.abs >= 1),\n\t    map {\"1/$_\"}, self.denominators;\n    }\n    method denominators {\n\tmy ($x, $y) = self.nude;\n\t$x %= $y;\n\tmy @denom = gather ($x, $y) = -$y % $x, $y * take ($y / $x).ceiling\n\t    while $x;\n    }\n}\n\nsay .nude.join('/'), \" = \", $_ but Egyptian for 43/48, 5/121, 2014/59;\n\nmy @sample = map { $_ => .denominators },\n    grep * < 1, \n        map {$_ but Egyptian}, \n            (2 .. 99 X/ 2 .. 99);\n\nsay .key.nude.join(\"/\"),\n    \" has max denominator, namely \",\n    .value.max\n        given max :by(*.value.max), @sample;\n\nsay .key.nude.join(\"/\"),\n    \" has max number of denominators, namely \",\n    .value.elems\n        given max :by(*.value.elems), @sample;\n\n```\n\nOutput:\n\n```\n43/48 = 1/2 + 1/3 + 1/16\n5/121 = 1/25 + 1/757 + 1/763309 + 1/873960180913 + 1/1527612795642093418846225\n2014/59 = [34] + 1/8 + 1/95 + 1/14947 + 1/670223480\n8/97 has max denominator, namely 579504587067542801713103191859918608251030291952195423583529357653899418686342360361798689053273749372615043661810228371898539583862011424993909789665\n8/97 has max number of denominators, namely 8\n```\n\nBecause the harmonic series diverges (albeit very slowly), it is possible to write even improper fractions as a sum of distinct unit fractions. Here is a code to do that:\n\n```\nrole Egyptian {\n    method gist { join ' + ', map {\"1/$_\"}, self.list }\n    method list {\n\tmy $sum = 0;\n\tgather for 2 .. * {\n\t    last if $sum == self;\n\t    $sum += 1 / .take unless $sum + 1 / $_ > self;\n\t}\n    }\n}\n \nsay 5/4 but Egyptian;\n\n```\n\nOutput:\n\n```\n1/2 + 1/3 + 1/4 + 1/6\n```\n\nThe list of terms grows exponentially with the value of the fraction, though."}]}
{"messages": [{"role": "user", "content": "The task is to display a series of vertical greyscale bars (contrast bars) with a sufficient number of bars to span the entire width of the display.\n\nFor the top quarter of the display, the left hand bar should be black, and we then incrementally step through six shades of grey until we have a white bar on the right hand side of the display. (This gives a total of 8 bars)\n\nFor the second quarter down, we start with white and step down through 14 shades of gray, getting darker until we have black on the right hand side of the display. (This gives a total of 16 bars).\n\nHalfway down the display, we start with black, and produce 32 bars, ending in white, and for the last quarter, we start with white and step through 62 shades of grey, before finally arriving at black in the bottom right hand corner, producing a total of 64 bars for the bottom quarter."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy ($width,$height) = 1280,768;\n \nmy $PGM = open \"Greyscale-bars-perl6.pgm\", :w orelse die \"Can't create Greyscale-bars-perl6.pgm: $_\";\n \n$PGM.print: qq:to/EOH/;\n    P2\n    # Greyscale-bars-perl6.pgm\n    $width $height\n    65535\n    EOH\n \nmy ($h1,$h2,$h3,$h4) = divvy($height,4);\n \nmy @nums = ((0/7,1/7...7/7) X* 65535)».floor;\nmy $line = ~(@nums Zxx divvy($width,8));\n$PGM.say: $line for ^$h1;\n \n@nums = ((15/15,14/15...0/15) X* 65535)».floor;\n$line = ~(@nums Zxx divvy($width,16));\n$PGM.say: $line for ^$h2;\n \n@nums = ((0/31,1/31...31/31) X* 65535)».floor;\n$line = ~(@nums Zxx divvy($width,32));\n$PGM.say: $line for ^$h3;\n \n@nums = ((63/63,62/63...0/63) X* 65535)».floor;\n$line = ~(@nums Zxx divvy($width,64));\n$PGM.say: $line for ^$h4;\n \n$PGM.close;\n \nsub divvy($all, $div) {\n    my @marks = ((1/$div,2/$div ... 1) X* $all)».round;\n    @marks Z- 0,|@marks;\n}\n\n```\n\nSee Greyscale-bars-perl6 (offsite image)"}]}
{"messages": [{"role": "user", "content": "**GSTrans** string encoding is a method of encoding all 8-bit character values 0-255 with only printable characters. It originates on Acorn computers to allow command line\ncommands to process non-printable characters.\n\n```\n Character Encoding\n 0-31      |letter eg |@, |A, |i |[ etc.\n 32-126    character, except for:\n \"         |\"\n |         ||\n 127       |?\n 128-255   |! followed by encoding, eg |!|@ = 128\n\n```\n\nA string can be surrounded in quotes, eg \"ALERT|G\".\n\nSee http://www.riscos.com/support/developers/prm/conversions.html\n\nExamples:\n\n```\n |LHello|G|J|M       encodes  CHR$12;\"Hello\";CHR$7;CHR$10;CHR$13\n \"|m|j|@|e|!t|m|!|?\" encodes  13,10,0,5,244,13,255\n\n```\n\nTask\n\n:   * Write two functions, one to encode a string of characters into a GSTrans string, and one to decode a GSTrans string. Indicate if any error checking is done, and how it is indicated."}, {"role": "assistant", "content": "**Translation of**: Julia\n\n```\n# 20231105 Raku programming solution\n\nsub GSTrans-encode(Str $str) {\n   return [~] $str.encode('utf8').list.chrs.comb.map: -> $c { \n      my $i = $c.ord;\n      die \"Char value of $c, $i, is out of range\" unless 0 <= $i <= 255;\n      given ($i,$c) { \n         when 0 <= $i <= 31    { '|' ~ chr(64 + $i) } \n         when $c eq '\"'        { '|\"' }\n         when $c eq '|'        { '||' }\n         when $i == 127        { '|?' }\n         when 128 <= $i <= 255 { '|!' ~ GSTrans-encode(chr($i - 128)) }\n         default               { $c }\n      }\n   }\n}\n\nsub GSTrans-decode(Str $str) {\n   my ($gotbar, $gotbang, $bangadd) = False, False, 0;\n\n   my @result = gather for $str.comb -> $c {\n      if $gotbang {\n         if $c eq '|' {\n            $bangadd = 128;\n            $gotbar = True;\n         } else {\n            take $c.ord + 128;\n         }\n         $gotbang = False;\n      } elsif $gotbar {\n         given $c {\n            when $c eq '?' { take 127 + $bangadd }\n            when $c eq '!' { $gotbang = True }\n            when $c eq '|' || $c eq '\"' || $c eq '<' { take $c.ord + $bangadd }\n            when $c eq '[' || $c eq '{' { take 27 + $bangadd } \n            when $c eq '\\\\' { take 28 + $bangadd } \n            when $c eq ']' || $c eq '}' { take 29 + $bangadd } \n            when $c eq '^' || $c eq '~' { take 30 + $bangadd }\n            when $c eq '_' || $c eq '`' { take 31 + $bangadd }\n            default { my $i = $c.uc.ord - 64 + $bangadd;\n                      take $i >= 0 ?? $i !! $c.ord      }\n         }\n         $gotbar = False;\n         $bangadd = 0;\n      } elsif $c eq '|' {\n         $gotbar = True\n      } else {\n         take $c.ord\n      }\n   }\n   return Blob.new(@result).decode('utf8c8')\n}\n\nmy @TESTS = <ALERT|G 'wert↑>;\nmy @RAND_TESTS = ^256 .roll(10).chrs.join xx 8;\nmy @DECODE_TESTS = < |LHello|G|J|M |m|j|@|e|!t|m|!|? abc|1de|5f >; \n\nfor |@TESTS, |@RAND_TESTS -> $t {\n   my $encoded = GSTrans-encode($t);\n   my $decoded = GSTrans-decode($encoded);\n   say \"String $t encoded is: $encoded, decoded is: $decoded.\";\n   die unless $t ~~ $decoded;\n}\nfor @DECODE_TESTS -> $enc {\n    say \"Encoded string $enc decoded is: \", GSTrans-decode($enc);\n}\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program where the program chooses a number between   **1**   and   **10**.\n\nA player is then prompted to enter a guess.   If the player guesses wrong,   then the prompt appears again until the guess is correct.\n\nWhen the player has made a successful guess the computer will issue a   \"Well guessed!\"   message,   and the program exits.\n\nA   conditional loop   may be used to repeat the guessing until the user is correct.\n\nRelated tasks\n\n* Bulls and cows\n* Bulls and cows/Player\n* Guess the number/With Feedback\n* Mastermind"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $number = (1..10).pick;\nrepeat {} until prompt(\"Guess a number: \") == $number;\nsay \"Guessed right!\";\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a game (computer program) that follows the following rules:\n\n:   :   * The computer chooses a number between given set limits.\n        * The player is asked for repeated guesses until the the target number is guessed correctly\n        * At each guess, the computer responds with whether the guess is:\n\n        :   :   :   * higher than the target,\n                    * equal to the target,\n                    * less than the target,   or\n                    * the input was inappropriate.\n\nRelated task\n\n* Guess the number/With Feedback (Player)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $maxnum = prompt(\"Hello, please give me an upper boundary: \");\nuntil 0 < $maxnum < Inf {\n    say \"Oops! The upper boundary should be > 0 and not Inf\";\n    $maxnum = prompt(\"Please give me a valid upper boundary: \");\n}\n\nmy $count = 0;\nmy $number = (1..$maxnum).pick;\n\nsay \"I'm thinking of a number from 1 to $maxnum, try to guess it!\";\nrepeat until my $guessed-right {\n    given prompt(\"Your guess: \") {\n        when /^[e|q]/ { say 'Goodbye.'; exit; }\n        when not 1 <= $_ <= $maxnum {\n           say \"You really should give me a number from 1 to $maxnum.\"\n        }\n        $count++;\n        when $number { $guessed-right = True }\n        when $number < $_ { say \"Sorry, my number is smaller.\" }\n        when $number > $_ { say \"Sorry, my number is bigger.\" }\n    }\n}\nsay \"Great you guessed right after $count attempts!\";\n\n```\n\n```\nHello, please give me an upper boundary: 10 \nI'm thinking of a number from 1 to 10, try to guess it!\nYour guess: 5\nSorry, my number is bigger.\nYour guess: 7\nSorry, my number is smaller.\nYour guess: 6\nGreat you guessed right after 3 attempts!\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a player for the game that follows the following rules:\n\n:   The scorer will choose a number between set limits. The computer player will print a guess of the target number. The computer asks for a score of whether its guess is higher than, lower than, or equal to the target. The computer guesses, and the scorer scores, in turn, until the computer correctly guesses the target number.\n\nThe computer should guess intelligently based on the accumulated scores given. One way is to use a Binary search based algorithm.\n\nRelated tasks\n\n* Guess the number/With Feedback\n* Bulls and cows/Player"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmulti sub MAIN() { MAIN(0, 100) }\nmulti sub MAIN($min is copy where ($min >= 0), $max is copy where ($max > $min)) {\n    say \"Think of a number between $min and $max and I'll guess it!\";\n    while $min <= $max {\n        my $guess = (($max + $min)/2).floor;\n        given lc prompt \"My guess is $guess. Is your number higher, lower or equal? \" {\n            when /^e/ { say \"I knew it!\"; exit }\n            when /^h/ { $min = $guess + 1      }\n            when /^l/ { $max = $guess          }\n            default   { say \"WHAT!?!?!\"        }\n        }\n    }\n    say \"How can your number be both higher and lower than $max?!?!?\";\n}\n\n```\n\nYou may execute this program with 'raku program' or with 'raku program min max'. Raku creates a usage for us if we don't give the right parameters. It also parses the parameters for us and provides them via $min and $max. We use multi-subs to provide two MAIN subroutines so the user is able to choose between min and max parameters and no parameters at all, in which case min is set to 0 and max to 100."}]}
{"messages": [{"role": "user", "content": "Almost every application needs to communicate with the user in some way.\nTherefore, a substantial part of the code deals with the interaction\nof program logic with GUI components.\n\nTypically, the following is needed:\n\n* put values into input fields under program control\n* read and check input from the user\n* pop up dialogs to query the user for further information\n\nTask\n\nFor a minimal \"application\", write a program that presents a form with three components to the user:\n\n:   :   * a numeric input field (\"Value\")\n        * a button (\"increment\")\n        * a button (\"random\")\n\nThe field is initialized to zero.\n\nThe user may manually enter a new value into the field,\nor increment its value with the \"increment\" button.\n\nEntering a non-numeric value should be either impossible,\nor issue an error message.\n\nPressing the \"random\" button presents a confirmation dialog,\nand resets the field's value to a random value if the answer is \"Yes\".\n\n(This task may be regarded as an extension of the task Simple windowed application)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Library:** GTK\n\n```\nuse GTK::Simple;\nuse GTK::Simple::App;\n\nmy GTK::Simple::App $app .= new(title => 'GUI component interaction');\n\n$app.set-content(\n    my $box = GTK::Simple::VBox.new(\n        my $value     = GTK::Simple::Entry.new(text => '0'),\n        my $increment = GTK::Simple::Button.new(label => 'Increment'),\n        my $random    = GTK::Simple::Button.new(label => 'Random'),\n    )\n);\n\n$app.size-request(400, 100);\n$app.border-width = 20;\n$box.spacing = 10;\n\n$value.changed.tap: {\n    ($value.text ||= '0') ~~ s:g/<-[0..9]>//;\n}\n\n$increment.clicked.tap: {\n    my $val = $value.text; $val += 1; $value.text = $val.Str\n}\n\n$random.clicked.tap: {\n    # Dirty hack to work around the fact that GTK::Simple doesn't provide\n    # access to GTK message dialogs yet :P\n    if run «zenity --question --text \"Reset to random value?\"» {\n        $value.text = (^100).pick.Str\n    }\n}\n\n$app.run;\n\n```"}]}
{"messages": [{"role": "user", "content": "In addition to fundamental GUI component interaction, an application should\ndynamically enable and disable GUI components, to give some guidance to the\nuser, and prohibit (inter)actions which are inappropriate in the current state\nof the application.\n\nTask\n\nSimilar to the task GUI component interaction, write a program\nthat presents a form with three components to the user:\n\n:   :   1. a numeric input field (\"Value\")\n        2. a button   (\"increment\")\n        3. a button   (\"decrement\")\n\nThe field is initialized to zero.\nThe user may manually enter a new value into the field,\nincrement its value with the \"increment\" button,\nor decrement the value with the \"decrement\" button.\n\nThe input field should be enabled only when its value is zero.\nThe \"increment\" button only as long as the field's value is less then 10:\nWhen the value 10 is reached, the button should go into a disabled state.\nAnalogously, the \"decrement\" button should be enabled only as long as\nthe value is greater than zero.\n\nEffectively, the user can now either increment up to 10, or down to zero.\nManually entering values outside that range is still legal,\nbut the buttons should reflect that and enable/disable accordingly."}, {"role": "assistant", "content": "(formerly Perl 6)\nExtremely basic implementation using the GTK library.\n\n```\nuse GTK::Simple;\nuse GTK::Simple::App;\n\nmy GTK::Simple::App $app .= new( title => 'Controls Enable / Disable' );\n\n$app.set-content(\n    my $box = GTK::Simple::HBox.new(\n        my $inc   = GTK::Simple::Button.new( label => ' + ' ),\n        my $value = GTK::Simple::Entry.new,\n        my $dec   = GTK::Simple::Button.new( label => ' - ' )\n    )\n);\n\n$app.border-width = 10;\n$box.spacing = 10;\n\n$value.changed.tap: {\n    $value.text.=subst(/\\D/, '');\n    $inc.sensitive = $value.text < 10;\n    $dec.sensitive = $value.text > 0;\n}\n\n$value.text = '0';\n\n$inc.clicked.tap: { my $val = $value.text; $val += 1; $value.text = $val.Str }\n$dec.clicked.tap: { my $val = $value.text; $val -= 1; $value.text = $val.Str }\n\n$app.run;\n\n```"}]}
{"messages": [{"role": "user", "content": "The task is to determine the maximum height and width of a window that can fit within the physical display area of the screen without scrolling.\n\nThis is effectively the screen size (not the total desktop area, which could be bigger than the screen display area) in pixels minus any adjustments for window decorations and menubars.\n\nThe idea is to determine the physical display parameters for the maximum height and width of the usable display area in pixels (without scrolling).\n\nThe values calculated should represent the usable desktop area of a window maximized to fit the the screen.\n\nConsiderations\n\n--- Multiple Monitors\n\nFor multiple monitors, the values calculated should represent the size of the usable display area on the monitor which is related to the task (i.e.:   the monitor which would display a window if such instructions were given).\n\n--- Tiling Window Managers\n\nFor a tiling window manager, the values calculated should represent the maximum height and width of the display area of the maximum size a window can be created (without scrolling). This would typically be a full screen window (minus any areas occupied by desktop bars), unless the window manager has restrictions that prevents the creation of a full screen window, in which case the values represent the usable area of the desktop that occupies the maximum permissible window size (without scrolling)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nThis is kind-of a silly task. The maximum window size is going to depend on your OS, hardware, display server and graphics toolkit, not your programming language. Taken at face value, using a Linux system running an X11 display server, the maximum displayable window size is the resolution of your monitor. Basically, the size of your desktop viewport. The Raku module X11::libxdo returns the desktop viewport size for get-desktop-dimensions which is the effective maximum window size.\n\n```\nuse X11::libxdo;\n\nmy $xdo = Xdo.new;\n\nmy ($dw, $dh) = $xdo.get-desktop-dimensions( 0 );\n\nsay \"Desktop viewport dimensions: (maximum-fullscreen size) $dw x $dh\";\n\n```\n\nOn my system returns:\n\n```\nDesktop viewport dimensions: (maximum-fullscreen size) 1920 x 1080\n```"}]}
{"messages": [{"role": "user", "content": "The Hailstone sequence of numbers can be generated from a starting positive integer,   n   by:\n\n* If   n   is     **1**     then the sequence ends.\n* If   n   is   **even** then the next   n   of the sequence    `= n/2`\n* If   n   is   **odd**   then the next   n   of the sequence    `= (3 * n) + 1`\n\nThe (unproven) Collatz conjecture is that the hailstone sequence for any starting number always terminates.\n\nThis sequence was named by Lothar Collatz in 1937   (or possibly in 1939),   and is also known as (the):\n\n:   :   :   * hailstone sequence,   hailstone numbers\n            * 3x + 2 mapping,   3n + 1 problem\n            * Collatz sequence\n            * Hasse's algorithm\n            * Kakutani's problem\n            * Syracuse algorithm,   Syracuse problem\n            * Thwaites conjecture\n            * Ulam's problem\n\nThe hailstone sequence is also known as   *hailstone numbers*   (because the values are usually subject to multiple descents and ascents like hailstones in a cloud).\n\nTask\n\n1. Create a routine to generate the hailstone sequence for a number.\n2. Use the routine to show that the hailstone sequence for the number 27 has 112 elements starting with `27, 82, 41, 124` and ending with `8, 4, 2, 1`\n3. Show the number less than 100,000 which has the longest hailstone sequence together with that sequence's length.  \n      (But don't show the actual sequence!)\n\nSee also\n\n* xkcd (humourous).\n* The Notorious Collatz conjecture Terence Tao, UCLA (Presentation, pdf).\n* The Simplest Math Problem No One Can Solve Veritasium (video, sponsored)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub hailstone($n) { $n, { $_ %% 2 ?? $_ div 2 !! $_ * 3 + 1 } ... 1 }\n\nmy @h = hailstone(27);\nsay \"Length of hailstone(27) = {+@h}\";\nsay ~@h;\n\nmy $m = max ( (1..99_999).race.map: { +hailstone($_) => $_ } );\nsay \"Max length {$m.key} was found for hailstone({$m.value}) for numbers < 100_000\";\n```\n\nOutput:\n\n```\nLength of hailstone(27) = 112\n27 82 41 124 62 31 94 47 142 71 214 107 322 161 484 242 121 364 182 91 274 137 412 206 103 310 155 466 233 700 350 175 526 263 790 395 1186 593 1780 890 445 1336 668 334 167 502 251 754 377 1132 566 283 850 425 1276 638 319 958 479 1438 719 2158 1079 3238 1619 4858 2429 7288 3644 1822 911 2734 1367 4102 2051 6154 3077 9232 4616 2308 1154 577 1732 866 433 1300 650 325 976 488 244 122 61 184 92 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1\nMax length 351 was found for hailstone(77031) for numbers < 100_000\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a program that crashes as soon as possible, with as few lines of code as possible. Be smart and don't damage your computer, ok?\n\nThe code should be syntactically valid. It should be possible to insert [a subset of] your submission into another program, presumably to help debug it, or perhaps for use when an internal corruption has been detected and it would be dangerous and irresponsible to continue.\n\nReferences\n\n* Wikipedia: Halt and Catch Fire\n\nRelated Tasks\n\n* Program termination"}, {"role": "assistant", "content": "```\n++8\n\n```\n\nSyntactically: Valid.\n\nSemantically: Change the mathematical concept of 8 to 9, either in your whole computer, or maybe the whole universe.\n\nFails with this run-time error:\n\nOutput:\n\n```\nCannot resolve caller prefix:<++>(Int:D); the following candidates\nmatch the type but require mutable arguments:\n    (Mu:D $a is rw)\n    (Int:D $a is rw --> Int:D)\n\nThe following do not match for other reasons:\n    (Bool $a is rw)\n    (Mu:U $a is rw)\n    (Num:D $a is rw)\n    (Num:U $a is rw)\n    (int $a is rw --> int)\n    (num $a is rw --> num)\n  in block <unit> at -e line 1\n```\n\nAlternately, and perhaps more community condoned, to end the program as soon as possible without trying to change the Laws of the Universe, you could just enter:\n\n```\ndie\n\n```\n\nIn REPL:\n\n```\nDied\n  in block <unit> at <unknown file> line 1\n```\n\nSame character count, exits the program as soon as possible (though trappable if desired through the exception system,) and it looks more like an intentional act rather than a typo. Plus, you can add a message that will be added *when* it dies to explain why.\n\nHere is a silly alternative : A standalone Unicode counterpart for the yada yada yada operator takes up 3 code units but visually just a single codepoint,\n\nOutput:\n\n```\ncat test.raku ; wc test.raku\n…\n1 1 4 test.raku\n\nraku -c test.raku ; echo $?\nSyntax OK\n0\n\nraku test.raku ; echo $?\nStub code executed\n  in block <unit> at test.raku line 1\n\n1\n```\n\nHowever when I tried to combine all to test against the Test module, the last one somehow lived through an EVAL,\n\n```\nuse Test;\n\ndies-ok { ++8 };\ndies-ok { die };\ndies-ok {  …  };\n\neval-dies-ok '++8';\neval-dies-ok 'die';\neval-dies-ok  '…' ;\n\n```\n\nOutput:\n\n```\nok 1 -\nok 2 -\nok 3 -\nok 4 -\nok 5 -\nnot ok 6 -\n# Failed test at all.raku line 11\n```\n\nso it is indeed at one's discretion whether this one is qualified as a crasher."}]}
{"messages": [{"role": "user", "content": "**Hamming numbers** are numbers of the form\n\n```\n    H = 2i × 3j × 5k\n           where \n     i,  j,  k  ≥  0 \n\n```\n\n*Hamming numbers*   are also known as   *ugly numbers*   and also   *5-smooth numbers*   (numbers whose prime divisors are less or equal to 5).\n\nTask\n\nGenerate the sequence of Hamming numbers, *in increasing order*.   In particular:\n\n1. Show the   first twenty   Hamming numbers.\n2. Show the   1691st   Hamming number (the last one below   231).\n3. Show the   one millionth   Hamming number (if the language – or a convenient library – supports arbitrary-precision integers).\n\nRelated tasks\n\n* Humble numbers\n* N-smooth numbers\n\nReferences\n\n* Wikipedia entry:   Hamming numbers     (this link is re-directed to   **Regular number**).\n* Wikipedia entry:   Smooth number\n* OEIS entry:   A051037   5-smooth   or   Hamming numbers\n* Hamming problem from Dr. Dobb's CodeTalk (dead link as of Sep 2011; parts of the thread here and here)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Merge version\n\n**Works with**: rakudo version 2015-11-04\n\nThe limit scaling is not *required*, but it cuts down on a bunch of unnecessary calculation.\n\n```\nmy $limit = 32;\n\nsub powers_of ($radix) { 1, |[\\*] $radix xx * }\n\nmy @hammings = \n  (   powers_of(2)[^ $limit ]       X*\n      powers_of(3)[^($limit * 2/3)] X* \n      powers_of(5)[^($limit * 1/2)]\n   ).sort;\n\nsay @hammings[^20];\nsay @hammings[1690]; # zero indexed\n```\n\nOutput:\n\n```\n(1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 25 27 30 32 36)\n2125764000\n```\n\n### Iterative version\n\n**Works with**: rakudo version 6.c\n\nThis version uses a lazy list, storing a maximum of two extra value from the highest index requested\n\n```\nmy \\Hammings := gather {\n  my %i = 2, 3, 5 Z=> (Hammings.iterator for ^3);\n  my %n = 2, 3, 5 Z=> 1 xx 3;\n\n  loop {\n    take my $n := %n{2, 3, 5}.min;\n\n    for 2, 3, 5 -> \\k {\n      %n{k} = %i{k}.pull-one * k if %n{k} == $n;\n    }\n  }\n}\n  \nsay Hammings.[^20];\nsay Hammings.[1691 - 1];\nsay Hammings.[1000000 - 1];\n```\n\nOutput:\n\n```\n(1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 25 27 30 32 36)\n2125764000\n519312780448388736089589843750000000000000000000000000000000000000000000000000000000\n```"}]}
{"messages": [{"role": "user", "content": "Most operating systems provide interrupt facilities, sometimes called signals either generated by the user or as a result of program failure or reaching a limit like file space.\nUnhandled signals generally terminate a program in a disorderly manner.\nSignal handlers are created so that the program behaves in a well-defined manner upon receipt of a signal.\n\nTask\n\nProvide a program that displays an integer on each line of output at the rate of about one per half second.\nUpon receipt of the SIGINT signal (often generated by the user typing ctrl-C ( or better yet, SIGQUIT ctrl-\\ )) the program will cease outputting integers, output the number of seconds the program has run, and then the program will quit."}, {"role": "assistant", "content": "(formerly Perl 6)\nWe note with glee that the task does not require us to print *consecutive* integers, so we'll print Fibonacci numbers instead. :-)\n\n```\nsignal(SIGINT).tap: {\n    note \"Took { now - INIT now } seconds.\";\n    exit;\n}\n\nfor 0, 1, *+* ... * {\n    sleep 0.5;\n    .say;\n}\n\n```\n\nOutput:\n\n```\n0\n1\n1\n2\n3\n5\n8\n13\n21\n34\n55\n89\n^CTook 6.3437449 seconds.\nAborted\n```"}]}
{"messages": [{"role": "user", "content": "From Wikipedia, the free encyclopedia:\n\n:   :   A happy number is defined by the following process:\n\n:   :   Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals   **1**   (where it will stay),   or it loops endlessly in a cycle which does not include   **1**.\n\n:   :   Those numbers for which this process end in   **1**   are       *happy*   numbers,\n    :   while   those numbers   that   do   not   end in   **1**   are   *unhappy*   numbers.\n\nTask\n\nFind and print the first   **8**   happy numbers.\n\nDisplay an example of your output here on this page.\n\nRelated tasks\n\n* Iterated digits squaring\n\nSee also\n\n* The OEIS entry:   The     happy numbers:   A007770\n* The OEIS entry:   The unhappy numbers;   A031177"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-13\n\n```\nsub happy (Int $n is copy --> Bool) {\n  loop {\n      state %seen;\n      $n = [+] $n.comb.map: { $_ ** 2 }\n      return True  if $n == 1;\n      return False if %seen{$n}++;\n  }\n}\n\nsay join ' ', grep(&happy, 1 .. *)[^8];\n```\n\nOutput:\n\n```\n1 7 10 13 19 23 28 31\n```\n\nHere's another approach that uses a different set of tricks including lazy lists, gather/take, repeat-until, and the cross metaoperator X.\n\n```\nmy @happy = lazy gather for 1..* -> $number {\n    my %stopper = 1 => 1;\n    my $n = $number;\n    repeat until %stopper{$n}++ {\n        $n = [+] $n.comb X** 2;\n    }\n    take $number if $n == 1;\n}\n\nsay ~@happy[^8];\n```\n\nOutput is the same as above.\n\nHere is a version using a subset and an anonymous recursion (we cheat a little bit by using the knowledge that 7 is the second happy number):\n\n```\nsubset Happy of Int where sub ($n) {\n    $n == 1 ?? True  !!\n    $n < 7  ?? False !!\n    &?ROUTINE([+] $n.comb »**» 2);\n}\n \nsay (grep Happy, 1 .. *)[^8];\n```\n\nAgain, output is the same as above. It is not clear whether this version returns in finite time for any integer, though.\n\nThere's more than one way to do it..."}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Harmonic number. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn mathematics, the **n-th** harmonic number is the sum of the reciprocals of the first **n** natural numbers:\n\n```\n   Hn = 1 + 1/2 + 1/3 + ... + 1/n\n\n```\n\nThe series of harmonic numbers thus obtained is often loosely referred to as the harmonic series.\n\nHarmonic numbers are closely related to the Riemann zeta function, and roughly approximate the natural logarithm function; differing by γ (lowercase Gamma), the Euler–Mascheroni constant.\n\nThe harmonic series is divergent, albeit quite slowly, and grows toward infinity.\n\nTask\n\n* Write a function (routine, procedure, whatever it may be called in your language) to generate harmonic numbers.\n* Use that procedure to show the values of the first 20 harmonic numbers.\n* Find and show the position in the series of the first value greater than the integers 1 through 5\n\nStretch\n\n* Find and show the position in the series of the first value greater than the integers 6 through 10\n\nRelated\n\n* Egyptian fractions"}, {"role": "assistant", "content": "Using Lingua::EN::Numbers from the Raku ecosystem.\n\n```\nuse Lingua::EN::Numbers;\n\nmy @H = [\\+] (1..*).map: { FatRat.new: 1, $_ };\n\nsay \"First twenty harmonic numbers as rationals:\\n\",\n    @H[^20]».&pretty-rat.batch(5)».fmt(\"%18s\").join: \"\\n\";\n\nput \"\\nOne Hundredth:\\n\", pretty-rat @H[99];\n\nsay \"\\n(zero based) Index of first value:\";\nprintf \"  greater than %2d: %6s (%s term)\\n\",\n  $_, comma( my $i = @H.first(* > $_, :k) ), ordinal 1 + $i for 1..10;\n\n```\n\nOutput:\n\n```\nFirst twenty harmonic numbers as rationals:\n                 1                3/2               11/6              25/12             137/60\n             49/20            363/140            761/280          7129/2520          7381/2520\n       83711/27720        86021/27720     1145993/360360     1171733/360360     1195757/360360\n    2436559/720720  42142223/12252240   14274301/4084080 275295799/77597520  55835135/15519504\n\nOne Hundredth:\n14466636279520351160221518043104131447711/2788815009188499086581352357412492142272\n\n(zero based) Index of first value:\n  greater than  1:      1 (second term)\n  greater than  2:      3 (fourth term)\n  greater than  3:     10 (eleventh term)\n  greater than  4:     30 (thirty-first term)\n  greater than  5:     82 (eighty-third term)\n  greater than  6:    226 (two hundred twenty-seventh term)\n  greater than  7:    615 (six hundred sixteenth term)\n  greater than  8:  1,673 (one thousand, six hundred seventy-fourth term)\n  greater than  9:  4,549 (four thousand, five hundred fiftieth term)\n  greater than 10: 12,366 (twelve thousand, three hundred sixty-seventh term)\n```"}]}
{"messages": [{"role": "user", "content": "The discovery of the Harriss Spiral was first publicized about 2015. It is the brainchild of Edmund Orme Harriss, a British mathematician, writer and artist. Since 2010 he has been at the Fulbright College of Arts & Sciences at The University of Arkansas in Fayetteville, Arkansas, where he is an Assistant Professor of Arts & Sciences (ARSC) and Mathematical Sciences (MASC). He does research in the Geometry of Tilings and Patterns,a branch of Convex and Discrete Geometry.\n\nIn Harriss' own words, his namesake spiral, \"…is constructed by taking a rectangle with height 1 and length the real root of x^3-x-1=0. With this rectangle you can cut off a similar rectangle, and then a square to get another similar rectangle. You can repeat this construction on the smaller similar rectangles, in each case getting a square and two more similar rectangles. Now simply adding an arc of a circle to each square (in the right way) gives the spiral, or more correctly the nest of spirals.\"\n\nFractal spiral discovered by Edmund Harriss\n\nThe Harriss Spiral is a variant of the decomposition for the golden spiral in which a rectangle is decomposed into three smaller units: a rectangle similar to the original rotated 90◦, a square, and a similar rectangle in the same orientation as the original rectangle. As in the golden-spiral decomposition, the individual non-square units can be decomposed further along these lines to create a cascading filling of the rectangle with ever-smaller squares. Unlike in the golden spiral, each square is incident on two smaller regions appearing in the same generation; if arcs are drawn between each square and the square which appeared in its previous generation The result is a branching structure, shown at right.\n\nAs with the golden spiral decomposition, the Harriss spiral requires a specific aspect ratio for the original rectangle. While the golden spiral requires an aspect ratio which is a solution to 𝜙2 = 𝜙 + 1 — the Golden Ratio of 1:1.618 — the Harriss spiral requires an aspect ratio 𝜌 satisfying 𝜌3 = 𝜌 + 1, whose real solution is known as the plastic ratio and equals 1:1.3247.\n\nTask\n\nCreate and display a Harriss Spiral in your language."}, {"role": "assistant", "content": "**Translation of**: Julia\n\n```\n# 20250129 Raku programming solution\n\nuse Cairo;\n\nconstant HR = 1.324718;  # The Harriss Ratio, aka Ian Stewart's \"plastic number\"\n\nsub harriss($ctx, $x, $y, $angle, $len, $iteration, $linew, $radius is copy = 0.0, $cntrx is copy = 0.0, $cntry is copy = 0.0) {\n   return if $iteration < 1;\n\n   my $startangle = $angle + 45;\n   my $endangle = $startangle + 90;\n\n   # Calculate end point of lines\n   my $xend = $x + $len * cos($angle * pi / 180);\n   my $yend = $y + $len * sin($angle * pi / 180);\n\n   $radius = $len / sqrt(2);\n   my $heading = $yend < $y ?? \"SN\" !! $xend < $x ?? \"EW\" !! $yend > $y ?? \"NS\" !! $xend > $x ?? \"WE\" !! \"DIE\";\n\n   given $heading {\n      when \"SN\" { $cntrx = $x - $len / 2;\n                  $cntry = $y - $len / 2;\n                  $ctx.rgb(1, 1, 0);      }\n      when \"EW\" { $cntrx = $x - $len / 2;\n                  $cntry = $y + $len / 2;\n                  $ctx.rgb(1, 0, 0);      }\n      when \"NS\" { $cntrx = $x + $len / 2;\n                  $cntry = $y + $len / 2;\n                  $ctx.rgb(0, 0, 1);      }\n      when \"WE\" { $cntrx = $x + $len / 2;\n                  $cntry = $y - $len / 2;\n                  $ctx.rgb(0, 0, 0);      }\n      default   { die }\n   }\n\n   $ctx.line_width = $linew;\n   $ctx.arc($cntrx, $cntry, $radius, $startangle * pi / 180, $endangle * pi / 180);\n   $ctx.stroke;\n\n   harriss($ctx, $xend, $yend, $angle - 90, $len / HR, $iteration - 1, $linew, $radius, $cntrx, $cntry);\n}\n\ngiven Cairo::Image.create(Cairo::FORMAT_ARGB32, 1400, 1000) {  \n   given Cairo::Context.new($_) {\n      .rgb(0.827, 0.827, 0.827);  # light gray background\n      .paint;\n      .rgb(0, 0, 0);  \n      .line_width = 1.0;\n\n      my ($startx, $starty, $init_len) = 750, 740, 525 / HR / HR;\n\n      # Reverse Order Hides Joints\n      harriss($_, $startx - ($init_len / HR + $init_len / HR**3), $starty - $init_len / HR**7, 180, $init_len / HR**6, 2, 6.0);\n      harriss($_, $startx - ($init_len / HR + $init_len / HR**3), $starty - ($init_len + $init_len / HR**2), 270, $init_len / HR**5, 3, 6.0);\n      harriss($_, $startx + $init_len / HR**4, $starty - ($init_len + $init_len / HR**2), 270, $init_len / HR**5, 3, 6.0);\n      harriss($_, $startx + $init_len / HR, $starty - ($init_len + $init_len / HR**2), 0, $init_len / HR**4, 4, 6.0);\n      harriss($_, $startx - $init_len / HR**4, $starty - $init_len / HR, 0, $init_len / HR**5, 2, 10.0);\n      harriss($_, $startx - $init_len / HR**4, $starty - $init_len / HR**3, -270, $init_len / HR**4, 3, 12.0);\n      harriss($_, $startx - $init_len / HR, $starty - $init_len / HR**3, 180, $init_len / HR**3, 4, 12.0);\n      harriss($_, $startx - $init_len / HR, $starty - $init_len, 270, $init_len / HR**2, 5, 14.0);\n      harriss($_, $startx, $starty - $init_len, 0, $init_len / HR, 6, 14.0);\n      harriss($_, $startx, $starty, -90, $init_len, 7, 18.0);\n   }\n   .write_png(\"harriss-spirals-raku.png\");\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "The Harshad or Niven numbers are positive integers ≥ 1 that are divisible by the sum of their digits.\n\nFor example,   **42**   is a Harshad number as   **42**   is divisible by   (**4** + **2**)   without remainder.\n\nAssume that the series is defined as the numbers in increasing order.\n\nTask\n\nThe task is to create a function/method/procedure to generate successive members of the Harshad sequence.\n\nUse it to:\n\n:   :   * list the first **20** members of the sequence,   and\n        * list the first Harshad number greater than **1000**.\n\nShow your output here.\n\nRelated task\n:   * Increasing gaps between consecutive Niven numbers\n\nSee also\n\n* OEIS: A005349"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.08\n\n```\nconstant @harshad = grep { $_ %% .comb.sum }, 1 .. *;\n \nsay @harshad[^20];\nsay @harshad.first: * > 1000;\n\n```\n\nOutput:\n\n```\n(1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42)\n1002\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nUsing two Arrays of equal length, create a Hash object\nwhere the elements from one array (the keys) are linked\nto the elements of the other (the values)\n\nRelated task\n\n* Associative arrays/Creation"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUsing the \"zipwith\" meta-operator on the => pair composer:\n\n**Works with**: rakudo version 2018.03\n\n```\nmy @keys = <a b c d e>;\nmy @values = ^5;\n\nmy %hash = @keys Z=> @values;\n\n\n#Alternatively, by assigning to a hash slice:\n%hash{@keys} = @values;\n\n\n# Or to create an anonymous hash:\n%( @keys Z=> @values );\n\n\n# All of these zip forms trim the result to the length of the shorter of their two input lists.\n# If you wish to enforce equal lengths, you can use a strict hyperoperator instead:\n\nquietly # suppress warnings about unused hash\n{ @keys »=>« @values };  # Will fail if the lists differ in length\n\n```"}]}
{"messages": [{"role": "user", "content": "An inner join is an operation that combines two data tables into one table, based on matching column values. The simplest way of implementing this operation is the nested loop join algorithm, but a more scalable alternative is the hash join algorithm.\n\nTask\n\nImplement the \"hash join\" algorithm, and demonstrate that it passes the test-case listed below.\n\nYou should represent the tables as data structures that feel natural in your programming language.\n\nGuidance\n\nThe \"hash join\" algorithm consists of two steps:\n\n1. **Hash phase:** Create a multimap from one of the two tables, mapping from each join column value to all the rows that contain it.  \n   * The multimap must support hash-based lookup which scales better than a simple linear search, because that's the whole point of this algorithm.\n   * Ideally we should create the multimap for the *smaller* table, thus minimizing its creation time and memory size.\n2. **Join phase:** Scan the other table, and find matching rows by looking in the multimap created before.\n\nIn pseudo-code, the algorithm could be expressed as follows:\n\n```\nlet A = the first input table (or ideally, the larger one)\nlet B = the second input table (or ideally, the smaller one)\nlet jA = the join column ID of table A\nlet jB = the join column ID of table B\nlet MB = a multimap for mapping from single values to multiple rows of table B (starts out empty)\nlet C = the output table (starts out empty)\n\nfor each row b in table B:\n   place b in multimap MB under key b(jB)\n\nfor each row a in table A:\n   for each row b in multimap MB under key a(jA):\n      let c = the concatenation of row a and row b\n      place row c in table C\n\n```\n\nTest case\n\n| Input | Output |\n| --- | --- |\n| |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | *A* = | | Age | Name | | --- | --- | | 27 | Jonah | | 18 | Alan | | 28 | Glory | | 18 | Popeye | | 28 | Alan | |  | *B* = | | Character | Nemesis | | --- | --- | | Jonah | Whales | | Jonah | Spiders | | Alan | Ghosts | | Alan | Zombies | | Glory | Buffy | | | *jA* = | `Name` (i.e. column 1) | *jB* = | `Character` (i.e. column 0) | | | A.Age | A.Name | B.Character | B.Nemesis | | --- | --- | --- | --- | | 27 | Jonah | Jonah | Whales | | 27 | Jonah | Jonah | Spiders | | 18 | Alan | Alan | Ghosts | | 18 | Alan | Alan | Zombies | | 28 | Glory | Glory | Buffy | | 28 | Alan | Alan | Ghosts | | 28 | Alan | Alan | Zombies | |\n\nThe order of the rows in the output table is not significant.  \nIf you're using numerically indexed arrays to represent table rows (rather than referring to columns by name), you could represent the output rows in the form `[[27, \"Jonah\"], [\"Jonah\", \"Whales\"]]`.\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe .classify method returns a multimap represented as a Hash whose values are Arrays.\n\n```\nsub hash-join(@a, &a, @b, &b) {\n    my %hash := @b.classify(&b);\n    \n    @a.map: -> $a {\n        |(%hash{$a.&a} // next).map: -> $b { [$a, $b] }\n    }\n}\n\nmy @A =\n    [27, \"Jonah\"],\n    [18, \"Alan\"],\n    [28, \"Glory\"],\n    [18, \"Popeye\"],\n    [28, \"Alan\"],\n;\n\nmy @B =\n    [\"Jonah\", \"Whales\"],\n    [\"Jonah\", \"Spiders\"],\n    [\"Alan\", \"Ghosts\"],\n    [\"Alan\", \"Zombies\"],\n    [\"Glory\", \"Buffy\"],\n;\n\n.say for hash-join @A, *[1], @B, *[0];\n\n```\n\nOutput:\n\n```\n[[27 Jonah] [Jonah Whales]]\n[[27 Jonah] [Jonah Spiders]]\n[[18 Alan] [Alan Ghosts]]\n[[18 Alan] [Alan Zombies]]\n[[28 Glory] [Glory Buffy]]\n[[28 Alan] [Alan Ghosts]]\n[[28 Alan] [Alan Zombies]]\n```"}]}
{"messages": [{"role": "user", "content": "# Hashtron classifier inference\n\n## Description\n\nThis task involves implementing a Hashtron classifier inference function. Hashtron\nclassifier program can be machine learned to calculate arbitrary finite computable\nfunctions or sets (Given enough CPU time and RAM).\nThe Hashtron classifier takes a command and a number of bits to infer, using a\nprovided program configuration. The inference function for the test will generate a\npseudo-random n-bits output. The inference function for the square root demo will\ngenerate a square root of a command in range: 0 <= command < 256.\n\n## Examples\n\n### Test demo\n\nGiven the following program configuration and input command:\n\nProgram configuration:\n\nInput command:\n\n```\n42\n```\n\nNumber of bits:\n\n```\n64\n```\n\nProgram:\n\n```\n[[0,2]]\n```\n\nThe inference function should process the input and generate the following 64-bit output:\n\n```\n14106184687260844995\n```\n\n### Square root demo\n\nGiven the following program configuration and input command:\n\nProgram configuration:\n\nInput command: A byte (integer) to take square root of.\n\nNumber of bits:\n\n```\n4\n```\n\nProgram:\n\n```\n[[8776,79884], [12638,1259], [9953,1242], [4658,1228], [5197,1210], [12043,1201],\n[6892,1183], [7096,1168], [10924,1149], [5551,1136], [5580,1123], [3735,1107],\n[3652,1091], [12191,1076], [14214,1062], [13056,1045], [14816,1031], [15205,1017],\n[10736,1001], [9804,989], [13081,974], [6706,960], [13698,944], [14369,928],\n[16806,917], [9599,906], [9395,897], [4885,883], [10237,870], [10676,858],\n[18518,845], [2619,833], [13715,822], [11065,810], [9590,799], [5747,785],\n[2627,776], [8962,764], [5575,750], [3448,738], [5731,725], [9434,714],\n[3163,703], [3307,690], [3248,678], [3259,667], [3425,657], [3506,648],\n[3270,639], [3634,627], [3077,617], [3511,606], [27159,597], [27770,589],\n[28496,580], [28481,571], [29358,562], [31027,552], [30240,543], [30643,534],\n[31351,527], [31993,519], [32853,510], [33078,502], [33688,495], [29732,487],\n[29898,480], [29878,474], [26046,468], [26549,461], [28792,453], [26101,446],\n[32971,439], [29704,432], [23193,426], [29509,421], [27079,415], [32453,409],\n[24737,404], [25725,400], [23755,395], [52538,393], [53242,386], [19609,380],\n[26492,377], [24566,358], [31163,368], [57174,363], [26639,364], [31365,357],\n[60918,350], [21235,338], [28072,322], [28811,314], [27571,320], [17635,309],\n[51968,169], [54367,323], [60541,254], [26732,270], [52457,157], [27181,276],\n[19874,227], [22797,320], [59346,271], [25496,260], [54265,231], [22281,250],\n[42977,318], [26008,240], [87604,142], [94647,314], [52292,157], [20999,216],\n[89253,316], [22746,29], [68338,312], [22557,317], [110904,104], [70975,285],\n[51835,277], [51871,313], [132221,228], [18522,290], [68512,285], [118816,302],\n[150865,268], [68871,273], [68139,290], [84984,285], [150693,266], [396047,272],\n[84923,269], [215562,258], [68015,248], [247689,235], [214471,229], [264395,221],\n[263287,212], [280193,201], [108065,194], [263616,187], [148609,176], [263143,173],\n[378205,162], [312547,154], [50400,147], [328927,140], [279217,132], [181111,127],\n[672098,118], [657196,113], [459383,111], [833281,105], [520281,102], [755397,95],\n[787994,91], [492444,82], [1016592,77], [656147,71], [819893,66], [165531,61],\n[886503,57], [1016551,54], [3547827,49], [14398170,43], [395900,41], [4950628,37],\n[11481175,33], [100014881,30], [8955328,31], [11313984,27], [13640855,23],\n[528553762,21], [63483027,17], [952477,8], [950580,4], [918378,2], [918471,1]]\n```\n\nThe inference function should process the input and generate the square root of the input byte."}, {"role": "assistant", "content": "Translation of #Phix and Go\n\n```\n# 20240530 Raku programming solution\n\nsub Inference($command, $bits, @program) {\n   my  $out = 0;\n\n   return $out unless @program.Bool;\n\n   for ^$bits -> $j { # Iterate over the bits\n      my $input = $command +| ($j +< 16);\n      $input = Hashtron($input, @program[0][0], my $maxx = @program[0][1]);\n      for @program[1..*] -> ($s, $max) {\n         $input = Hashtron($input, $s, $maxx -= $max);\n      }\n      if ( $input +&= 1 ) != 0 { $out +|= 1 +< $j }\n   }\n   return $out;\n}\n\nsub Hashtron($n, $s, $max) {\n   # Mixing stage, mix input with salt using subtraction\n   my $m = $n - $s;\n\n   # Hashing stage, use xor shift with prime coefficients\n   for <-2 -3 +5 +7 -11 -13 +17 -19> -> $p {\n      $m = ($m +^ ($m +> $p)) +& 0xFFFFFFFF; \n   }\n\n   # Mixing stage 2, mix input with salt using addition\n   $m = ($m + $s) +& 0xFFFFFFFF;\n\n   # Modular stage using Lemire's fast alternative to modulo reduction\n   return (($m * $max) +> 32) +& 0xFFFFFFFF;\n}\n\nsub MAIN() {\n   say  \"Test demo:\\n{ Inference(42, 64, (<0 2>,)) } \\n\";\n   say \"Square root demo for commands in [0, 255]:\";\n\n   for ^256 .rotor(16) -> @i {\n      say [~] @i.map: { sprintf( \"%2d \", Inference($_, 4, (\n         <8776 79884>, <12638 1259>, <9953 1242>, <4658 1228>, <5197 1210>,\n         <12043 1201>, <6892 1183>, <7096 1168>, <10924 1149>, <5551 1136>, \n         <5580 1123>, <3735 1107>, <3652 1091>, <12191 1076>, <14214 1062>, \n         <13056 1045>, <14816 1031>, <15205 1017>, <10736 1001>, <9804 989>, \n         <13081 974>, <6706 960>, <13698 944>, <14369 928>, <16806 917>, \n         <9599 906>, <9395 897>, <4885 883>, <10237 870>, <10676 858>,\n         <18518 845>, <2619 833>, <13715 822>, <11065 810>, <9590 799>, \n         <5747 785>, <2627 776>, <8962 764>, <5575 750>, <3448 738>, \n         <5731 725>, <9434 714>, <3163 703>, <3307 690>, <3248 678>, \n         <3259 667>, <3425 657>, <3506 648>, <3270 639>, <3634 627>, \n         <3077 617>, <3511 606>, <27159 597>, <27770 589>, <28496 580>, \n         <28481 571>, <29358 562>, <31027 552>, <30240 543>, <30643 534>,\n         <31351 527>, <31993 519>, <32853 510>, <33078 502>, <33688 495>, \n         <29732 487>, <29898 480>, <29878 474>, <26046 468>, <26549 461>, \n         <28792 453>, <26101 446>, <32971 439>, <29704 432>, <23193 426>, \n         <29509 421>, <27079 415>, <32453 409>, <24737 404>, <25725 400>, \n         <23755 395>, <52538 393>, <53242 386>, <19609 380>, <26492 377>, \n         <24566 358>, <31163 368>, <57174 363>, <26639 364>, <31365 357>,\n         <60918 350>, <21235 338>, <28072 322>, <28811 314>, <27571 320>, \n         <17635 309>, <51968 169>, <54367 323>, <60541 254>, <26732 270>, \n         <52457 157>, <27181 276>, <19874 227>, <22797 320>, <59346 271>, \n         <25496 260>, <54265 231>, <22281 250>, <42977 318>, <26008 240>, \n         <87604 142>, <94647 314>, <52292 157>, <20999 216>, <89253 316>, \n         <22746 29>, <68338 312>, <22557 317>, <110904 104>, <70975 285>,\n         <51835 277>, <51871 313>, <132221 228>, <18522 290>, <68512 285>, \n         <118816 302>, <150865 268>, <68871 273>, <68139 290>, <84984 285>, \n         <150693 266>, <396047 272>, <84923 269>, <215562 258>, <68015 248>, \n         <247689 235>, <214471 229>, <264395 221>, <263287 212>, <280193 201>, \n         <108065 194>, <263616 187>, <148609 176>, <263143 173>, <378205 162>, \n         <312547 154>, <50400 147>, <328927 140>, <279217 132>, <181111 127>,\n         <672098 118>, <657196 113>, <459383 111>, <833281 105>, <520281 102>, \n         <755397 95>, <787994 91>, <492444 82>, <1016592 77>, <656147 71>, \n         <819893 66>, <165531 61>, <886503 57>, <1016551 54>, <3547827 49>, \n         <14398170 43>, <395900 41>, <4950628 37>, <11481175 33>, \n         <100014881 30>, <8955328 31>, <11313984 27>, <13640855 23>,\n         <528553762 21>, <63483027 17>, <952477 8>, <950580 4>, <918378 2>, \n         <918471 1> )\n      ))} \n   } \n}\n\n```\n\nYou may Attempt This Online!\n\nOutput:\n\n```\nTest demo:\n14106184687260844995 \n\nSquare root demo for commands in [0, 255]:\n 0  1  1  1  2  2  2  2  2  3  3  3  3  3  3  3 \n 4  4  4  4  4  4  4  4  4  5  5  5  5  5  5  5 \n 5  5  5  5  6  6  6  6  6  6  6  6  6  6  6  6 \n 6  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7 \n 8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8 \n 8  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9 \n 9  9  9  9 10 10 10 10 10 10 10 10 10 10 10 10 \n10 10 10 10 10 10 10 10 10 11 11 11 11 11 11 11 \n11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 \n12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 \n12 12 12 12 12 12 12 12 12 13 13 13 13 13 13 13 \n13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 \n13 13 13 13 14 14 14 14 14 14 14 14 14 14 14 14 \n14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 \n14 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 \n15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 \n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Haversine formula. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThe **haversine formula** is an equation important in navigation, giving great-circle distances between two points on a sphere from their longitudes and latitudes.\n\nIt is a special case of a more general formula in spherical trigonometry, the **law of haversines**, relating the sides and angles of spherical \"triangles\".\n\nTask\n\nImplement a great-circle distance function, or use a library function,\nto show the great-circle distance between:\n\n* Nashville International Airport (BNA)   in Nashville, TN, USA,   which is:\n\n```\n   N 36°7.2',   W 86°40.2'     (36.12,   -86.67)           -and-\n\n```\n\n* Los Angeles International Airport (LAX)  in Los Angeles, CA, USA,   which is:\n\n```\n   N 33°56.4',  W 118°24.0'    (33.94,  -118.40)   \n\n```\n\n```\nUser Kaimbridge clarified on the Talk page:\n\n -- 6371.0 km is the authalic radius based on/extracted from surface area;\n -- 6372.8 km is an approximation of the radius of the average circumference\n    (i.e., the average great-elliptic or great-circle radius), where the\n     boundaries are the meridian (6367.45 km) and the equator (6378.14 km).\n\nUsing either of these values results, of course, in differing distances:\n\n 6371.0 km -> 2886.44444283798329974715782394574671655 km;\n 6372.8 km -> 2887.25995060711033944886005029688505340 km;\n (results extended for accuracy check:  Given that the radii are only\n  approximations anyways, .01' ≈ 1.0621333 km and .001\" ≈ .00177 km,\n  practical precision required is certainly no greater than about\n  .0000001——i.e., .1 mm!)\n\nAs distances are segments of great circles/circumferences, it is\nrecommended that the latter value (r = 6372.8 km) be used (which\nmost of the given solutions have already adopted, anyways). \n\n```\n\nMost of the examples below adopted Kaimbridge's recommended value of\n6372.8 km for the earth radius. However, the derivation of this\nellipsoidal quadratic mean radius\nis wrong (the averaging over azimuth is biased). When applying these\nexamples in real applications, it is better to use the\nmean earth radius,\n6371 km. This value is recommended by the International Union of\nGeodesy and Geophysics and it minimizes the RMS relative error between the\ngreat circle and geodesic distance."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nclass EarthPoint {\n        has $.lat; # latitude\n        has $.lon; # longitude\n\n        has $earth_radius = 6371; # mean earth radius\n        has $radian_ratio = pi / 180;\n\n        # accessors for radians\n        method latR { $.lat * $radian_ratio }\n        method lonR { $.lon * $radian_ratio }\n\n        method haversine-dist(EarthPoint $p) {\n\n                my EarthPoint $arc .= new(\n                        lat => $!lat - $p.lat,\n                        lon => $!lon - $p.lon );\n\n                my $a = sin($arc.latR/2) ** 2 + sin($arc.lonR/2) ** 2\n                        * cos($.latR) * cos($p.latR);\n                my $c = 2 * asin( sqrt($a) );\n\n                return $earth_radius * $c;\n        }\n}\n\nmy EarthPoint $BNA .= new(lat => 36.12, lon => -86.67);\nmy EarthPoint $LAX .= new(lat => 33.94, lon => -118.4);\n\nsay $BNA.haversine-dist($LAX); # 2886.44444099822\n\n```"}]}
{"messages": [{"role": "user", "content": "Held–Karp Algorithm Problem Description\n\nThe Held–Karp algorithm is a classic dynamic programming algorithm used to solve the Traveling Salesperson Problem (TSP). While the TSP is an NP-hard problem, the Held–Karp algorithm provides an exact solution in exponential time, which is considerably more efficient than a brute-force search for small to moderately sized inputs.\n\nProblem Statement\n:   Traveling Salesperson Problem\n\nGiven a set of **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle n}**\ncities and a matrix \n\nC\n{\\displaystyle {\\displaystyle C}}\n where \n\nC\n\ni\nj\n{\\displaystyle {\\displaystyle C\\_{ij}}}\n represents the cost (or distance) of traveling from city \n\ni\n{\\displaystyle {\\displaystyle i}}\n to city **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle j}**\n, the Traveling Salesperson Problem (TSP) requires finding the minimum-cost route that visits each city exactly once and returns to the starting city.\n\nLet the cities be indexed from \n\n0\n{\\displaystyle {\\displaystyle 0}}\n to \n\nn\n−\n1\n{\\displaystyle {\\displaystyle n-1}}\n. We seek a permutation of cities \n\n(\n\nv\n\n0\n,\n\nv\n\n1\n,\n…\n,\n\nv\n\nn\n−\n1\n)\n{\\displaystyle {\\displaystyle (v\\_{0},v\\_{1},\\dots ,v\\_{n-1})}}\n, where \n\nv\n\n0\n{\\displaystyle {\\displaystyle v\\_{0}}}\n is the starting city (e.g., city 0), such that the total cost of the cycle\n\nTotal Cost\n=\n\n∑\n\ni\n=\n0\n\nn\n−\n2\n\nC\n\n\nv\n\ni\n,\n\nv\n\ni\n+\n1\n+\n\nC\n\n\nv\n\nn\n−\n1\n,\n\nv\n\n0\n{\\displaystyle {\\displaystyle {\\text{Total Cost}}=\\sum \\_{i=0}^{n-2}C\\_{v\\_{i},v\\_{i+1}}+C\\_{v\\_{n-1},v\\_{0}}}}\n\nis minimized.\n\nAlgorithm Overview\n\nThe Held–Karp algorithm employs dynamic programming to solve the TSP. It breaks down the problem into smaller subproblems defined by the set of cities visited so far and the current location of the salesperson.\n\nDynamic Programming State\n\nLet \n\nd\np\n(\nS\n,\nj\n)\n{\\displaystyle {\\displaystyle dp(S,j)}}\n represent the minimum cost of a path that starts at a designated city (typically city 0), visits all cities in the set \n\nS\n{\\displaystyle {\\displaystyle S}}\n exactly once, and ends at city **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle j}**\n, where \n\nj\n∈\nS\n{\\displaystyle {\\displaystyle j\\in S}}\n and the starting city **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle 0 \\in S}**\n.\n\nHere, \n\nS\n{\\displaystyle {\\displaystyle S}}\n is a subset of the set of all cities \n\nV\n=\n\n0\n,\n1\n,\n…\n,\nn\n−\n1\n{\\displaystyle {\\displaystyle V={0,1,\\dots ,n-1}}}\n, and **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle j}**\nis a city in the subset \n\nS\n{\\displaystyle {\\displaystyle S}}\n. Note that we fix the starting city as 0 and require **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle 0 \\in S}**\nfor any state.\n\nBase Case\n\nThe base case for the dynamic programming is a path starting at city 0 and going directly to another city **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle j}**\n.\nFor all cities \n\nj\n∈\n\n1\n,\n2\n,\n…\n,\nn\n−\n1\n{\\displaystyle {\\displaystyle j\\in {1,2,\\dots ,n-1}}}\n:\n\nd\np\n(\n{\n0\n,\nj\n}\n,\nj\n)\n=\n\nC\n\n0\n,\nj\n{\\displaystyle {\\displaystyle dp(\\{0,j\\},j)=C\\_{0,j}}}\n\nThis represents the shortest path from city 0 visiting only cities 0 and **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle j}**\n, ending at city **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle j}**\n.\n\nRecurrence Relation\n\nTo compute \n\nd\np\n(\nS\n,\nj\n)\n{\\displaystyle {\\displaystyle dp(S,j)}}\n for a subset \n\nS\n{\\displaystyle {\\displaystyle S}}\n with \n\n|\nS\n\n|\n>\n2\n{\\displaystyle {\\displaystyle |S|>2}}\n and \n\nj\n≠\n0\n{\\displaystyle {\\displaystyle j\\neq 0}}\n, the path must have arrived at city **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle j}**\nfrom some city \n\ni\n{\\displaystyle {\\displaystyle i}}\n where \n\ni\n∈\nS\n{\\displaystyle {\\displaystyle i\\in S}}\n and **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle i \\ne j}**\n. The path leading to city \n\ni\n{\\displaystyle {\\displaystyle i}}\n must have visited all cities in the subset \n\nS\n∖\n\nj\n{\\displaystyle {\\displaystyle S\\setminus {j}}}\n and ended at \n\ni\n{\\displaystyle {\\displaystyle i}}\n. The cost of this path is \n\nd\np\n(\nS\n∖\n\nj\n,\ni\n)\n{\\displaystyle {\\displaystyle dp(S\\setminus {j},i)}}\n. Therefore, the minimum cost to reach city **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle j}**\nhaving visited all cities in \n\nS\n{\\displaystyle {\\displaystyle S}}\n is the minimum cost over all possible preceding cities \n\ni\n{\\displaystyle {\\displaystyle i}}\n plus the cost of the final leg from \n\ni\n{\\displaystyle {\\displaystyle i}}\n to **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle j}**\n.\n\nFor **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle S \\subseteq V}**\nwith \n\n|\nS\n\n|\n>\n2\n{\\displaystyle {\\displaystyle |S|>2}}\n, **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle 0 \\in S}**\n, and \n\nj\n∈\nS\n,\nj\n≠\n0\n{\\displaystyle {\\displaystyle j\\in S,j\\neq 0}}\n:\n\nd\np\n(\nS\n,\nj\n)\n=\n\nmin\n\ni\n∈\nS\n,\ni\n≠\nj\n{\nd\np\n(\nS\n∖\n{\nj\n}\n,\ni\n)\n+\n\nC\n\ni\n,\nj\n}\n{\\displaystyle {\\displaystyle dp(S,j)=\\min \\_{i\\in S,i\\neq j}\\{dp(S\\setminus \\{j\\},i)+C\\_{i,j}\\}}}\n\nThe algorithm computes these values iteratively, starting with subsets of size 2, then size 3, and so on, up to size **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle n}**\n.\n\nFinal Solution\n\nThe final goal is to find the shortest Hamiltonian cycle starting and ending at city 0. This means we need to find the shortest path that visits all cities in **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle V}**\n, ends at some city \n\nj\n≠\n0\n{\\displaystyle {\\displaystyle j\\neq 0}}\n, and then add the cost of returning from **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle j}**\nto 0.\n\nThe minimum total cost for the TSP is:\n\nmin\n\nj\n∈\n{\n1\n,\n…\n,\nn\n−\n1\n}\n{\nd\np\n(\nV\n,\nj\n)\n+\n\nC\n\nj\n,\n0\n}\n{\\displaystyle {\\displaystyle \\min \\_{j\\in \\{1,\\dots ,n-1\\}}\\{dp(V,j)+C\\_{j,0}\\}}}\n\nwhere **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle V}**\nis the set of all **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle n}**\ncities.\n\nComplexity\n\nThe time complexity of the Held–Karp algorithm is determined by the number of states and the cost to compute each state.\n\nNumber of states \n\n(\nS\n,\nj\n)\n{\\displaystyle {\\displaystyle (S,j)}}\n: There are \n\n2\n\nn\n−\n1\n{\\displaystyle {\\displaystyle 2^{n-1}}}\n possible subsets \n\nS\n{\\displaystyle {\\displaystyle S}}\n that contain city 0. For each subset \n\nS\n{\\displaystyle {\\displaystyle S}}\n with \n\nk\n{\\displaystyle {\\displaystyle k}}\n cities, there are **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle k-1}**\npossible ending cities \n\nj\n≠\n0\n{\\displaystyle {\\displaystyle j\\neq 0}}\n. The total number of states is bounded by \n\nO\n(\nn\n\n2\n\nn\n)\n{\\displaystyle {\\displaystyle O(n2^{n})}}\n.\n\nTransition cost: To compute \n\nd\np\n(\nS\n,\nj\n)\n{\\displaystyle {\\displaystyle dp(S,j)}}\n, we iterate through all possible previous cities \n\ni\n∈\nS\n∖\n\nj\n{\\displaystyle {\\displaystyle i\\in S\\setminus {j}}}\n. There are at most \n\nn\n−\n1\n{\\displaystyle {\\displaystyle n-1}}\n such cities.\n\nOverall time complexity: \n\nO\n(\nn\n⋅\n\n2\n\nn\n⋅\nn\n)\n=\nO\n(\n\nn\n\n2\n\n2\n\nn\n)\n{\\displaystyle {\\displaystyle O(n\\cdot 2^{n}\\cdot n)=O(n^{2}2^{n})}}\n.\n\nThe space complexity required to store the DP table \n\nd\np\n(\nS\n,\nj\n)\n{\\displaystyle {\\displaystyle dp(S,j)}}\n is proportional to the number of states, which is \n\nO\n(\nn\n\n2\n\nn\n)\n{\\displaystyle {\\displaystyle O(n2^{n})}}\n.\n\nWhile exponential, this is significantly better than the \n\nO\n(\nn\n!\n)\n{\\displaystyle {\\displaystyle O(n!)}}\n complexity of brute-force enumeration of all possible permutations."}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20250515 Raku programming solution\n\nclass Result { has Int ( $.Cost, @.Tour ) }\n\n# heldKarp solves the Traveling Salesman Problem using the Held–Karp algorithm (O(n^2·2^n)).\n# @dist is an n×n matrix of pairwise distances.\n# Returns a Result{minimumCost, tour}, where tour is a sequence of city indices\n# starting and ending at 0.\nsub heldKarp(@dist) {\n   my $subsetCount = 2 ** ( my $n = @dist.elems );\n   # dp[mask][j] = minimum cost to start at 0, visit exactly the cities in mask, and end at j\n   my (@dp,@parents) := [[Inf xx $n] xx $subsetCount], [[-1 xx $n] xx $subsetCount];\n   @dp[1][0] = 0; # Base case: mask = 1<<0, at city 0, cost = 0\n\n   for ^$subsetCount -> $mask { # Build up dp table       \n      next if $mask +& 1 == 0; # City 0 must always be included\n      for ^$n -> $j {\n         next if $mask +& (1 +< $j) == 0;\n         my $prevMask = $mask +^ (1 +< $j);\n         for ^$n -> $k {\n            next if $prevMask +& (1 +< $k) == 0;\n            if ( my $cost = @dp[$prevMask;$k] + @dist[$k;$j] ) < @dp[$mask;$j] {\n               ( @dp[$mask][$j], @parents[$mask][$j] ) = $cost, $k\n            }\n         }\n      }\n   }\n\n   # Complete the tour by returning to city 0\n   my ($fullMask, $minCost, $lastCity) = $subsetCount - 1, Inf, 0; \n\n   for ^$n -> $j {\n      if ( my $cost = @dp[$fullMask;$j] + @dist[$j;0] ) < $minCost {\n         ( $minCost, $lastCity ) = $cost, $j\n      }\n   }\n\n   # Reconstruct the optimal tour\n   my ($mask, $curr, @tour) = $fullMask, $lastCity, ($lastCity); \n\n   while @tour[0] != 0 {\n      my $prev = @parents[$mask;$curr];\n      $mask +^= 1 +< $curr;\n      $curr = $prev;\n      @tour.unshift($curr);\n   }\n   @tour.push(0); # append the start city, then return to start\n\n   return Result.new(Cost => $minCost, Tour => @tour)\n}\n\n# Test case: 4 cities with symmetric distances\nmy @dist = [ <0 2 9 10>, <1 0 6 4>, <15 7 0 8>, <6 3 12 0> ]; \n\ngiven heldKarp(@dist) { say \"Minimum tour cost: { .Cost }\\nTour: { .Tour }\" }\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay the string       **Goodbye, World!**       on a GUI object   (alert box, plain window, text area, etc.).\n\nRelated task\n\n* Hello world/Text"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n**Library:** GTK\n\n```\nuse GTK::Simple;\nuse GTK::Simple::App;\n\nmy GTK::Simple::App $app .= new;\n$app.border-width = 20;\n$app.set-content( GTK::Simple::Label.new(text => \"Goodbye, World!\") );\n$app.run;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCause a line printer attached to the computer to print a line containing the message:    `Hello World!`\n\nNote\n\nA line printer is not the same as standard output.\n\nA   line printer   was an older-style printer which prints one line at a time to a continuous ream of paper.\n\nWith some systems, a line printer can be any device attached to an appropriate port (such as a parallel port)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $lp = open '/dev/lp0', :w;\n$lp.say: 'Hello World!';\n$lp.close;\n\n```\n\nOr using `given` to avoid having to write the variable name repeatedly:\n\n```\ngiven open '/dev/lp0', :w {\n    .say: 'Hello World!';\n    .close;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGuide a new user of a language through the steps necessary\nto install the programming language and selection of a text editor if needed,\nto run the languages' example in the Hello world/Text task.\n\n* Assume the language-newbie is a programmer in another language.\n* Assume the language-newbie is competent in installing software for the platform.\n* Assume the language-newbie can use one simple text editor for the OS/platform, (but that may not necessarily be a particular one if the installation needs a particular editor).\n* Refer to, (and link to), already existing documentation as much as possible (but provide a summary here).\n* Remember to state where to view the output.\n* If particular IDE's or editors are required that are not standard, then point to/explain their installation too.\n\nNote:\n\n* If it is more natural for a language to give output via a GUI or to a file etc, then use that method of output rather than as text to a terminal/command-line, but remember to give instructions on how to view the output generated.\n* You may use sub-headings if giving instructions for multiple platforms."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku is a language spec and test suite, not an implementation. Any implementation which implements the spec and passes the test suite can call itself Raku. Philosophically, there is no official \"Raku distribution\". Practically, at this point (early 2020), Rakudo Raku is the only realistic option. There are others, but they are either not currently being developed or far behind Rakudo in functionality.\n\nThere are several ways to get and install Rakudo Raku depending on your operating system and the balance between your technical familiarity and tolerance of outdated code. Rakudo Raku is still in heavy development and the code base still has features being added, refined and optimized on a daily basis; a few weeks can make a big difference.\n\nFor ease of installation, there are MSI files for Windows, Homebrew packages for OSX and pre-built Linux packages for apt and yum based packaging systems. They will get you a working compiler most easily, but may be weeks or months behind a blead source build.\n\nAll of these options are detailed in the Downloads section of the Rakuko.org website.\n\nIf you do run into problems installing Rakudo, (or any Raku compiler, or have any Raku questions,) the #raku IRC channel on freenode.net nearly always has people willing to help out.\n\nOnce you have your compiler installed, open a terminal window and type:\n\n```\n raku -e'say \"Hello World!\"'\n \n\n```\n\nor, under Windows cmd.exe,\n\n```\n raku -e\"say 'Hello World!'\"\n\n```\n\nand press enter.\n\nAlternately, type\n\n```\n echo say 'Hello World!' > hw.raku\n\n```\n\nthen type\n\n```\n raku hw.raku\n\n```\n\nto execute it.\n\nNote that the file name may have any extension or none at all."}]}
{"messages": [{"role": "user", "content": "Some languages automatically insert a newline after outputting a string, unless measures are taken to prevent its output.\n\nTask\n\nDisplay the string   `Goodbye, World!`   without a trailing newline.\n\nRelated tasks\n\n* Hello world/Graphical\n* Hello world/Line Printer\n* Hello world/Standard error\n* Hello world/Text"}, {"role": "assistant", "content": "(formerly Perl 6)\nA newline is not added automatically to print or printf\n\n```\nprint \"Goodbye, World!\";\nprintf \"%s\", \"Goodbye, World!\";\n```"}]}
{"messages": [{"role": "user", "content": "A common practice in computing is to send error messages\nto a different output stream than normal text console messages.\n\nThe normal messages print to what is called \"standard output\" or \"standard out\".\n\nThe error messages print to \"standard error\".\n\nThis separation can be used to redirect error messages to a different place than normal messages.\n\nTask\n\nShow how to print a message to standard error by printing     **Goodbye, World!**     on that stream."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nnote \"Goodbye, World!\";\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay the string **Hello world!** on a text console.\n\nRelated tasks\n\n* Hello world/Graphical\n* Hello world/Line Printer\n* Hello world/Newbie\n* Hello world/Newline omission\n* Hello world/Standard error\n* Hello world/Web server"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsay 'Hello world!';\n```\n\nIn an object-oriented approach, the string is treated as an object calling its **say()** method:\n\n```\n\"Hello, World!\".say();\n```"}]}
{"messages": [{"role": "user", "content": "The browser is the new GUI !\n\nTask\n\nServe our standard text   `Goodbye, World!`   to   http://localhost:8080/   so that it can be viewed with a web browser.\n\nThe provided solution must start or implement a server that accepts multiple client connections and serves text as requested.\n\nNote that starting a web browser or opening a new window with this URL\nis not part of the task.\n\nAdditionally, it is permissible to serve the provided page as a plain text file (there is no requirement to serve properly formatted HTML here).\n\nThe browser will generally do the right thing with simple text like this."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo\n\n```\nmy $listen = IO::Socket::INET.new(:listen, :localhost<localhost>, :localport(8080));\nloop {\n    my $conn = $listen.accept;\n    my $req =  $conn.get ;\n    $conn.print: \"HTTP/1.0 200 OK\\r\\nContent-Type: text/plain; charset=UTF-8\\r\\n\\r\\nGoodbye, World!\\r\\n\";\n    $conn.close;\n}\n\n```\n\nAsync:\n\n```\nreact {\n    whenever IO::Socket::Async.listen('0.0.0.0', 8080) -> $conn {\n        whenever $conn.Supply.lines -> $line {\n            $conn.print: \"HTTP/1.0 200 OK\\r\\nContent-Type: text/plain; charset=UTF-8\\r\\n\\r\\nGoodbye, World!\\r\\n\";\n            $conn.close;\n        }\n    }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "A   *here document*   (or \"heredoc\")   is a way of specifying a text block, preserving the line breaks, indentation and other whitespace within the text.\n\nDepending on the language being used, a   *here document*   is constructed using a command followed by \"<<\" (or some other symbol) followed by a token string.\n\nThe text block will then start on the next line, and will be followed by the chosen token at the beginning of the following line, which is used to mark the end of the text block.\n\nTask\n\nDemonstrate the use of   *here documents*   within the language.\n\nRelated task\n\n* Documentation"}, {"role": "assistant", "content": "(formerly Perl 6)\nHeredocs in Raku use the `:to` modifier to a quoting operator,\nsuch as `q` or `qq`.\nThe indentation of the end marker is removed from every line.\n\n```\nmy $color = 'green';\nsay qq :to 'END';\n    some line\n    color: $color\n    another line\n    END\n\n```\n\nOutput:\n\n```\nsome line\ncolor: green\nanother line\n\n```\n\nNote that the quotes around the \"END\" are not magic --- the marker is just a regular string; it's the `q` or `qq` that decides whether or not the heredoc interpolates.\n\nMultiple here docs may be stacked on top of each other.\n\n```\nmy $contrived_example = 'Dylan';\nsub freewheelin() {\n        print q :to 'QUOTE', '-- ', qq :to 'AUTHOR';\n          I'll let you be in my dream,\n            if I can be in yours.\n        QUOTE\n                Bob $contrived_example\n                AUTHOR\n}\n\nfreewheelin;\n\n```\n\nOutput:\n\n```\n  I'll let you be in my dream,\n    if I can be in yours.\n-- Bob Dylan\n\n```\n\nBoth q and qq are specialised forms of Q which comes with many adverbs. Here a heredoc that only interpolates @-sigils.\n\n```\nmy @a = <1 2 3 4>;\nsay Q :array :to 'EOH';\n    123 \\n '\"`\n        @a$bc\n        @a[]\n    EOH\n\n```\n\nOutput:\n\n```\n123 \\n '\"`\n    @a$bc\n    1 2 3 4\n```"}]}
{"messages": [{"role": "user", "content": "Hero's formula for the area of a triangle given the length of its three sides    *a*,   *b*,   and   *c*   is given by:\n\n:   :   :   :   A\n                =\n\n\n                s\n                (\n                s\n                −\n                a\n                )\n                (\n                s\n                −\n                b\n                )\n                (\n                s\n                −\n                c\n                )\n                ,\n                {\\displaystyle {\\displaystyle A={\\sqrt {s(s-a)(s-b)(s-c)}},}}\n\nwhere   *s*   is half the perimeter of the triangle; that is,\n\n:   :   :   :   s\n                =\n\n                a\n                +\n                b\n                +\n                c\n                2\n                .\n                {\\displaystyle {\\displaystyle s={\\frac {a+b+c}{2}}.}}\n\n**Heronian triangles**\nare triangles whose sides *and area* are all integers.\n\n:   An example is the triangle with sides   **3, 4, 5**   whose area is   **6**   (and whose perimeter is   **12**).\n\nNote that any triangle whose sides are all an integer multiple of   **3, 4, 5**;   such as   **6, 8, 10,**   will also be a Heronian triangle.\n\nDefine a **Primitive Heronian triangle** as a Heronian triangle where the greatest common divisor\nof all three sides is   **1**   (unity).\n\nThis will exclude, for example, triangle   **6, 8, 10.**\n\nTask\n\n1. Create a named function/method/procedure/... that implements Hero's formula.\n2. Use the function to generate all the *primitive* Heronian triangles with sides <= 200.\n3. Show the count of how many triangles are found.\n4. Order the triangles by first increasing area, then by increasing perimeter, then by increasing maximum side lengths\n5. Show the first ten ordered triangles in a table of sides, perimeter, and area.\n6. Show a similar ordered table for those triangles with area = 210\n\nShow all output here.\n\n**Note**: when generating triangles it may help to restrict \n\na\n<=\nb\n<=\nc\n{\\displaystyle {\\displaystyle a<=b<=c}}"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\n```\nsub hero($a, $b, $c) {\n    my $s = ($a + $b + $c) / 2;\n    ($s * ($s - $a) * ($s - $b) * ($s - $c)).sqrt;\n}\n \nsub heronian-area($a, $b, $c) {\n    $_ when Int given hero($a, $b, $c).narrow;\n} \n\nsub primitive-heronian-area($a, $b, $c) {\n    heronian-area $a, $b, $c\n        if 1 == [gcd] $a, $b, $c;\n}\n\nsub show(@measures) {\n    say \"   Area Perimeter   Sides\";\n    for @measures -> [$area, $perim, $c, $b, $a] {\n\tprintf \"%6d %6d %12s\\n\", $area, $perim, \"$a×$b×$c\";\n    }\n}\n \nsub MAIN ($maxside = 200, $first = 10, $witharea = 210) {\n    my @hh[1000];\n    my atomicint $i;\n    (1 .. $maxside).race(:12batch).map: -> $c {\n        for 1 .. $c -> $b {\n            for $c - $b + 1 .. $b -> $a {\n                if primitive-heronian-area($a,$b,$c) -> $area {\n                    @hh[$i⚛++] = [$area, $a+$b+$c, $c, $b, $a];\n                }\n            }\n        }\n    }\n\n    my @h = (@hh.grep: so *).sort;\n    say \"Primitive Heronian triangles with sides up to $maxside: \", +@h;\n\n    say \"\\nFirst $first:\";\n    show @h[^$first];\n\n    say \"\\nArea $witharea:\";\n    show @h.grep: *[0] == $witharea;\n}\n\n```\n\nOutput:\n\n```\nPrimitive Heronian triangles with sides up to 200: 517\n\nFirst 10:\n   Area Perimeter   Sides\n     6     12        3×4×5\n    12     16        5×5×6\n    12     18        5×5×8\n    24     32      4×13×15\n    30     30      5×12×13\n    36     36      9×10×17\n    36     54      3×25×26\n    42     42      7×15×20\n    60     36     10×13×13\n    60     40      8×15×17\n\nArea 210:\n   Area Perimeter   Sides\n   210     70     17×25×28\n   210     70     20×21×29\n   210     84     12×35×37\n   210     84     17×28×39\n   210    140      7×65×68\n   210    300    3×148×149\n```"}]}
{"messages": [{"role": "user", "content": "A hex dump is a textual representation of bytes in a file, and *hexdump* is a command-line tool that can dump bytes from a file in a variety of formats, including hexadecimal, octal and ASCII.\n\nhexdump's canonical format displays, on each line:\n\n* a byte offset in hexadecimal,\n* up to 16 bytes in hexadecimal, separated by spaces, with an extra space between the 8th and 9th byte,\n* the same 16 bytes interpreted as ASCII characters, with non-printing and non-ascii characters replaced with a dot (`.`), surrounded by pipes (`|`).\n\nThe last line of output shows a final byte count, also in hexadecimal.\n\nFor example, the string \"Rosetta Code is a programming chrestomathy site 😀.\" encoded in UTF-16 (little-endian - the first two bytes are the byte order mark), displayed in the canonical format is:\n\n```\n00000000  ff fe 52 00 6f 00 73 00  65 00 74 00 74 00 61 00  |..R.o.s.e.t.t.a.|\n00000010  20 00 43 00 6f 00 64 00  65 00 20 00 69 00 73 00  | .C.o.d.e. .i.s.|\n00000020  20 00 61 00 20 00 70 00  72 00 6f 00 67 00 72 00  | .a. .p.r.o.g.r.|\n00000030  61 00 6d 00 6d 00 69 00  6e 00 67 00 20 00 63 00  |a.m.m.i.n.g. .c.|\n00000040  68 00 72 00 65 00 73 00  74 00 6f 00 6d 00 61 00  |h.r.e.s.t.o.m.a.|\n00000050  74 00 68 00 79 00 20 00  73 00 69 00 74 00 65 00  |t.h.y. .s.i.t.e.|\n00000060  20 00 3d d8 00 de 2e 00                           | .=.....|\n00000068\n\n```\n\nTask\n\nImplement a hexdump-like program that:\n\n* outputs in the canonical format,\n* takes an optional offset in bytes from which to start,\n* takes an optional length in bytes after which it will stop.\n\nDemonstrate your implementation by showing the canonical hex dump of the example above, plus any other examples you find useful.\n\nStretch\n\n*xxd* is another command-line tool similar to hexdump. It offers a binary mode where bytes are displayed in bits instead of hexadecimal.\n\nImplement a binary mode. For this task, in binary mode, the example above should be displayed like this:\n\n```\n00000000  11111111 11111110 01010010 00000000 01101111 00000000  |..R.o.|\n00000006  01110011 00000000 01100101 00000000 01110100 00000000  |s.e.t.|\n0000000c  01110100 00000000 01100001 00000000 00100000 00000000  |t.a. .|\n00000012  01000011 00000000 01101111 00000000 01100100 00000000  |C.o.d.|\n00000018  01100101 00000000 00100000 00000000 01101001 00000000  |e. .i.|\n0000001e  01110011 00000000 00100000 00000000 01100001 00000000  |s. .a.|\n00000024  00100000 00000000 01110000 00000000 01110010 00000000  | .p.r.|\n0000002a  01101111 00000000 01100111 00000000 01110010 00000000  |o.g.r.|\n00000030  01100001 00000000 01101101 00000000 01101101 00000000  |a.m.m.|\n00000036  01101001 00000000 01101110 00000000 01100111 00000000  |i.n.g.|\n0000003c  00100000 00000000 01100011 00000000 01101000 00000000  | .c.h.|\n00000042  01110010 00000000 01100101 00000000 01110011 00000000  |r.e.s.|\n00000048  01110100 00000000 01101111 00000000 01101101 00000000  |t.o.m.|\n0000004e  01100001 00000000 01110100 00000000 01101000 00000000  |a.t.h.|\n00000054  01111001 00000000 00100000 00000000 01110011 00000000  |y. .s.|\n0000005a  01101001 00000000 01110100 00000000 01100101 00000000  |i.t.e.|\n00000060  00100000 00000000 00111101 11011000 00000000 11011110  | .=...|\n00000066  00101110 00000000                                      |..|\n00000068\n\n```\n\nOther hexdump/xxd features and a command line interface to your program are optional."}, {"role": "assistant", "content": "The hexdump() routine expects a Blob. How you feed it the Blob is up to you. You may read a file in binary mode, encode a string, whatever. Using encoded strings here for a compact, self-contained example. Encoded in a few different ways for variety.\n\n```\nsay my $string = 'Rosettacode is a programming crestomathy site 😀.    🍨 👨‍👩‍👦 ⚽ ¯\\_(ツ)_/¯';\n\nsay \"\\nHex dump UTF-16BE, offset 0\";\nhexdump $string.encode(\"UTF-16BE\");\n\nsay \"\\nHex dump UTF-16LE, offset 0\";\nhexdump $string.encode(\"UTF-16LE\");\n\nsay \"\\nBinary dump UTF-8, offset 17\";\nhexdump $string.encode(\"UTF-8\"), :bin, :17offset;\n\nsub hexdump(Blob $blob, Int :$offset is copy = 0, :$bin = False) {\n    my ($fmt, $space, $batch) = $bin ?? (\"%08b\", ' ' x 8, 6) !! (\"%02X\", '  ', 16);\n    for $blob.skip($offset).batch($batch) {\n        my @h = flat $_».fmt($fmt), $space xx $batch;\n        @h[7] ~= ' ';\n        printf \"%08X  %s  |%s|\\n\", $offset, @h[^$batch].Str,\n           $_».chr.join.subst(/<-print>|\\t|\\n/, '.', :g);\n        $offset += $batch;\n    }\n}\n\n```\n\nOutput:\n\n```\nRosettacode is a programming crestomathy site 😀.    🍨 👨‍👩‍👦 ⚽ ¯\\_(ツ)_/¯\n\nHex dump UTF-16BE, offset 0\n00000000  00 52 00 6F 00 73 00 65  00 74 00 74 00 61 00 63  |.R.o.s.e.t.t.a.c|\n00000010  00 6F 00 64 00 65 00 20  00 69 00 73 00 20 00 61  |.o.d.e. .i.s. .a|\n00000020  00 20 00 70 00 72 00 6F  00 67 00 72 00 61 00 6D  |. .p.r.o.g.r.a.m|\n00000030  00 6D 00 69 00 6E 00 67  00 20 00 63 00 72 00 65  |.m.i.n.g. .c.r.e|\n00000040  00 73 00 74 00 6F 00 6D  00 61 00 74 00 68 00 79  |.s.t.o.m.a.t.h.y|\n00000050  00 20 00 73 00 69 00 74  00 65 00 20 D8 3D DE 00  |. .s.i.t.e. Ø=Þ.|\n00000060  00 2E 00 20 00 20 00 20  00 20 D8 3C DF 68 00 20  |... . . . Ø<ßh. |\n00000070  D8 3D DC 68 20 0D D8 3D  DC 69 20 0D D8 3D DC 66  |Ø=Üh .Ø=Üi .Ø=Üf|\n00000080  00 20 26 BD 00 20 00 AF  00 5C 00 5F 00 28 30 C4  |. &½. .¯.\\._.(0Ä|\n00000090  00 29 00 5F 00 2F 00 AF                           |.)._./.¯|\n\nHex dump UTF-16LE, offset 0\n00000000  52 00 6F 00 73 00 65 00  74 00 74 00 61 00 63 00  |R.o.s.e.t.t.a.c.|\n00000010  6F 00 64 00 65 00 20 00  69 00 73 00 20 00 61 00  |o.d.e. .i.s. .a.|\n00000020  20 00 70 00 72 00 6F 00  67 00 72 00 61 00 6D 00  | .p.r.o.g.r.a.m.|\n00000030  6D 00 69 00 6E 00 67 00  20 00 63 00 72 00 65 00  |m.i.n.g. .c.r.e.|\n00000040  73 00 74 00 6F 00 6D 00  61 00 74 00 68 00 79 00  |s.t.o.m.a.t.h.y.|\n00000050  20 00 73 00 69 00 74 00  65 00 20 00 3D D8 00 DE  | .s.i.t.e. .=Ø.Þ|\n00000060  2E 00 20 00 20 00 20 00  20 00 3C D8 68 DF 20 00  |.. . . . .<Øhß .|\n00000070  3D D8 68 DC 0D 20 3D D8  69 DC 0D 20 3D D8 66 DC  |=ØhÜ. =ØiÜ. =ØfÜ|\n00000080  20 00 BD 26 20 00 AF 00  5C 00 5F 00 28 00 C4 30  | .½& .¯.\\._.(.Ä0|\n00000090  29 00 5F 00 2F 00 AF 00                           |)._./.¯.|\n\nBinary dump UTF-8, offset 17\n00000011  01110000 01110010 01101111 01100111 01110010 01100001  |progra|\n00000017  01101101 01101101 01101001 01101110 01100111 00100000  |mming |\n0000001D  01100011 01110010 01100101 01110011 01110100 01101111  |cresto|\n00000023  01101101 01100001 01110100 01101000 01111001 00100000  |mathy |\n00000029  01110011 01101001 01110100 01100101 00100000 11110000  |site ð|\n0000002F  10011111 10011000 10000000 00101110 00100000 00100000  |....  |\n00000035  00100000 00100000 11110000 10011111 10001101 10101000  |  ð..¨|\n0000003B  00100000 11110000 10011111 10010001 10101000 11100010  | ð..¨â|\n00000041  10000000 10001101 11110000 10011111 10010001 10101001  |..ð..©|\n00000047  11100010 10000000 10001101 11110000 10011111 10010001  |â..ð..|\n0000004D  10100110 00100000 11100010 10011010 10111101 00100000  |¦ â.½ |\n00000053  11000010 10101111 01011100 01011111 00101000 11100011  |¯\\_(ã|\n00000059  10000011 10000100 00101001 01011111 00101111 11000010  |..)_/Â|\n0000005F  10101111                                               |¯|\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nFor the purposes of this task a **hex word** means a word which (in lower case form) consists entirely of the letters **a, b, c, d, e** and **f**.\n\nTask\n\nUsing unixdict.txt, find all hex words with **4** letters or more.\n\nConvert each such word to its decimal equivalent and compute its base 10 digital root.\n\nDisplay all three in increasing order of digital root and show the total count of such words.\n\nKeeping only words which contain at least **4** distinct letters, display the same statistics but in decreasing order of decimal equivalent together with their total count."}, {"role": "assistant", "content": "Sorted by digital root with a secondary alphabetical sort.\n\n```\nsub dr (Int $_ is copy) { $_ = .comb.sum while .chars > 1; $_ }\n\nmy %hex = './unixdict.txt'.IO.slurp.words.grep( *.chars > 3 )\\\n  .grep({ not / <-[abcdef]> / }).map: { $_ => dr :16($_).comb.sum }\n\nsay \"{+%hex} hex words longer than 3 characters found in unixdict.txt:\";\nprintf \"%6s ➡ %8d ➡ %d\\n\", .key, :16(.key), .value for %hex.sort: { .value, .key }\n\nmy %many = %hex.grep: +*.key.comb.Set > 3;\n\nsay \"\\nOf which {+%many} contain at least four distinct characters:\";\nprintf \"%6s ➡ %8d ➡ %d\\n\", .key, :16(.key), .value for %many.sort: { -:16(.key) }\n\n```\n\nOutput:\n\n```\n26 hex words longer than 3 characters found in unixdict.txt:\n ababa ➡   703162 ➡ 1\n  abbe ➡    43966 ➡ 1\n  dada ➡    56026 ➡ 1\n  deaf ➡    57007 ➡ 1\ndecade ➡ 14600926 ➡ 1\n  cede ➡    52958 ➡ 2\n  feed ➡    65261 ➡ 2\n  abed ➡    44013 ➡ 3\n added ➡   712173 ➡ 3\n  bade ➡    47838 ➡ 3\n beebe ➡   782014 ➡ 4\n decca ➡   912586 ➡ 4\n  dade ➡    56030 ➡ 5\n  bead ➡    48813 ➡ 6\ndeface ➡ 14613198 ➡ 6\n  babe ➡    47806 ➡ 7\n  fade ➡    64222 ➡ 7\n  dead ➡    57005 ➡ 8\nefface ➡ 15727310 ➡ 8\nfacade ➡ 16435934 ➡ 8\naccede ➡ 11325150 ➡ 9\n  beef ➡    48879 ➡ 9\n  cafe ➡    51966 ➡ 9\n dacca ➡   896202 ➡ 9\n  deed ➡    57069 ➡ 9\n  face ➡    64206 ➡ 9\n\nOf which 13 contain at least four distinct characters:\nfacade ➡ 16435934 ➡ 8\nefface ➡ 15727310 ➡ 8\ndeface ➡ 14613198 ➡ 6\ndecade ➡ 14600926 ➡ 1\naccede ➡ 11325150 ➡ 9\n decca ➡   912586 ➡ 4\n  fade ➡    64222 ➡ 7\n  face ➡    64206 ➡ 9\n  deaf ➡    57007 ➡ 1\n  cafe ➡    51966 ➡ 9\n  bead ➡    48813 ➡ 6\n  bade ➡    47838 ➡ 3\n  abed ➡    44013 ➡ 3\n```"}]}
{"messages": [{"role": "user", "content": "The following function,   due to D. Hickerson,   is said to generate \"Almost integers\" by the\n  \n\"Almost Integer\" page of Wolfram MathWorld,   (December 31 2013).   (See formula numbered   **51**.)\n\nThe function is:           \n\nh\n(\nn\n)\n=\n\nn\n!\n\n2\n(\nln\n⁡\n\n2\n\n)\n\nn\n+\n1\n{\\displaystyle {\\displaystyle h(n)={\\operatorname {n} ! \\over 2(\\ln {2})^{n+1}}}}\n\nIt is said to produce \"almost integers\" for   **n**   between   **1**   and   **17**.\nThe purpose of the task is to verify this assertion.\n\nAssume that an \"almost integer\" has **either a nine or a zero as its first digit after the decimal point** of its decimal string representation\n\nTask\n\nCalculate all values of the function checking and stating which are \"almost integers\".\n\nNote: Use extended/arbitrary precision numbers in your calculation if necessary to ensure you have adequate precision of results as for example:\n\n```\n               h(18) = 3385534663256845326.39...\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-13\n\nWe'll use FatRat values, and a series for an approximation of ln(2).\n\n```\nconstant ln2 = [+] (1/2.FatRat, */2 ... *) Z/ 1 .. 100;\nconstant h = [\\*] 1/2, |(1..*) X/ ln2;\n\nuse Test;\nplan *;\n \nfor h[1..17] {\n    ok m/'.'<[09]>/, .round(0.001) \n}\n\n```\n\nOutput:\n\n```\nok 1 - 1.041\nok 2 - 3.003\nok 3 - 12.996\nok 4 - 74.999\nok 5 - 541.002\nok 6 - 4683.001\nok 7 - 47292.999\nok 8 - 545834.998\nok 9 - 7087261.002\nok 10 - 102247563.005\nok 11 - 1622632572.998\nok 12 - 28091567594.982\nok 13 - 526858348381.001\nok 14 - 10641342970443.085\nok 15 - 230283190977853.037\nnot ok 16 - 5315654681981354.513\n\n# Failed test '5315654681981354.513'\n# at hickerson line 8\nnot ok 17 - 130370767029135900.458\n\n# Failed test '130370767029135900.458'\n# at hickerson line 8\n```"}]}
{"messages": [{"role": "user", "content": "Description\n\nHierholzer's Algorithm is an efficient way to find Eulerian circuits in a graph.\n\n```\nAlgorithm: Hierholzer's Algorithm\nInput: Graph G = (V, E) represented as adjacency list\nOutput: Eulerian circuit as ordered list of vertices\n\nFunction FindEulerianCircuit(Graph G):\n    // Initialize empty circuit and stack\n    Circuit = empty list\n    Stack = empty stack\n    \n    // Start from any vertex with non-zero degree\n    current = any vertex v in V where degree(v) > 0\n    Push current to Stack\n    \n    While Stack is not empty:\n        if OutDegree(current) == 0:\n            // Add to circuit when no more unused edges\n            Add current to front of Circuit\n            current = Pop from Stack\n        else:\n            // Follow an unused edge\n            Push current to Stack\n            next = any adjacent vertex with unused edge from current\n            Remove edge (current, next) from G\n            current = next\n            \n    Return Circuit\n\nFunction VerifyEulerianCircuit(Graph G):\n    For each vertex v in G:\n        If InDegree(v) ≠ OutDegree(v):\n            Return false\n    If Graph is not strongly connected:\n        Return false\n    Return true\n\nMain Algorithm:\n    1. If not VerifyEulerianCircuit(G):\n        Return \"No Eulerian circuit exists\"\n        \n    2. Circuit = FindEulerianCircuit(G)\n    \n    3. If Circuit contains all edges:\n        Return Circuit\n    Else:\n        Return \"No Eulerian circuit exists\"\n\nPreconditions:\n    - Graph must be connected\n    - All vertices must have equal in-degree and out-degree\n\nTime Complexity: O(|E|) where E is the number of edges\nSpace Complexity: O(|V|) where V is the number of vertices\n```\n\nTask\n\nImplement the Hierholze's Algorithm in your language and test it using the same examples as in the OCaml entry."}, {"role": "assistant", "content": "```\nsay join ' -> ', .&hierholser for ([1],[2],[0]), ([1,6],[2],[0,3],[4],[2,5],[0],[4]);\n\nsub hierholser (@graph) {\n    my @cycle = 0;\n    @cycle.push: @graph[@cycle.tail].pop while @graph[@cycle.tail].elems;\n    @cycle; \n}\n\n```\n\nOutput:\n\n```\n0 -> 1 -> 2 -> 0\n0 -> 6 -> 4 -> 5 -> 0 -> 1 -> 2 -> 3 -> 4 -> 2 -> 0\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task\n\nPass a function     *as an argument*     to another function.\n\nRelated task\n\n* First-class functions"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe best type to use for the parameter of a higher-order function is `Callable` (implied by the `&` sigil), a role common to all function-like objects. For an example of defining and calling a second-order function, see Functional Composition.\n\nConvenient syntax is provided for anonymous functions,\neither a bare block, or a parametrized block introduced with ->, which serves as a \"lambda\":\n\n```\nsub twice(&todo) {\n   todo(); todo(); # declaring &todo also defines bare function\n}\ntwice { say \"Boing!\" }\n# output:\n# Boing!\n# Boing!\n\nsub twice-with-param(&todo) {\n    todo(0); todo(1);\n}\ntwice-with-param -> $time {\n   say \"{$time+1}: Hello!\"\n}\n# output:\n# 1: Hello!\n# 2: Hello!\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nProduce a graphical or ASCII-art representation of a Hilbert curve of at least order 3."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nuse SVG;\n\nrole Lindenmayer {\n    has %.rules;\n    method succ {\n        self.comb.map( { %!rules{$^c} // $c } ).join but Lindenmayer(%!rules)\n    }\n}\n\nmy $hilbert = 'A' but Lindenmayer( { A => '-BF+AFA+FB-', B => '+AF-BFB-FA+' } );\n\n$hilbert++ xx 7;\nmy @points = (647, 13);\n\nfor $hilbert.comb {\n    state ($x, $y) = @points[0,1];\n    state $d = -5 - 0i;\n    when 'F' { @points.append: ($x += $d.re).round(1), ($y += $d.im).round(1) }\n    when /< + - >/ { $d *= \"{$_}1i\" }\n    default { }\n}\n\nsay SVG.serialize(\n    svg => [\n        :660width, :660height, :style<stroke:blue>,\n        :rect[:width<100%>, :height<100%>, :fill<white>],\n        :polyline[ :points(@points.join: ','), :fill<white> ],\n    ],\n);\n\n```\n\nSee: Hilbert curve\n\nThere is a variation of a Hilbert curve known as a Moore curve which is essentially 4 Hilbert curves joined together in a loop.\n\n```\nuse SVG;\n\nrole Lindenmayer {\n    has %.rules;\n    method succ {\n        self.comb.map( { %!rules{$^c} // $c } ).join but Lindenmayer(%!rules)\n    }\n}\n\nmy $moore = 'AFA+F+AFA' but Lindenmayer( { A => '-BF+AFA+FB-', B => '+AF-BFB-FA+' } );\n\n$moore++ xx 6;\nmy @points = (327, 647);\n\nfor $moore.comb {\n    state ($x, $y) = @points[0,1];\n    state $d = 0 - 5i;\n    when 'F' { @points.append: ($x += $d.re).round(1), ($y += $d.im).round(1) }\n    when /< + - >/ { $d *= \"{$_}1i\" }\n    default { }\n}\n\nsay SVG.serialize(\n    svg => [\n        :660width, :660height, :style<stroke:darkviolet>,\n        :rect[:width<100%>, :height<100%>, :fill<white>],\n        :polyline[ :points(@points.join: ','), :fill<white> ],\n    ],\n);\n\n```\n\nSee: Moore curve"}]}
{"messages": [{"role": "user", "content": "*Storing the history of objects in a program is a common task.* \nMaintaining the history of an object in a program has traditionally required programmers either to write specific code for handling the historical data, or to use a library which supports history logging.\n\n*History variables are variables in a programming language which store not only their current value, but also the values they have contained in the past. Some existing languages do provide support for history variables. However these languages typically have many limits and restrictions on use of history variables.*\n\n[http://www.bod.com/index.php?id=3435&objk\\_id=148050 \"History Variables:\nThe Semantics, Formal Correctness, and Implementation of History Variables\nin an Imperative Programming Language\" by Mallon and Takaoka]\n\nConcept also discussed on LtU and Patents.com.\n\nTask\n\nDemonstrate History variable support:\n\n* enable history variable support (if needed)\n* define a history variable\n* assign three values\n* non-destructively display the history\n* recall the three values.\n\nFor extra points, if the language of choice does not support history variables,\ndemonstrate how this might be implemented."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nclass HistoryVar {\n    has @.history;\n    has $!var handles <Str gist FETCH Numeric>;\n    method STORE($val) is rw {\n        push @.history, [now, $!var];\n        $!var = $val;\n    }\n}\n\nmy \\foo = HistoryVar.new;\n\nfoo = 1;\nfoo = 2;\nfoo += 3;\nfoo = 42;\n\n.say for foo.history;\nsay \"Current value: {foo}\";\n\n```\n\nOutput:\n\n```\n[Instant:1523396079.685629 (Any)]\n[Instant:1523396079.686844 1]\n[Instant:1523396079.687130 2]\n[Instant:1523396079.687302 5]\nCurrent value: 42\n\n```"}]}
{"messages": [{"role": "user", "content": "These two sequences of positive integers are defined as:\n\n:   :   :   :   R\n                (\n                1\n                )\n\n\n                =\n                1\n                 \n                ;\n                 \n                S\n                (\n                1\n                )\n                =\n                2\n\n\n                R\n                (\n                n\n                )\n\n\n                =\n                R\n                (\n                n\n                −\n                1\n                )\n                +\n                S\n                (\n                n\n                −\n                1\n                )\n                ,\n\n                n\n                >\n                1.\n                {\\displaystyle {\\displaystyle {\\begin{aligned}R(1)&=1\\ ;\\ S(1)=2\\\\R(n)&=R(n-1)+S(n-1),\\quad n>1.\\end{aligned}}}}\n\nThe sequence \n\nS\n(\nn\n)\n{\\displaystyle {\\displaystyle S(n)}}\n is further defined as the sequence of positive integers ***not*** present in \n\nR\n(\nn\n)\n{\\displaystyle {\\displaystyle R(n)}}\n.\n\nSequence \n\nR\n{\\displaystyle {\\displaystyle R}}\n starts:\n\n```\n   1, 3, 7, 12, 18, ...\n\n```\n\nSequence \n\nS\n{\\displaystyle {\\displaystyle S}}\n starts:\n\n```\n   2, 4, 5, 6, 8, ...\n\n```\n\nTask\n\n1. Create two functions named **ffr** and **ffs** that when given **n** return **R(n)** or **S(n)** respectively.  \n   (Note that R(1) = 1 and S(1) = 2 to avoid off-by-one errors).\n2. No maximum value for **n** should be assumed.\n3. Calculate and show that the first ten values of **R** are:  \n    1, 3, 7, 12, 18, 26, 35, 45, 56, and 69\n4. Calculate and show that the first 40 values of **ffr** plus the first 960 values of **ffs** include all the integers from 1 to 1000 exactly once.\n\nReferences\n\n* Sloane's A005228 and A030124.\n* Wolfram MathWorld\n* Wikipedia: Hofstadter Figure-Figure sequences."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nmy %r = 1 => 1;\nmy %s = 1 => 2;\n\nsub ffr ($n) { %r{$n} //= ffr($n - 1) + ffs($n - 1) }\nsub ffs ($n) { %s{$n} //= (grep none(map &ffr, 1..$n), max(%s.values)+1..*)[0] }\n\nmy @ffr = map &ffr, 1..*;\nmy @ffs = map &ffs, 1..*;\n\nsay @ffr[^10];\nsay \"Rawks!\" if 1...1000 eqv sort |@ffr[^40], |@ffs[^960];\n\n```\n\nOutput:\n\n```\n1 3 7 12 18 26 35 45 56 69\nRawks!\n```"}]}
{"messages": [{"role": "user", "content": "The Hofstadter Q sequence is defined as:\n\n:   :   Q\n        (\n        1\n        )\n\n\n        =\n        Q\n        (\n        2\n        )\n        =\n        1\n        ,\n\n\n        Q\n        (\n        n\n        )\n\n\n        =\n        Q\n\n\n        (\n        n\n        −\n        Q\n        (\n        n\n        −\n        1\n        )\n\n\n        )\n        +\n        Q\n\n\n        (\n        n\n        −\n        Q\n        (\n        n\n        −\n        2\n        )\n\n\n        )\n        ,\n\n        n\n        >\n        2.\n        {\\displaystyle {\\displaystyle {\\begin{aligned}Q(1)&=Q(2)=1,\\\\Q(n)&=Q{\\big (}n-Q(n-1){\\big )}+Q{\\big (}n-Q(n-2){\\big )},\\quad n>2.\\end{aligned}}}}\n\nIt is defined like the Fibonacci sequence, but whereas the next term in the Fibonacci sequence is the sum of the previous two terms, in the Q sequence the previous two terms tell you how far to go back in the Q sequence to find the two numbers to sum to make the next term of the sequence.\n\nTask\n\n* Confirm and display that the first ten terms of the sequence are: 1, 1, 2, 3, 3, 4, 5, 5, 6, and 6\n* Confirm and display that the 1000th term is:   502\n\nOptional extra credit\n\n* Count and display how many times a member of the sequence is less than its preceding term for terms up to and including the 100,000th term.\n* Ensure that the extra credit solution   *safely*   handles being initially asked for an **n**th term where   **n**   is large.\n\n(This point is to ensure that caching and/or recursion limits, if it is a concern, is correctly handled)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### OO solution\n\n**Works with**: rakudo version 2016.03\n\nSimilar concept as the perl5 solution, except that the cache is only filled on demand.\n\n```\nclass Hofstadter {\n  has @!c = 1,1;\n  method AT-POS ($me: Int $i) {\n    @!c.push($me[@!c.elems-$me[@!c.elems-1]] +\n\t     $me[@!c.elems-$me[@!c.elems-2]]) until @!c[$i]:exists;\n    return @!c[$i];\n  }\n}\n\n# Testing:\n\nmy Hofstadter $Q .= new();\n\nsay \"first ten: $Q[^10]\";\nsay \"1000th: $Q[999]\";\n\nmy $count = 0;\n$count++ if $Q[$_ +1 ] < $Q[$_] for  ^99_999;\nsay \"In the first 100_000 terms, $count terms are less than their preceding terms\";\n\n```\n\nOutput:\n\n```\nfirst ten: 1 1 2 3 3 4 5 5 6 6\n1000th: 502\nIn the first 100_000 terms, 49798 terms are less than their preceding terms\n```\n\n### Idiomatic solution\n\n**Works with**: rakudo version 2015-11-22\n\nWith a lazily generated array, we automatically get caching.\n\n```\nmy @Q = 1, 1, -> $a, $b {\n    (state $n = 1)++;\n    @Q[$n - $a] + @Q[$n - $b]\n} ... *;\n\n# Testing:\n\nsay \"first ten: \", @Q[^10];\nsay \"1000th: \", @Q[999];\nsay \"In the first 100_000 terms, \",\n   [+](@Q[1..100000] Z< @Q[0..99999]),\n   \" terms are less than their preceding terms\";\n\n```\n\n(Same output.)"}]}
{"messages": [{"role": "user", "content": "The definition of the sequence is colloquially described as:\n\n* Starting with the list [1,1],\n* Take the last number in the list so far: 1, I'll call it x.\n* Count forward x places from the beginning of the list to find the first number to add (1)\n* Count backward x places from the end of the list to find the second number to add (1)\n* Add the two indexed numbers from the list and the result becomes the next number in the list (1+1)\n* This would then produce [1,1,2] where 2 is the third element of the sequence.\n\nNote that indexing for the description above starts from alternately the left and right ends of the list and starts from an index of *one*.\n\nA less wordy description of the sequence is:\n\n```\n   a(1)=a(2)=1\n   a(n)=a(a(n-1))+a(n-a(n-1))\n\n```\n\nThe sequence begins:\n\n```\n   1, 1, 2, 2, 3, 4, 4, 4, 5, ...\n\n```\n\nInteresting features of the sequence are that:\n\n* a(n)/n   tends to   0.5   as   n   grows towards infinity.\n* a(n)/n   where   n   is a power of   2   is   0.5\n* For   n>4   the maximal value of   a(n)/n   between successive powers of 2 decreases.\n\na(n) / n   for   n   in   1..256\n\nThe sequence is so named because John Conway offered a prize of $10,000 to the first person who could\nfind the first position,   p   in the sequence where\n\n```\n   │a(n)/n│ < 0.55  for all  n > p\n\n```\n\nIt was later found that Hofstadter had also done prior work on the sequence.\n\nThe 'prize' was won quite quickly by Dr. Colin L. Mallows who proved the properties of the sequence and allowed him to find the value of   n   (which is much smaller than the 3,173,375,556 quoted in the NYT article).\n\nTask\n\n1. Create a routine to generate members of the Hofstadter-Conway $10,000 sequence.\n2. Use it to show the maxima of   a(n)/n   between successive powers of two up to   2\\*\\*20\n3. As a stretch goal:   compute the value of   n   that would have won the prize and confirm it is true for   n   up to 2\\*\\*20\n\nAlso see\n\n* Conways Challenge Sequence, Mallows' own account.\n* Mathworld Article."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\nNote that @a is a lazy array, and the Z variants are \"zipwith\" operators.\n\n```\nmy $n = 3;\nmy @a = (0,1,1, -> $p { @a[$p] + @a[$n++ - $p] } ... *);\n@a[2**20]; # pre-calculate sequence\n\nmy $last55;\nfor 1..19 -> $power {\n    my @range := 2**$power .. 2**($power+1)-1;\n    my @ratios = (@a[@range] Z/ @range) Z=> @range;\n    my $max = @ratios.max;\n    ($last55 = .value if .key >= .55 for @ratios) if $max.key >= .55;\n    say $power.fmt('%2d'), @range.min.fmt(\"%10d\"), '..', @range.max.fmt(\"%-10d\"),\n        $max.key, ' at ', $max.value;\n}\nsay \"Mallows' number would appear to be \", $last55;\n\n```\n\nOutput:\n\n```\n 1         2..3         0.666666666666667 at 3\n 2         4..7         0.666666666666667 at 6\n 3         8..15        0.636363636363636 at 11\n 4        16..31        0.608695652173913 at 23\n 5        32..63        0.590909090909091 at 44\n 6        64..127       0.576086956521739 at 92\n 7       128..255       0.567415730337079 at 178\n 8       256..511       0.559459459459459 at 370\n 9       512..1023      0.554937413073713 at 719\n10      1024..2047      0.550100874243443 at 1487\n11      2048..4095      0.547462892647566 at 2897\n12      4096..8191      0.544144747863964 at 5969\n13      8192..16383     0.542442708780362 at 11651\n14     16384..32767     0.540071097511587 at 22223\n15     32768..65535     0.538784020584256 at 45083\n16     65536..131071    0.537043656999866 at 89516\n17    131072..262143    0.536020067811561 at 181385\n18    262144..524287    0.534645431078112 at 353683\n19    524288..1048575   0.533779229963368 at 722589\nMallows' number would appear to be 1489\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCalculate the dates of:\n\n:   :   :   * Easter\n            * Ascension Thursday\n            * Pentecost\n            * Trinity Sunday\n            * Corpus Christi feast (for Catholic)\n            * All Saints' Sunday (for Orthodox)\n\nAs an example, calculate for the first year of each century from;\n\n:   :   :   * years     400   to   2100 CE   and for\n            * years   2010   to   2020 CE.\n\nNote\n\nFrom the year 325 CE on,   Easter Sunday   has been defined as the first Sunday *after* the first full moon *on or after* the day of the March equinox. However, the actual astronomical values for the moments of the full moon and equinox are not used. Instead, approximations are used, the first one being that the equinox is assumed to fall on March 21st every year. The tracking of the moon phases is similarly done with relatively straightforward arithmetic (compared to the sort required for astronomical accuracy) which amounts to maintaining a lunisolar calendar in parallel to our standard purely-solar one.\n\nWhen Pope Gregory reformed the Catholic calendar in 1582 CE, the drifting of Easter with respect to the seasons was the driving motivation, and the rules for determining it (called the *computus*) were altered to correct that drift. Catholic nations adopted both the new calendar and the new computus right away, while Western Protestant nations adopted them more gradually over the next 350 years or so. Eventually, even nations dominated by the Eastern Orthodox church adopted a similar calendar reform (the Revised Julian calendar), so pretty much the whole world agrees on what day it is for civil purposes. But the Eastern churches never adopted the corresponding Easter rule changes; they still use the original Julian calendar and computus to determine the date of what is known in the West as \"Orthodox Easter\". Therefore, your output should indicate which computus was used to calculate the dates and, at least for historical dates where the calendar can't be assumed or is location-dependent, which calendar those dates are given in.\n\nYou may find algorithms on the Computus Wikipedia page. Some of the results:\n\nIn the year 400 CE, Easter Sunday was April 1st (in the contemporary Julian calendar), making Ascension Thursday May 10th and Pentecost May 20th. It is ahistorical to give a date so far back for either Trinity Sunday or Corpus Christi, neither of which were observed until centuries later, but they would have been May 27th and 31st. If you extend the modern civil calendar back that far, those days are instead assigned the subsequent dates: Easter on April 2nd, Ascension on May 11th, Pentecost on May 21st.\n\nSkipping forward to the year 2100 CE, assuming the rules don't change between now and then, the Western churches will observe Easter on March 28, Ascension Thursday May 6th, Pentecost May 16th, Trinity Sunday May 23rd and Corpus Christi May 27th. Heading East, the Orthodox rules place Easter on April 18 in the original Julian calendar; the corresponding civil date is May 2nd. That puts the Ascension on June 10th and Pentecost June 20th. Orthodox Trinity Sunday is the same day as Pentecost, but they observe All Saints' Sunday the following week, June 27th. Corpus Christi is a purely Catholic date that has no Orthodox version.\n\nTest values of Easter dates\n\n| Year | Orthodox | Catholic | Calendar |\n| --- | --- | --- | --- |\n| 400 | 01 Apr | — | Jul. |\n| 800 | 19 Apr | — | Jul. |\n| 1200 | 09 Apr | — | Jul. |\n| 2000 | 30 Apr | 23 Apr | Gr. |\n| 2020 | 19 Apr | 12 Apr | Gr. |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nmy @abbr = < Nil Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec >;\n \nmy @holidays =\n    Easter    => 0,\n    Ascension => 39,\n    Pentecost => 49,\n    Trinity   => 56,\n    Corpus    => 60;\n \nsub easter($year) {\n    my \\ay = $year % 19;\n    my \\by = $year div 100;\n    my \\cy = $year % 100;\n    my \\dy = by div 4;\n    my \\ey = by % 4;\n    my \\fy = (by + 8) div 25;\n    my \\gy = (by - fy + 1) div 3;\n    my \\hy = (ay * 19 + by - dy - gy + 15) % 30;\n    my \\iy = cy div 4;\n    my \\ky = cy % 4;\n    my \\ly = (32 + 2 * ey + 2 * iy - hy - ky) % 7;\n    my \\md = hy + ly - 7 * ((ay + 11 * hy + 22 * ly) div 451) + 114;\n    my \\month = md div 31;\n    my \\day = md % 31 + 1;\n\n    return month, day;\n}\n \nsub cholidays($year) {\n    my ($emon, $eday) = easter($year);\n    printf \"%4s: \", $year;\n    say join ', ', gather for @holidays -> $holiday {\n\tmy $d = Date.new($year,$emon,$eday) + $holiday.value;\n\ttake \"{$holiday.key}: $d.day-of-month.fmt('%02s') @abbr[$d.month]\";\n    }\n}\n \nfor flat (400,500 ... 2000), (2010 ... 2020), 2100 -> $year {\n    cholidays($year);\n}\n\n```\n\nOutput:\n\n```\n 400: Easter: 02 Apr, Ascension: 11 May, Pentecost: 21 May, Trinity: 28 May, Corpus: 01 Jun\n 500: Easter: 04 Apr, Ascension: 13 May, Pentecost: 23 May, Trinity: 30 May, Corpus: 03 Jun\n 600: Easter: 13 Apr, Ascension: 22 May, Pentecost: 01 Jun, Trinity: 08 Jun, Corpus: 12 Jun\n 700: Easter: 15 Apr, Ascension: 24 May, Pentecost: 03 Jun, Trinity: 10 Jun, Corpus: 14 Jun\n 800: Easter: 23 Apr, Ascension: 01 Jun, Pentecost: 11 Jun, Trinity: 18 Jun, Corpus: 22 Jun\n 900: Easter: 28 Mar, Ascension: 06 May, Pentecost: 16 May, Trinity: 23 May, Corpus: 27 May\n1000: Easter: 30 Mar, Ascension: 08 May, Pentecost: 18 May, Trinity: 25 May, Corpus: 29 May\n1100: Easter: 08 Apr, Ascension: 17 May, Pentecost: 27 May, Trinity: 03 Jun, Corpus: 07 Jun\n1200: Easter: 09 Apr, Ascension: 18 May, Pentecost: 28 May, Trinity: 04 Jun, Corpus: 08 Jun\n1300: Easter: 18 Apr, Ascension: 27 May, Pentecost: 06 Jun, Trinity: 13 Jun, Corpus: 17 Jun\n1400: Easter: 20 Apr, Ascension: 29 May, Pentecost: 08 Jun, Trinity: 15 Jun, Corpus: 19 Jun\n1500: Easter: 01 Apr, Ascension: 10 May, Pentecost: 20 May, Trinity: 27 May, Corpus: 31 May\n1600: Easter: 02 Apr, Ascension: 11 May, Pentecost: 21 May, Trinity: 28 May, Corpus: 01 Jun\n1700: Easter: 11 Apr, Ascension: 20 May, Pentecost: 30 May, Trinity: 06 Jun, Corpus: 10 Jun\n1800: Easter: 13 Apr, Ascension: 22 May, Pentecost: 01 Jun, Trinity: 08 Jun, Corpus: 12 Jun\n1900: Easter: 15 Apr, Ascension: 24 May, Pentecost: 03 Jun, Trinity: 10 Jun, Corpus: 14 Jun\n2000: Easter: 23 Apr, Ascension: 01 Jun, Pentecost: 11 Jun, Trinity: 18 Jun, Corpus: 22 Jun\n2010: Easter: 04 Apr, Ascension: 13 May, Pentecost: 23 May, Trinity: 30 May, Corpus: 03 Jun\n2011: Easter: 24 Apr, Ascension: 02 Jun, Pentecost: 12 Jun, Trinity: 19 Jun, Corpus: 23 Jun\n2012: Easter: 08 Apr, Ascension: 17 May, Pentecost: 27 May, Trinity: 03 Jun, Corpus: 07 Jun\n2013: Easter: 31 Mar, Ascension: 09 May, Pentecost: 19 May, Trinity: 26 May, Corpus: 30 May\n2014: Easter: 20 Apr, Ascension: 29 May, Pentecost: 08 Jun, Trinity: 15 Jun, Corpus: 19 Jun\n2015: Easter: 05 Apr, Ascension: 14 May, Pentecost: 24 May, Trinity: 31 May, Corpus: 04 Jun\n2016: Easter: 27 Mar, Ascension: 05 May, Pentecost: 15 May, Trinity: 22 May, Corpus: 26 May\n2017: Easter: 16 Apr, Ascension: 25 May, Pentecost: 04 Jun, Trinity: 11 Jun, Corpus: 15 Jun\n2018: Easter: 01 Apr, Ascension: 10 May, Pentecost: 20 May, Trinity: 27 May, Corpus: 31 May\n2019: Easter: 21 Apr, Ascension: 30 May, Pentecost: 09 Jun, Trinity: 16 Jun, Corpus: 20 Jun\n2020: Easter: 12 Apr, Ascension: 21 May, Pentecost: 31 May, Trinity: 07 Jun, Corpus: 11 Jun\n2100: Easter: 28 Mar, Ascension: 06 May, Pentecost: 16 May, Trinity: 23 May, Corpus: 27 May\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Home prime. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn number theory, the **home prime HP(n)** of an integer **n** greater than 1 is the prime number obtained by repeatedly factoring the increasing concatenation of prime factors including repetitions.\n\nThe traditional notation has the prefix \"HP\" and a postfix count of the number of iterations until the home prime is found (if the count is greater than 0), for instance HP4(2) === HP22(1) === 211 is the same as saying the home prime of 4 needs 2 iterations and is the same as the home prime of 22 which needs 1 iteration, and (both) resolve to 211, a prime.\n\nPrime numbers are their own home prime;\n\nSo:\n\n```\n   HP2 = 2\n   \n   HP7 = 7\n\n```\n\nIf the integer obtained by concatenating increasing prime factors is not prime, iterate until you reach a prime number; the home prime.\n\n```\n   HP4(2) = HP22(1) = 211\n   HP4(2) = 2 × 2 => 22; HP22(1) = 2 × 11 => 211; 211 is prime  \n   \n   HP10(4) = HP25(3) = HP55(2) = HP511(1) = 773\n   HP10(4) = 2 × 5 => 25; HP25(3) = 5 × 5 => 55; HP55(2) = 5 × 11 => 511; HP511(1) = 7 × 73 => 773; 773 is prime  \n\n```\n\nTask\n\n* Find and show here, on this page, the home prime iteration chains for the integers 2 through 20 inclusive.\n\nStretch goal\n\n* Find and show the iteration chain for 65.\n\nImpossible goal\n\n* Show the the home prime for HP49.\n\nSee also\n\n* OEIS:A037274 - Home primes for n >= 2 * OEIS:A056938 - Concatenation chain for HP49"}, {"role": "assistant", "content": "Not the fastest, but not too bad either. Make an abortive attempt at HP49.\n\nAssuming there are n steps; HP49(n - 25) is slow, HP49(n - 31) is *really* slow, and I gave up on HP49(n - 34) after 45 minutes.\n\nUsing Prime::Factor from the Raku ecosystem.\n\n```\nuse Prime::Factor;\n\nmy $start = now;\n\n(flat 2..20, 65).map: -> $m {\n    my ($now, @steps, @factors) = now, $m;\n\n    @steps.push: @factors.join('_') while (@factors = prime-factors @steps[*-1].Int) > 1;\n\n    say (my $step = +@steps) > 1 ?? (@steps[0..*-2].map( { \"HP$_\\({--$step})\" } ).join: ' = ') !! (\"HP$m\"),\n      \" = \", @steps[*-1], \"  ({(now - $now).fmt(\"%0.3f\")} seconds)\";\n}\n\nsay \"Total elapsed time: {(now - $start).fmt(\"%0.3f\")} seconds\\n\";\n\nsay 'HP49:';\nmy ($now, @steps, @factors) = now, 49;\nmy $step = 0;\nwhile (@factors = prime-factors @steps[*-1].Int) > 1 {\n    @steps.push: @factors.join('_');\n    say \"HP{@steps[$step].Int}\\(n - {$step++}) = \", @steps[*-1], \"  ({(now - $now).fmt(\"%0.3f\")} seconds)\";\n    $now = now;\n    last if $step > 30;\n}\n\n```\n\nOutput:\n\n```\nHP2 = 2  (0.000 seconds)\nHP3 = 3  (0.000 seconds)\nHP4(2) = HP2_2(1) = 2_11  (0.001 seconds)\nHP5 = 5  (0.000 seconds)\nHP6(1) = 2_3  (0.000 seconds)\nHP7 = 7  (0.000 seconds)\nHP8(13) = HP2_2_2(12) = HP2_3_37(11) = HP3_19_41(10) = HP3_3_3_7_13_13(9) = HP3_11123771(8) = HP7_149_317_941(7) = HP229_31219729(6) = HP11_2084656339(5) = HP3_347_911_118189(4) = HP11_613_496501723(3) = HP97_130517_917327(2) = HP53_1832651281459(1) = 3_3_3_11_139_653_3863_5107  (0.014 seconds)\nHP9(2) = HP3_3(1) = 3_11  (0.000 seconds)\nHP10(4) = HP2_5(3) = HP5_5(2) = HP5_11(1) = 7_73  (0.001 seconds)\nHP11 = 11  (0.000 seconds)\nHP12(1) = 2_2_3  (0.000 seconds)\nHP13 = 13  (0.000 seconds)\nHP14(5) = HP2_7(4) = HP3_3_3(3) = HP3_3_37(2) = HP47_71(1) = 13_367  (0.001 seconds)\nHP15(4) = HP3_5(3) = HP5_7(2) = HP3_19(1) = 11_29  (0.001 seconds)\nHP16(4) = HP2_2_2_2(3) = HP2_11_101(2) = HP3_11_6397(1) = 3_163_6373  (0.001 seconds)\nHP17 = 17  (0.000 seconds)\nHP18(1) = 2_3_3  (0.000 seconds)\nHP19 = 19  (0.000 seconds)\nHP20(15) = HP2_2_5(14) = HP3_3_5_5(13) = HP5_11_61(12) = HP11_4651(11) = HP3_3_12739(10) = HP17_194867(9) = HP19_41_22073(8) = HP709_273797(7) = HP3_97_137_17791(6) = HP11_3610337981(5) = HP7_3391_4786213(4) = HP3_3_3_3_7_23_31_1815403(3) = HP13_17_23_655857429041(2) = HP7_7_2688237874641409(1) = 3_31_8308475676071413  (0.020 seconds)\nHP65(19) = HP5_13(18) = HP3_3_3_19(17) = HP11_13_233(16) = HP11_101203(15) = HP3_3_23_53629(14) = HP3_3_1523_24247(13) = HP3_3_3_7_47_3732109(12) = HP11_18013_16843763(11) = HP151_740406071813(10) = HP3_13_13_54833_5458223(9) = HP3_3_97_179_373_7523_71411(8) = HP1571_1601_1350675311441(7) = HP3_3_13_33391_143947_279384649(6) = HP11_23_204069263_6417517893491(5) = HP7_11_1756639_83039633268945697(4) = HP29_29_5165653_13503983_12122544283(3) = HP228345060379_1282934064985326977(2) = HP3_3_3_2979253_3030445387_9367290955541(1) = 1381_3211183211_75157763339900357651  (6.686 seconds)\nTotal elapsed time: 6.737 seconds\n\nHP49:\nHP49(n - 0) = 7_7  (0.000 seconds)\nHP77(n - 1) = 7_11  (0.000 seconds)\nHP711(n - 2) = 3_3_79  (0.000 seconds)\nHP3379(n - 3) = 31_109  (0.000 seconds)\nHP31109(n - 4) = 13_2393  (0.000 seconds)\nHP132393(n - 5) = 3_44131  (0.000 seconds)\nHP344131(n - 6) = 17_31_653  (0.000 seconds)\nHP1731653(n - 7) = 7_11_43_523  (0.000 seconds)\nHP71143523(n - 8) = 11_11_577_1019  (0.000 seconds)\nHP11115771019(n - 9) = 311_35742029  (0.000 seconds)\nHP31135742029(n - 10) = 7_17_261644891  (0.000 seconds)\nHP717261644891(n - 11) = 11_19_3431873899  (0.002 seconds)\nHP11193431873899(n - 12) = 11_613_4799_345907  (0.001 seconds)\nHP116134799345907(n - 13) = 3_204751_189066719  (0.001 seconds)\nHP3204751189066719(n - 14) = 3_1068250396355573  (0.003 seconds)\nHP31068250396355573(n - 15) = 621611_49980213343  (0.005 seconds)\nHP62161149980213343(n - 16) = 3_3_6906794442245927  (0.006 seconds)\nHP336906794442245927(n - 17) = 73_4615161567701999  (0.009 seconds)\nHP734615161567701999(n - 18) = 3_13_18836286194043641  (0.009 seconds)\nHP31318836286194043641(n - 19) = 3_3_3_43_14369_161461_11627309  (0.004 seconds)\nHP333431436916146111627309(n - 20) = 3_32057_1618455677_2142207827  (0.153 seconds)\nHP33205716184556772142207827(n - 21) = 3_1367_2221_5573_475297_1376323127  (0.006 seconds)\nHP31367222155734752971376323127(n - 22) = 7_3391_51263_25777821480557336017  (0.003 seconds)\nHP733915126325777821480557336017(n - 23) = 47_67_347_431_120361987_12947236602187  (0.043 seconds)\nHP476734743112036198712947236602187(n - 24) = 3_7_7_17_12809_57470909_57713323_4490256751  (0.124 seconds)\nHP377171280957470909577133234490256751(n - 25) = 3096049809383_121823389214993262890297  (27.913 seconds)\nHP3096049809383121823389214993262890297(n - 26) = 7_379_62363251_18712936424989555929478399  (0.132 seconds)\nHP73796236325118712936424989555929478399(n - 27) = 13_1181_145261411_33089538087518197265265053  (0.034 seconds)\nHP13118114526141133089538087518197265265053(n - 28) = 3_19_521_441731977174163487542111577539726749  (0.002 seconds)\nHP319521441731977174163487542111577539726749(n - 29) = 59_5415617656474189392601483764603009147911  (0.002 seconds)\nHP595415617656474189392601483764603009147911(n - 30) = 13_8423_1466957_3706744784027901056001426046777  (0.015 seconds)\n```"}]}
{"messages": [{"role": "user", "content": "A Honaker prime is a prime whose digital sum is equal to the digital sum of its position in the sequence of primes.\n\nE.G.\n\nIf you look at the sequence of positive integer primes the first prime is **2** at position **1**. The digital sums of **2** and **1** are not equal, so **2** is **not** a Honaker prime. The prime at position **32**: **131** *is* a Honaker prime. The digital sum of **32** (**5**) is equal to the digital sum of **131** (**5**).\n\nTask\n\n* Write a routine (procedure, function, filter, whatever it may be called in your language) to identify Honaker primes.\n* Use that routine to find the first fifty Honaker primes and display the position and value for each.\n\nStretch\n\n* Find and display the ten thousandth Honaker prime (position and value).\n\nSee also\n\n* OEIS:A033548 - Honaker primes * Numbers Aplenty - Honaker primes"}, {"role": "assistant", "content": "```\nmy @honaker = lazy (^∞).hyper.grep(&is-prime).kv.grep: (1 + *).comb.sum == *.comb.sum;\n\nsay \"First 50 Honaker primes (index, prime):\\n\" ~ @honaker[^50].map(&format).batch(5).join: \"\\n\";\nsay \"\\nTen thousandth: \" ~ @honaker[9999].&format;\n\nsub format ($_) { sprintf \"(%3d, %4d)\", 1 + .[0], .[1] }\n\n```\n\nOutput:\n\n```\nFirst 50 Honaker primes (index, prime):\n( 32,  131) ( 56,  263) ( 88,  457) (175, 1039) (176, 1049)\n(182, 1091) (212, 1301) (218, 1361) (227, 1433) (248, 1571)\n(293, 1913) (295, 1933) (323, 2141) (331, 2221) (338, 2273)\n(362, 2441) (377, 2591) (386, 2663) (394, 2707) (397, 2719)\n(398, 2729) (409, 2803) (439, 3067) (446, 3137) (457, 3229)\n(481, 3433) (499, 3559) (508, 3631) (563, 4091) (571, 4153)\n(595, 4357) (599, 4397) (635, 4703) (637, 4723) (655, 4903)\n(671, 5009) (728, 5507) (751, 5701) (752, 5711) (755, 5741)\n(761, 5801) (767, 5843) (779, 5927) (820, 6301) (821, 6311)\n(826, 6343) (827, 6353) (847, 6553) (848, 6563) (857, 6653)\n\nTen thousandth: (286069, 4043749)\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a program that calculates the hour, sun hour angle, dial hour line angle from 6am to 6pm for an *operator* entered location.\n\nFor example, the user is prompted for a location and inputs the latitude and longitude 4°57′S 150°30′W (4.95°S 150.5°W of Jules Verne's *Lincoln Island*, aka *Ernest Legouve Reef)*, with a legal meridian of 150°W.\n\n(Note: the \"meridian\" is approximately the same concept as the \"longitude\" - the distinction is that the meridian is used to determine when it is \"noon\" for official purposes. This will typically be slightly different from when the sun appears at its highest location, because of the structure of time zones. For most, but not all, time zones (hour wide zones with hour zero centred on Greenwich), the legal meridian will be an even multiple of 15 degrees.)\n\nWikipedia: A sundial is a device that measures time by the position of the Sun. In common designs such as the horizontal sundial, the sun casts a shadow from its *style* (also called its Gnomon, a thin rod or a sharp, straight edge) onto a flat surface marked with lines indicating the hours of the day (also called the dial face or dial plate). As the sun moves across the sky, the shadow-edge progressively aligns with different hour-lines on the plate. Such designs rely on the style being aligned with the axis of the Earth's rotation. Hence, if such a sundial is to tell the correct time, the style must point towards true north (not the north or south magnetic pole) and the style's angle with horizontal must equal the sundial's geographical latitude."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub postfix:<°> ($a) { $a * pi / 180 } # degrees to radians\nsub postfix:<®> ($a) { $a * 180 / pi } # radians to degrees\n\nmy $latitude  = prompt 'Enter latitude       => ';\nmy $longitude = prompt 'Enter longitude      => ';\nmy $meridian  = prompt 'Enter legal meridian => ';\n\nmy $lat_sin = sin( $latitude° );\nsay 'Sine of latitude: ', $lat_sin.fmt(\"%.4f\"); \nsay 'Longitude offset: ', my $offset = $meridian - $longitude;\nsay '=' x 48;\nsay ' Hour  : Sun hour angle° : Dial hour line angle°'; \n\nfor -6 .. 6 -> $hour {\n    my $sun_deg  = $hour * 15 + $offset;\n    my $line_deg = atan2( ( sin($sun_deg°) * $lat_sin ), cos($sun_deg°) )®;\n    printf \"%2d %s      %7.3f             %7.3f\\n\",\n    ($hour + 12) % 12 || 12, ($hour < 0 ?? 'AM' !! 'PM'), $sun_deg, $line_deg;\n}\n\n```\n\nExample output:\n\n```\nEnter latitude       => -4.95\nEnter longitude      => -150.5\nEnter legal meridian => -150\nSine of latitude: -0.0863\nLongitude offset: 0.5\n================================================\n Hour  : Sun hour angle° : Dial hour line angle°\n 6 AM      -89.500              84.225\n 7 AM      -74.500              17.283\n 8 AM      -59.500               8.334\n 9 AM      -44.500               4.847\n10 AM      -29.500               2.795\n11 AM      -14.500               1.278\n12 PM        0.500              -0.043\n 1 PM       15.500              -1.371\n 2 PM       30.500              -2.910\n 3 PM       45.500              -5.018\n 4 PM       60.500              -8.671\n 5 PM       75.500             -18.451\n 6 PM       90.500             -95.775\n\n```"}]}
{"messages": [{"role": "user", "content": "A fast scheme for evaluating a polynomial such as:\n\n:   −\n    19\n    +\n    7\n    x\n    −\n    4\n\n    x\n\n    2\n    +\n    6\n\n    x\n\n    3\n\n    {\\displaystyle {\\displaystyle -19+7x-4x^{2}+6x^{3}\\,}}\n\nwhen\n\n:   x\n    =\n    3\n\n    {\\displaystyle {\\displaystyle x=3\\;}}\n    .\n\nis to arrange the computation as follows:\n\n:   (\n    (\n    (\n    (\n    0\n    )\n    x\n    +\n    6\n    )\n    x\n    +\n    (\n    −\n    4\n    )\n    )\n    x\n    +\n    7\n    )\n    x\n    +\n    (\n    −\n    19\n    )\n\n    {\\displaystyle {\\displaystyle ((((0)x+6)x+(-4))x+7)x+(-19)\\;}}\n\nAnd compute the result from the innermost brackets outwards as in this pseudocode:\n\n```\ncoefficients := [-19, 7, -4, 6] # list coefficients of all x^0..x^n in order\nx := 3\naccumulator := 0\nfor i in length(coefficients) downto 1 do\n    # Assumes 1-based indexing for arrays\n    accumulator := ( accumulator * x ) + coefficients[i]\ndone\n# accumulator now has the answer\n\n```\n\n**Task Description**\n\n:   Create a routine that takes a list of coefficients of a polynomial in order of increasing powers of x; together with a value of x to compute its value at, and return the value of the polynomial at that value using Horner's rule.\n\nCf. Formal power series"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub horner ( @coeffs, $x ) {\n    @coeffs.reverse.reduce: { $^a * $x + $^b };\n}\n\nsay horner( [ -19, 7, -4, 6 ], 3 );\n\n```\n\nHere is a recursive version :\n\n```\nmulti horner(@c, $x) {\n    @c > 1 ?? @c.head + $x * samewith(@c.tail(*-1), $x) !! @c.pick\n}\n \nsay horner( [-19, 7, -4, 6 ], 3 );\n\n```\n\nWe can also use the composition operator:\n\n```\nsub horner ( @coeffs, $x ) {\n    ([o] map { $_ + $x * * }, @coeffs)(0);\n}\n \nsay horner( [ -19, 7, -4, 6 ], 3 );\n\n```\n\nOutput:\n\n```\n128\n```\n\nOne advantage of using the composition operator is that it allows for the use of an infinite list of coefficients.\n\n```\nsub horner ( @coeffs, $x ) {\n    map { .(0) }, [\\o] map { $_ + $x * * }, @coeffs;\n}\n \nsay horner( [ 1 X/ (1, |[\\*] 1 .. *) ], i*pi )[20];\n\n```\n\nOutput:\n\n```\n-0.999999999924349-5.28918515954219e-10i\n```"}]}
{"messages": [{"role": "user", "content": "Background\n\nIn three recent races at Rosetta Park, the results have been:\n\n*Race 1*\n\n| Pos | Horse | Weight | Dist | Sex |\n| --- | --- | --- | --- | --- |\n| 1 | A | 9.00 | 0.0 | Colt |\n| 2 | B | 8.06 | 2.0 | Filly |\n| 3 | C | 9.04 | 1.5 | Colt |\n\nTime 1 minute 36.0 seconds\n\n*Race 2*\n\n| Pos | Horse | Weight | Dist | Sex |\n| --- | --- | --- | --- | --- |\n| 1 | D | 8.10 | 0.0 | Filly |\n| 2 | E | 9.03 | 1.0 | Colt |\n| 3 | F | 9.07 | 3.0 | Colt |\n\n(F was slowly away and lost 2 lengths at the finish as a result)\n\nTime 1 minute 36.4 seconds\n\n*Race 3*\n\n| Pos | Horse | Weight | Dist | Sex |\n| --- | --- | --- | --- | --- |\n| 1 | G | 8.04 | 0.0 | Colt |\n| 2 | H | 8.10 | 1.5 | Colt |\n| 3 | I | 9.05 | 0.5 | Filly |\n\nTime 1 minute 35.8 seconds\n\nIt is assumed that:\n\n1. Weights carried are expressed in stones and pounds (traditional in US and UK racing) where 1 stone equals 14 pounds.\n\n2. The distances are the actual distances between horses at the finish of the race.\n\n3. All races are run at 1 mile in similar going and weather conditions and the time shown is the time taken by the winner to run the race.\n\n4. 2 pounds slows a horse down by 1 length at the finish.\n\n5. 1 second is equivalent to 5 lengths at the finish.\n\nTask\n\nAll 9 of these horses, plus a further horse J, are due to compete against each other in Race 4 at Rosetta Park again over 1 mile and in similar conditions to the earlier races. Colts will carry 9.00 and fillies 8.11.\n\nSuppose that:\n\n1. Horse B has been moving well on the galops and her trainer thinks she has improved 4 pounds since her last outing.\n\n2. Horse C has had a setback in training and his trainer expects him to perform 4 pounds below his best.\n\n3. Horse H is being ridden by the champion jockey which is expected to improve his performance by 3 pounds compared to what it would otherwise have been.\n\n4. Horse J, a filly, has never run before but her performance on the galops suggests she can run 1 mile in 1 minute 35.8 seconds when carrying 8.11.\n\nOther things being equal (which they seldom are in actual horse racing!) what would you ***expect*** the **full result** of Race 4 to be including the **time** of the winner?"}, {"role": "assistant", "content": "I know nothing about horse racing and/or handicapping. This is mostly a straightforward translation of the logic from Go though I did take certain liberties with formatting and layout.\n\n```\nmy %card;\n%card<a> = { name => 'Alberta Clipper',       :sex<M>, rating => 100 };\n%card<b> = { name => 'Beetlebaum',            :sex<F>, rating => %card<a><rating> - 8 - 2*2 };\n%card<c> = { name => 'Canyonero',             :sex<M>, rating => %card<a><rating> + 4 - 2*3.5 };\n%card<d> = { name => 'Donnatello',            :sex<F>, rating => %card<a><rating> - 4 - 10*0.4 };\n%card<e> = { name => 'Exterminator',          :sex<M>, rating => %card<d><rating> + 7 - 2*1 };\n%card<f> = { name => 'Frequent Flyer',        :sex<M>, rating => %card<d><rating> + 11 - 2*(4-2) };\n%card<g> = { name => 'Grindstone',            :sex<M>, rating => %card<a><rating> - 10 + 10*0.2 };\n%card<h> = { name => 'His Honor',             :sex<M>, rating => %card<g><rating> + 6 - 2*1.5 };\n%card<i> = { name => 'Iphigenia in Brooklyn', :sex<F>, rating => %card<g><rating> + 15 - 2*2 };\n%card<j> = { name => 'Josephine',             :sex<F>, rating => Nil };\n\n# adjustments to ratings for current race\n%card<b><rating> += 4;\n%card<c><rating> -= 4;\n%card<h><rating> += 3;\n%card<j><rating> = %card<a><rating> - 3 + 10*0.2;\n\n# adjust filly's allowance\n# initialize carry weights\nfor %card {\n    .value<rating> += 3 if .value<sex> eq 'F';\n    .value<weight> = (.value<sex> eq 'M') ?? 9.00 !! 8.11\n}\n\nmy ($previous, $position, $leader) = 0;\nsay \"Pos Horse         Name           Weight   Back    Sex    Time\";\n\nfor %card.sort( -*.value.<rating> ) {\n    FIRST $leader = $_;\n    ++$position if $previous != .value.<rating>;\n    $previous = .value.<rating>;\n    .value<back> = ($leader.value<rating> - .value<rating>) / 2;\n    .value<time> = 96 - (.value.<rating> - 100) / 10;\n    printf \"%2d    %s   %-22s  %.2f    %.1f    %-6s %s\\n\", $position, .key, .value<name>, .value<weight>,\n      .value<back>, .value<sex> eq 'M' ?? 'colt' !! 'filly', .value.<time>.polymod(60 xx*).reverse.join: ':';\n}\n\n```\n\nOutput:\n\n```\nPos Horse         Name           Weight   Back    Sex    Time\n 1    i   Iphigenia in Brooklyn   8.11    0.0    filly  1:35.4\n 2    j   Josephine               8.11    2.0    filly  1:35.8\n 3    a   Alberta Clipper         9.00    3.0    colt   1:36\n 4    f   Frequent Flyer          9.00    3.5    colt   1:36.1\n 5    h   His Honor               9.00    4.0    colt   1:36.2\n 6    e   Exterminator            9.00    4.5    colt   1:36.3\n 7    d   Donnatello              8.11    5.5    filly  1:36.5\n 7    b   Beetlebaum              8.11    5.5    filly  1:36.5\n 8    c   Canyonero               9.00    6.5    colt   1:36.7\n 9    g   Grindstone              9.00    7.0    colt   1:36.8\n```"}]}
{"messages": [{"role": "user", "content": "Print the word size and endianness of the host machine.\n\nSee also: Variable size/Get"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nEndian detection translated from C.\n\n**Works with**: Rakudo version 2018.03\n\n```\nuse NativeCall;\nsay $*VM.config<ptr_size>;\nmy $bytes = nativecast(CArray[uint8], CArray[uint16].new(1));\nsay $bytes[0] ?? \"little-endian\" !! \"big-endian\";\n\n```\n\nOutput:\n\n```\n8\nlittle-endian\n```\n\nNote: Rakudo 2018.12 is introducing the endian-sensitive`read-int16` method,\nwhich makes endian detection a little easier:\n\n```\nsay blob8.new(1,0).read-int16(0) == 1 ?? \"little-endian\" !! \"big-endian\"\n\n```\n\nIn Rakudo 2019.01 the dynamic KERNEL variable was fleshed out with a bunch of accessors, among them:\n\n```\nsay join ', ', $*KERNEL, $*KERNEL.bits, $*KERNEL.arch, $*KERNEL.endian\n\n```\n\nOutput:\n\n```\nlinux, 64, x86_64, LittleEndian\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind the name of the host on which the routine is running."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $host = qx[hostname];\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement the Hough transform, which is used as part of feature extraction with digital images.\n\nIt is a tool that makes it far easier to identify straight lines in the source image, whatever their orientation.\n\nThe transform maps each point in the target image, \n\n(\nρ\n,\nθ\n)\n{\\displaystyle {\\displaystyle (\\rho ,\\theta )}}\n, to the average color of the pixels on the corresponding line of the source image (in \n\n(\nx\n,\ny\n)\n{\\displaystyle {\\displaystyle (x,y)}}\n-space, where the line corresponds to points of the form \n\nx\ncos\n⁡\nθ\n+\ny\nsin\n⁡\nθ\n=\nρ\n{\\displaystyle {\\displaystyle x\\cos \\theta +y\\sin \\theta =\\rho }}\n). The idea is that where there is a straight line in the original image, it corresponds to a bright (or dark, depending on the color of the background field) spot; by applying a suitable filter to the results of the transform, it is possible to extract the locations of the lines in the original image.\n\nSample PNG image to use for the Hough transform.\n\nThe target space actually uses polar coordinates, but is conventionally plotted on rectangular coordinates for display. There's no specification of exactly how to map polar coordinates to a flat surface for display, but a convenient method is to use one axis for \n\nθ\n{\\displaystyle {\\displaystyle \\theta }}\n and the other for \n\nρ\n{\\displaystyle {\\displaystyle \\rho }}\n, with the center of the source image being the origin.\n\nThere is also a spherical Hough transform, which is more suited to identifying planes in 3D data."}, {"role": "assistant", "content": "(formerly Perl 6)\nThe `GD` module the output palette to 255 colors, so only transform darker pixels in the image.\n\n**Translation of**: Perl\n\n```\nuse GD;\n\nmy $filename = 'pentagon.ppm';\nmy $in = open($filename, :r, :enc<iso-8859-1>);\nmy ($type, $dim, $depth) = $in.lines[^3];\nmy ($xsize,$ysize) = split ' ', $dim;\n\nmy ($width, $height) = 460, 360;\nmy $image = GD::Image.new($width, $height);\n\nmy @canvas = [255 xx $width] xx $height;\n\nmy $rmax = sqrt($xsize**2 + $ysize**2);\nmy $dr   = 2 * $rmax / $height;\nmy $dth  = π / $width;\n\nmy $pixel = 0;\nmy %cstore;\nfor $in.lines.ords -> $r, $g, $b {\n    $pixel++;\n    next if $r > 130;\n\n    my $x =       $pixel % $xsize;\n    my $y = floor $pixel / $xsize;\n\n    (^$width).map: -> $k {\n        my $th = $dth*$k;\n        my $r = ($x*cos($th) + $y*sin($th));\n        my $iry = ($height/2 + ($r/$dr).round(1)).Int;\n        my $c = '#' ~ (@canvas[$iry][$k]--).base(16) x 3;\n        %cstore{$c} = $image.colorAllocate($c) if %cstore{$c}:!exists;\n        $image.pixel($k, $iry, %cstore{$c});\n    }\n}\n\nmy $png_fh = $image.open(\"hough-transform.png\", \"wb\");\n$image.output($png_fh, GD_PNG);\n$png_fh.close;\n\n```\n\nSee Hough Transform (offsite .png image)"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven two hourglasses of   **4**   minutes and   **7**   minutes,   the task is to measure   **9**   minutes.\n\nNotes\n\nImplemented as a 1-player game."}, {"role": "assistant", "content": "```\n# 20201230 Raku programming solution\n\nmy @hourglasses = 4, 7;\nmy $target = 9;\nmy @output = [];\nmy %elapsed = 0 => 1 ;\nmy $done = False ;\n\nfor 1 .. ∞ -> $t {\n   my $flip-happened = False;\n   for @hourglasses -> $hg {\n      unless $t % $hg {\n         %elapsed{$t} = 1 unless %elapsed{$t};\n         with @output[$t] { $_ ~= \"\\t, flip hourglass $hg \" } else {\n            $_ = \"At time t = $t , flip hourglass $hg\" }\n         $flip-happened = True\n      }\n   }\n   if $flip-happened {\n      for %elapsed.keys.sort -> $t1 {\n         if ($t - $t1) == $target {\n            @output[$t1] ~= \"\\tbegin = 0\";\n            @output[$t]  ~= \"\\tend   = $target\";\n            $done = True\n         }\n         %elapsed{$t} = 1 unless %elapsed{$t} ;\n      }\n   }\n   last if $done\n}\n\n.say if .defined for @output\n\n```\n\nOutput:\n\n```\nAt time t = 4 , flip hourglass 4\nAt time t = 7 , flip hourglass 7        begin = 0\nAt time t = 8 , flip hourglass 4\nAt time t = 12 , flip hourglass 4\nAt time t = 14 , flip hourglass 7\nAt time t = 16 , flip hourglass 4       end   = 9\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nAccess and print a URL's content (the located resource) to the console.\n\nThere is a separate task for HTTPS Requests."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Library:** LWP\n\nUsing LWP::Simple from the Raku ecosystem.\n\n```\nuse LWP::Simple;\n\nprint LWP::Simple.get(\"http://www.rosettacode.org\");\n```\n\nor, without LWP::Simple:\n\n```\nmy $socket = IO::Socket::INET.new(host => \"www.rosettacode.org\",\n\t\t\t\t  port => 80,);\n$socket.print(\"GET / HTTP/1.0\\r\\n\\r\\n\");\nprint $socket.recv();\n$socket.close;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSend a GET request to obtain the resource located at the URL \"https://www.w3.org/\", then print it to the console.  \nChecking the host certificate for validity is recommended.  \nDo not authenticate. That is the subject of other tasks.  \nReaders may wish to contrast with the HTTP Request task, and also the task on HTTPS request with authentication."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nThere are several modules that provide HTTPS capability. WWW and HTTP::UserAgent are probably the most popular right now, but others exist.\n\n```\nuse WWW;\nsay get 'https://sourceforge.net/';\n\n```\n\nor\n\n```\nuse HTTP::UserAgent;\nsay HTTP::UserAgent.new.get('https://sourceforge.net/').content;\n\n```"}]}
{"messages": [{"role": "user", "content": "The goal of this task is to demonstrate HTTPS requests with authentication.\nImplementations of this task should not use client certificates for this: that is the subject of another task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nUsed here to connect to my local wireless router to a page that is password protected. Obviously not going to be generally publicly accessible but should be easily adaptable to other sites / devices.\n\n```\nuse HTTP::UserAgent;\n\nmy $username = 'username'; # my username\nmy $password = 'password'; # my password\nmy $address  = 'http://192.168.1.1/Status_Router.asp'; # my local wireless router\n\nmy $ua = HTTP::UserAgent.new;\n$ua.auth( $username, $password );\nmy $response = $ua.get: $address;\nsay $response.is-success ?? $response.content !! $response.status-line;\n\n```"}]}
{"messages": [{"role": "user", "content": "Demonstrate how to connect to a web server over HTTPS where that server requires that the client present a certificate to prove who (s)he is. Unlike with the HTTPS request with authentication task, it is *not* acceptable to perform the authentication by a username/password or a set cookie.\n\nThis task is in general useful for use with webservice clients as it offers a high level of assurance that the client is an acceptable counterparty for the server. For example, Amazon Web Services uses this style of authentication."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# cert creation commands\n\n# openssl req -newkey rsa:4096 -keyout my_key.pem -out my_csr.pem -nodes -subj \"/CN=ME\"\n\n# openssl x509 -req -in my_csr.pem -signkey my_key.pem -out my_cert.pem\n\nuse v6;\nuse OpenSSL;\n\nmy $host = \"github.com\";\n\nmy $ssl = OpenSSL.new(:client);\n\n$ssl.use-certificate-file(\"./my_cert.pem\");\n$ssl.use-privatekey-file(\"./my_key.pem\");\n$ssl.check-private-key;\n\n\nmy $s = IO::Socket::INET.new(:$host, :port(443));\n\n$ssl.set-socket($s);\n$ssl.set-connect-state;\n$ssl.connect;\n$ssl.write(\"GET / HTTP/1.1\\r\\n\\r\\n\");\nsay $ssl.read(1024);\n$ssl.close;\n$s.close;\n\n```"}]}
{"messages": [{"role": "user", "content": "Huffman encoding is a way to assign binary codes to symbols that reduces the overall number of bits used to encode a typical string of those symbols.\n\nFor example, if you use letters as symbols and have details of the frequency of occurrence of those letters in typical strings, then you could just encode each letter with a fixed number of bits, such as in ASCII codes. You can do better than this by encoding more frequently occurring letters such as e and a, with smaller bit strings; and less frequently occurring letters such as q and x with longer bit strings.\n\nAny string of letters will be encoded as a string of bits that are no-longer of the same length per letter. To successfully decode such as string, the smaller codes assigned to letters such as 'e' cannot occur as a prefix in the larger codes such as that for 'x'.\n\n:   If you were to assign a code 01 for 'e' and code 011 for 'x', then if the bits to decode started as 011... then you would not know if you should decode an 'e' or an 'x'.\n\nThe Huffman coding scheme takes each symbol and its weight (or frequency of occurrence), and generates proper encodings for each symbol taking account of the weights of each symbol, so that higher weighted symbols have fewer bits in their encoding. (See the WP article for more information).\n\nA Huffman encoding can be computed by first creating a tree of nodes:\n\n1. Create a leaf node for each symbol and add it to the priority queue.\n2. While there is more than one node in the queue:\n   1. Remove the node of highest priority (lowest probability) twice to get two nodes.\n   2. Create a new internal node with these two nodes as children and with probability equal to the sum of the two nodes' probabilities.\n   3. Add the new node to the queue.\n3. The remaining node is the root node and the tree is complete.\n\nTraverse the constructed binary tree from root to leaves assigning and accumulating a '0' for one branch and a '1' for the other at each node. The accumulated zeros and ones at each leaf constitute a Huffman encoding for those symbols and weights:\n\nTask\n\nUsing the characters and their frequency from the string:\n\n:   :   :   :   :   ***this is an example for huffman encoding***\n\ncreate a program to generate a Huffman encoding for each character as a table."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### By building a tree\n\nThis version uses nested `Array`s to build a tree like shown in this diagram, and then recursively traverses the finished tree to accumulate the prefixes.\n\n**Works with**: rakudo version 2015-12-17\n\n```\nsub huffman (%frequencies) {\n    my @queue = %frequencies.map({ [.value, .key] }).sort;\n    while @queue > 1 {\n        given @queue.splice(0, 2) -> ([$freq1, $node1], [$freq2, $node2]) {\n            @queue = (|@queue, [$freq1 + $freq2, [$node1, $node2]]).sort;\n        }\n    }\n    hash gather walk @queue[0][1], '';\n}\n\nmulti walk ($node,            $prefix) { take $node => $prefix; }\nmulti walk ([$node1, $node2], $prefix) { walk $node1, $prefix ~ '0';\n                                         walk $node2, $prefix ~ '1'; }\n\n```\n\n### Without building a tree\n\nThis version uses an `Array` of `Pair`s to implement a simple priority queue. Each value of the queue is a `Hash` mapping from letters to prefixes, and when the queue is reduced the hashes are merged on-the-fly, so that the last one remaining is the wanted Huffman table.\n\n**Works with**: rakudo version 2015-12-17\n\n```\nsub huffman (%frequencies) {\n    my @queue = %frequencies.map: { .value => (hash .key => '') };\n    while @queue > 1 {\n        @queue.=sort;\n        my $x = @queue.shift;\n        my $y = @queue.shift;\n        @queue.push: ($x.key + $y.key) => hash $x.value.deepmap('0' ~ *),\n                                               $y.value.deepmap('1' ~ *);\n    }\n    @queue[0].value;\n}\n\n# Testing\n\nfor huffman 'this is an example for huffman encoding'.comb.Bag {\n    say \"'{.key}' : {.value}\";\n}\n\n# To demonstrate that the table can do a round trip:\n\nsay '';\nmy $original = 'this is an example for huffman encoding';\n\nmy %encode-key = huffman $original.comb.Bag;\nmy %decode-key = %encode-key.invert;\nmy @codes      = %decode-key.keys;\n\nmy $encoded = $original.subst: /./,      { %encode-key{$_} }, :g;\nmy $decoded = $encoded .subst: /@codes/, { %decode-key{$_} }, :g;\n\n.say for $original, $encoded, $decoded;\n\n```\n\nOutput:\n\n```\n'x' : 11000\n'p' : 01100\n'h' : 0001\n'g' : 00000\n'a' : 1001\n'e' : 1101\n'd' : 110011\n's' : 0111\n'f' : 1110\n'c' : 110010\n'm' : 0010\n' ' : 101\n'n' : 010\n'o' : 0011\n'u' : 10001\n't' : 10000\n'i' : 1111\n'r' : 01101\n'l' : 00001\n\nthis is an example for huffman encoding\n1000000011111011110111110111101100101010111011100010010010011000000111011011110001101101101000110001111011100010100101010111010101100100011110011111101000000\nthis is an example for huffman encoding\n```"}]}
{"messages": [{"role": "user", "content": "Humble numbers are positive integers which have   no   prime factors    >    **7**.\n\nHumble numbers are also called   *7-smooth numbers*,   and sometimes called   *highly composite*,\n  \nalthough this conflicts with another meaning of   *highly composite numbers*.\n\nAnother way to express the above is:\n\n```\n  humble  =  2i × 3j × 5k × 7m \n\n```\n\n```\n           where     i, j, k, m ≥ 0 \n\n```\n\nTask\n:   * show the first   **50**   humble numbers   (in a horizontal list)\n    * show the number of humble numbers that have   **x**   decimal digits for all   **x's**   up to   **n**   (inclusive).\n    * show   (as many as feasible or reasonable for above)   on separate lines\n    * show all output here on this page\n\nRelated tasks\n:   * Hamming numbers\n\nReferences\n:   * Wikipedia: Smooth numbers, see the 2nd paragraph.\n    * OEIS A002473: humble numbers\n    * University of Ulm, The first 5842 terms of humble numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\n```\nsub smooth-numbers (*@list) {\n    cache my \\Smooth := gather {\n        my %i = (flat @list) Z=> (Smooth.iterator for ^@list);\n        my %n = (flat @list) Z=> 1 xx *;\n\n        loop {\n            take my $n := %n{*}.min;\n\n            for @list -> \\k {\n                %n{k} = %i{k}.pull-one * k if %n{k} == $n;\n            }\n        }\n    }\n}\n\nmy $humble := smooth-numbers(2,3,5,7);\n\nput $humble[^50];\nsay '';\n\nmy $upto = 50;\nmy $digits = 1;\nmy $count;\n\n$humble.map: -> \\h {\n    ++$count and next if h.chars == $digits;\n    printf \"Digits: %2d - Count: %s\\n\", $digits++, $count;\n    $count = 1;\n    last if $digits > $upto;\n}\n\n```\n\nOutput:\n\n```\n1 2 3 4 5 6 7 8 9 10 12 14 15 16 18 20 21 24 25 27 28 30 32 35 36 40 42 45 48 49 50 54 56 60 63 64 70 72 75 80 81 84 90 96 98 100 105 108 112 120\n\nDigits:  1 - Count: 9\nDigits:  2 - Count: 36\nDigits:  3 - Count: 95\nDigits:  4 - Count: 197\nDigits:  5 - Count: 356\nDigits:  6 - Count: 579\nDigits:  7 - Count: 882\nDigits:  8 - Count: 1272\nDigits:  9 - Count: 1767\nDigits: 10 - Count: 2381\nDigits: 11 - Count: 3113\nDigits: 12 - Count: 3984\nDigits: 13 - Count: 5002\nDigits: 14 - Count: 6187\nDigits: 15 - Count: 7545\nDigits: 16 - Count: 9081\nDigits: 17 - Count: 10815\nDigits: 18 - Count: 12759\nDigits: 19 - Count: 14927\nDigits: 20 - Count: 17323\nDigits: 21 - Count: 19960\nDigits: 22 - Count: 22853\nDigits: 23 - Count: 26015\nDigits: 24 - Count: 29458\nDigits: 25 - Count: 33188\nDigits: 26 - Count: 37222\nDigits: 27 - Count: 41568\nDigits: 28 - Count: 46245\nDigits: 29 - Count: 51254\nDigits: 30 - Count: 56618\nDigits: 31 - Count: 62338\nDigits: 32 - Count: 68437\nDigits: 33 - Count: 74917\nDigits: 34 - Count: 81793\nDigits: 35 - Count: 89083\nDigits: 36 - Count: 96786\nDigits: 37 - Count: 104926\nDigits: 38 - Count: 113511\nDigits: 39 - Count: 122546\nDigits: 40 - Count: 132054\nDigits: 41 - Count: 142038\nDigits: 42 - Count: 152515\nDigits: 43 - Count: 163497\nDigits: 44 - Count: 174986\nDigits: 45 - Count: 187004\nDigits: 46 - Count: 199565\nDigits: 47 - Count: 212675\nDigits: 48 - Count: 226346\nDigits: 49 - Count: 240590\nDigits: 50 - Count: 255415\n```"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nCreate a simple implementation of the classic textual game Hunt the Wumpus.\n\nThe rules are:\n\nThe game is set in a cave that consists of a 20 room labyrinth.\nEach room is connected to 3 other rooms (the cave is modeled after the\nvertices of a dodecahedron).\nThe objective of the player is to find and kill the horrendous beast Wumpus that lurks in the cave.\n\nThe player has 5 arrows.\nIf they run out of arrows before killing the Wumpus, the player loses the game.\n\nIn the cave there are:\n\n* One Wumpus\n* Two giant bats\n* Two bottomless pits\n\nIf the player enters a room with the Wumpus, he is eaten by it and the game is lost.\n\nIf the player enters a room with a bottomless pit, he falls into it and the game is lost.\n\nIf the player enters a room with a giant bat, the bat takes him and transports him into a random empty room.\n\nEach turn the player can either walk into an adjacent room or shoot into an adjacent room.\n\nWhenever the player enters a room, he \"senses\" what happens in adjacent rooms.\nThe messages are:\n\n* Nearby Wumpus: \"You smell something terrible nearby.\"\n* Nearby bat: \"You hear a rustling.\"\n* Nearby pit: \"You feel a cold wind blowing from a nearby cavern.\"\n\nWhen the player shoots, he wins the game if he is shooting in the room with the Wumpus.\nIf he shoots into another room, the Wumpus has a 75% of chance of waking up and moving into an adjacent room: if this is the room with the player, he eats him up and the game is lost."}, {"role": "assistant", "content": "(formerly Perl 6)\nSee Hunt the Wumpus/Raku"}]}
{"messages": [{"role": "user", "content": "The phrase     \"I before E, except after C\"     is a\nwidely known mnemonic which is supposed to help when spelling English words.\n\nTask\n\nUsing the word list from   http://wiki.puzzlers.org/pub/wordlists/unixdict.txt,\n  \ncheck if the two sub-clauses of the phrase are plausible individually:\n\n:   :   :   1. *\"I before E when not preceded by C\"*\n            2. *\"E before I when preceded by C\"*\n\nIf both sub-phrases are plausible then the original phrase can be said to be plausible.\n\nSomething is plausible if the number of words having the feature is more than two times the number of words having the opposite feature (where feature is 'ie' or 'ei' preceded or not by 'c' as appropriate).\n\nStretch goal\n\nAs a stretch goal use the entries from the table of Word Frequencies in Written and Spoken English: based on the British National Corpus, (selecting those rows with three space or tab separated words only), to see if the phrase is plausible when word frequencies are taken into account.\n\n*Show your output here as well as your program.*\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet\n\ncf.\n\n* Schools to rethink 'i before e' - BBC news, 20 June 2009\n* I Before E Except After C - QI Series 8 Ep 14, (humorous)\n* Companion website for the book: \"Word Frequencies in Written and Spoken English: based on the British National Corpus\"."}, {"role": "assistant", "content": "(formerly Perl 6)\nThis solution uses grammars and actions to parse the given file, the Bag for tallying up occurrences of each possible thing we're looking for (\"ie\", \"ei\", \"cie\", and \"cei\"), and junctions to determine the plausibility of a phrase from the subphrases. Note that a version of rakudo newer than the January 2014 compiler or Star releases is needed, as this code relies on a recent bugfix to the make function.\n\n```\ngrammar CollectWords {\n    token TOP {\n        [^^ <word> $$ \\n?]+\n    }\n\n    token word {\n        [ <with_c> | <no_c> | \\N ]+\n    }\n\n    token with_c {\n        c <ie_part>\n    }\n\n    token no_c {\n        <ie_part>\n    }\n\n    token ie_part {\n        ie | ei | eie # a couple words in the list have \"eie\"\n    }\n}\n\nclass CollectWords::Actions {\n    method TOP($/) {\n        make $<word>».ast.flat.Bag;\n    }\n\n    method word($/) {\n        if $<with_c> + $<no_c> {\n            make flat $<with_c>».ast, $<no_c>».ast;\n        } else {\n            make ();\n        }\n    }\n\n    method with_c($/) {\n        make \"c\" X~ $<ie_part>.ast;\n    }\n\n    method no_c($/) {\n        make \"!c\" X~ $<ie_part>.ast;\n    }\n\n    method ie_part($/) {\n        if ~$/ eq 'eie' {\n            make ('ei', 'ie');\n        } else {\n            make ~$/;\n        }\n    }\n}\n\nsub plausible($good, $bad, $msg) {\n    if $good > 2*$bad {\n        say \"$msg: PLAUSIBLE ($good  vs. $bad ✘)\";\n        return True;\n    } else {\n        say \"$msg: NOT PLAUSIBLE ($good  vs. $bad ✘)\";\n        return False;\n    }\n}\n\nmy $results = CollectWords.parsefile(\"unixdict.txt\", :actions(CollectWords::Actions)).ast;\n\nmy $phrasetest = [&] plausible($results<!cie>, $results<!cei>, \"I before E when not preceded by C\"),\n                     plausible($results<cei>, $results<cie>, \"E before I when preceded by C\");\n\nsay \"I before E except after C: \", $phrasetest ?? \"PLAUSIBLE\" !! \"NOT PLAUSIBLE\";\n\n```\n\nOutput:\n\n```\nI before E when not preceded by C: PLAUSIBLE (466  vs. 217 ✘)\nE before I when preceded by C: NOT PLAUSIBLE (13  vs. 24 ✘)\nI before E except after C: NOT PLAUSIBLE\n```\n\n### Raku: Stretch Goal\n\nNote that within the original text file, a tab character was erroneously replaced with a space. Thus, the following changes to the text file are needed before this solution will run:\n\n```\n--- orig_1_2_all_freq.txt\t2014-02-01 14:36:53.124121018 -0800\n+++ 1_2_all_freq.txt\t2014-02-01 14:37:10.525552980 -0800\n@@ -2488,7 +2488,7 @@\n \tother than\tPrep\t43\n \tvisited\tVerb\t43\n \tcross\tNoC\t43\n-\tlie Verb\t43\n+\tlie\tVerb\t43\n \tgrown\tVerb\t43\n \tcrowd\tNoC\t43\n \trecognised\tVerb\t43\n```\n\nThis solution requires just a few modifications to the grammar and actions from the non-stretch goal.\n\n```\ngrammar CollectWords {\n    token TOP {\n        ^^ \\t Word \\t PoS \\t Freq $$ \\n\n        [^^ <word> $$ \\n?]+\n    }\n\n    token word {\n        \\t+\n        [ <with_c> | <no_c> | \\T ]+ \\t+\n        \\T+ \\t+ # PoS doesn't matter to us, so ignore it\n        $<freq>=[<.digit>+] \\h*\n    }\n\n    token with_c {\n        c <ie_part>\n    }\n\n    token no_c {\n        <ie_part>\n    }\n\n    token ie_part {\n        ie | ei\n    }\n}\n\nclass CollectWords::Actions {\n    method TOP($/) {\n        make $<word>».ast.flat.Bag;\n    }\n\n    method word($/) {\n        if $<with_c> + $<no_c> {\n            make flat $<with_c>».ast xx +$<freq>, $<no_c>».ast xx +$<freq>;\n        } else {\n            make ();\n        }\n    }\n\n    method with_c($/) {\n        make \"c\" ~ $<ie_part>;\n    }\n\n    method no_c($/) {\n        make \"!c\" ~ $<ie_part>;\n    }\n}\n\nsub plausible($good, $bad, $msg) {\n    if $good > 2*$bad {\n        say \"$msg: PLAUSIBLE ($good  vs. $bad ✘)\";\n        return True;\n    } else {\n        say \"$msg: NOT PLAUSIBLE ($good  vs. $bad ✘)\";\n        return False;\n    }\n}\n\n# can't use .parsefile like before due to the non-Unicode £ in this file.\nmy $file = slurp(\"1_2_all_freq.txt\", :enc<iso-8859-1>);\nmy $results = CollectWords.parse($file, :actions(CollectWords::Actions)).ast;\n\nmy $phrasetest = [&] plausible($results<!cie>, $results<!cei>, \"I before E when not preceded by C\"),\n                     plausible($results<cei>, $results<cie>, \"E before I when preceded by C\");\n\nsay \"I before E except after C: \", $phrasetest ?? \"PLAUSIBLE\" !! \"NOT PLAUSIBLE\";\n\n```\n\nOutput:\n\n```\nI before E when not preceded by C: NOT PLAUSIBLE (8222  vs. 4826 ✘)\nE before I when preceded by C: NOT PLAUSIBLE (327  vs. 994 ✘)\nI before E except after C: NOT PLAUSIBLE\n```"}]}
{"messages": [{"role": "user", "content": "Your latest contract has hit a snag. You came to update the army payroll system, but awoke this morning to the sound of mortars landing not far away and panicked generals banging on you door. The President has loaded his gold on trucks and needs to find the shortest route to safety. You are given the following map. The top left hand corner is (0,0). You and The President are located at HQ in the centre of the country (11,11). Cells marked 0 indicate safety. Numbers other than 0 indicate the number of cells that his party will travel in a day in any direction up, down, left, right, or diagonally.\n\n```\n         00000         \n      00003130000      \n    000321322221000    \n   00231222432132200   \n  0041433223233211100  \n  0232231612142618530  \n 003152122326114121200 \n 031252235216111132210 \n 022211246332311115210 \n00113232262121317213200\n03152118212313211411110\n03231234121132221411410\n03513213411311414112320\n00427534125412213211400\n 013322444412122123210 \n 015132331312411123120 \n 003333612214233913300 \n  0219126511415312570  \n  0021321524341325100  \n   00211415413523200   \n    000122111322000    \n      00001120000      \n         00000         \n\n```\n\nPart 1 Use Dijkstra's algorithm to find a list of the shortest routes from HQ to safety.\n  \nPart 2  \nSix days later and you are called to another briefing. The good news is The President and his gold are safe, so your invoice may be paid if you can get out of here. To do this a number of troop repositions will be required. It is concluded that you need to know the shortest route from each cell to every other cell. You decide to use Floyd's algorithm. Print the shortest route from (21,11) to (1,11) and from (1,11) to (21,11), and the longest shortest route between any two points.\n  \nExtra Credit\n\n1. Is there any cell in the country that can not be reached from HQ?\n2. Which cells will it take longest to send reinforcements to from HQ?\n\nRelated tasks:\n\n1. Dijkstra's algorithm\n2. Floyd-Warshall algorithm\n\nSee also\n\n* Back from the Klondike."}, {"role": "assistant", "content": "**Translation of**: Perl\n\n```\nmy $d = qq:to/END/;\n         00000\n      00003130000\n    000321322221000\n   00231222432132200\n  0041433223233211100\n  0232231612142618530\n 003152122326114121200\n 031252235216111132210\n 022211246332311115210\n00113232262121317213200\n03152118212313211411110\n03231234121132221411410\n03513213411311414112320\n00427534125412213211400\n 013322444412122123210\n 015132331312411123120\n 003333612214233913300\n  0219126511415312570\n  0021321524341325100\n   00211415413523200\n    000122111322000\n      00001120000\n         00000\nEND\n\nmy $w = $d.split(\"\\n\")».chars.max;\n$d = $d.split(\"\\n\")».fmt(\"%-{$w}s\").join(\"\\n\"); # pad lines to same length\n$w++;\n\nmy @directions = ( 1, -1, -$w-1, -$w, -$w+1, $w-1, $w, $w+1);\nmy @nodes.push: .pos - 1 for $d ~~ m:g/\\d/;\nmy %dist = @nodes.race.map: { $_ => all-destinations([$_]) };\n\nsub all-destinations (@queue) {\n    my %to;\n    my $dd = $d;\n    while shift @queue -> $path {\n        my $from = ($path.split(' '))[*-1];\n        my $steps = $dd.substr($from, 1);\n        next if $steps eq ' ';\n        %to{$from} //= $path;\n        next if $steps eq '0';\n        $dd.substr-rw($from, 1) = '0';\n        for @directions -> $dir {\n            my $next = $from + $steps × $dir;\n            next if $next < 0 or $next > $dd.chars;\n            @queue.push: \"$path $next\" if $dd.substr($next, 1) ~~ /\\d/;\n        }\n    }\n    %to;\n}\n\nsub   to-xy ($nodes) { join ' ', $nodes.split(' ').map: { '(' ~ join(',', floor($_/$w), $_%$w) ~ ')' } }\nsub from-xy ($x, $y) { $x × $w + $y }\n\nmy $startpos = from-xy 11, 11;\n\nmy %routes;\n%routes{.split(' ').elems}.push: .&to-xy\n    for grep { .so }, map { %dist{$startpos}{$_} }, grep { '0' eq $d.substr($_, 1) }, @nodes;\nmy $n = %routes{ my $short-route = %routes.keys.sort.first }.elems;\nsay \"Shortest escape routes ($n) of length {$short-route - 1}:\\n\\t\" ~\n    %routes{$short-route}.join(\"\\n\\t\");\n\nsay \"\\nShortest from (21,11) to  (1,11):\\n\\t\" ~ %dist{from-xy 21, 11}{from-xy  1, 11}.&to-xy;\nsay \"\\nShortest from  (1,11) to (21,11):\\n\\t\" ~ %dist{from-xy  1, 11}{from-xy 21, 11}.&to-xy;\n\nmy @long-short = reverse sort { .split(' ').elems }, gather %dist.deepmap(*.take);\nmy $l = @long-short[0].split(' ').elems;\nsay \"\\nLongest 'shortest' paths (length {$l-1}):\";\nsay \"\\t\" ~ .&to-xy for grep { .split(' ').elems == $l }, @long-short;\n\nsay \"\\nNot reachable from HQ:\\n\\t\" ~ @nodes.grep({not %dist{$startpos}{$_}}).&to-xy;\n\nmy @HQ;\n@HQ[.split(' ').elems].push: .&to-xy for %dist{$startpos}.values;\nsay \"\\nLongest reinforcement from HQ is {@HQ - 2} for:\\n\\t\" ~ @HQ[*-1].join(\"\\n\\t\");\n\n```\n\nOutput:\n\n```\nShortest escape routes (40) of length 4:\n    (11,11) (11,12) (8,12) (6,12) (0,12)\n    (11,11) (10,11) (7,11) (7,12) (1,6)\n    (11,11) (11,12) (8,9) (2,9) (1,8)\n    (11,11) (11,12) (8,9) (2,9) (1,9)\n    (11,11) (10,10) (8,10) (5,13) (1,13)\n    (11,11) (11,12) (8,9) (2,15) (1,14)\n    (11,11) (11,12) (8,9) (2,15) (1,15)\n    (11,11) (11,12) (8,9) (2,15) (1,16)\n    (11,11) (10,10) (8,10) (5,7) (2,4)\n    (11,11) (10,11) (7,8) (7,5) (2,5)\n    (11,11) (11,12) (8,9) (2,15) (2,16)\n    (11,11) (11,12) (11,9) (9,9) (3,3)\n    (11,11) (10,11) (7,8) (4,5) (3,4)\n    (11,11) (12,11) (12,14) (8,18) (3,18)\n    (11,11) (12,11) (9,14) (6,17) (4,19)\n    (11,11) (11,12) (8,9) (8,3) (6,1)\n    (11,11) (10,10) (8,8) (8,4) (6,2)\n    (11,11) (11,12) (11,15) (11,17) (7,21)\n    (11,11) (11,12) (8,9) (8,3) (8,1)\n    (11,11) (10,10) (8,8) (12,4) (9,1)\n    (11,11) (11,12) (8,9) (14,3) (11,0)\n    (11,11) (10,11) (7,8) (7,5) (12,0)\n    (11,11) (12,10) (13,10) (13,5) (13,0)\n    (11,11) (10,10) (12,8) (16,4) (13,1)\n    (11,11) (12,11) (12,14) (16,18) (13,21)\n    (11,11) (10,10) (8,8) (12,4) (15,1)\n    (11,11) (11,12) (11,15) (11,17) (15,21)\n    (11,11) (10,10) (12,8) (16,4) (16,1)\n    (11,11) (10,11) (10,14) (12,16) (16,20)\n    (11,11) (12,11) (12,14) (16,18) (16,21)\n    (11,11) (12,11) (15,8) (15,5) (18,2)\n    (11,11) (10,11) (13,8) (14,7) (18,3)\n    (11,11) (11,12) (14,9) (18,5) (19,4)\n    (11,11) (11,12) (14,15) (16,15) (19,18)\n    (11,11) (11,12) (14,12) (16,12) (20,16)\n    (11,11) (10,11) (13,11) (17,15) (20,18)\n    (11,11) (12,10) (13,10) (18,15) (21,15)\n    (11,11) (11,12) (14,9) (18,13) (22,9)\n    (11,11) (12,11) (15,8) (18,11) (22,11)\n    (11,11) (11,12) (14,9) (18,13) (22,13)\n\nShortest from (21,11) to  (1,11):\n    (21,11) (21,12) (19,10) (14,10) (10,10) (8,8) (4,8) (1,11)\n\nShortest from  (1,11) to (21,11):\n    (1,11) (2,10) (5,13) (9,9) (15,3) (20,8) (20,10) (21,11)\n\nLongest 'shortest' paths (length 9):\n    (7,3) (7,4) (5,4) (8,7) (8,9) (14,15) (16,17) (17,16) (18,16) (20,14)\n    (10,21) (10,20) (9,19) (9,16) (9,9) (15,3) (15,8) (15,5) (15,2) (14,2)\n    (11,21) (11,20) (11,16) (11,17) (11,13) (13,11) (17,7) (15,5) (15,2) (14,2)\n    (12,21) (12,19) (12,17) (12,16) (12,12) (12,11) (15,8) (15,5) (15,2) (14,2)\n    (1,11) (1,12) (4,9) (6,9) (8,9) (14,15) (16,17) (17,16) (18,16) (20,14)\n    (2,9) (2,10) (5,7) (8,7) (8,9) (14,15) (16,17) (17,16) (18,16) (20,14)\n    (2,13) (2,15) (3,15) (6,12) (12,18) (13,19) (13,20) (17,16) (18,16) (20,14)\n\nNot reachable from HQ:\n    (2,18) (4,3) (18,20)\n\nLongest reinforcement from HQ is 6 for:\n    (11,11) (11,12) (11,15) (11,17) (7,17) (7,20) (6,20)\n    (11,11) (11,12) (11,15) (13,17) (13,19) (13,20) (17,20)\n    (11,11) (11,12) (14,12) (16,12) (20,12) (21,11) (22,12)\n    (11,11) (11,12) (14,15) (16,17) (17,16) (18,16) (20,14)\n    (11,11) (12,11) (9,14) (6,17) (4,17) (4,18) (3,19)\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at IBAN. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThe   International Bank Account Number (IBAN)   is an internationally agreed means of identifying bank accounts across national borders with a reduced risk of propagating transcription errors.\n\nThe IBAN consists of up to **34** alphanumeric characters:\n\n:   :   * first the two-letter ISO 3166-1 alpha-2 country code,\n        * then two check digits, and\n        * finally a country-specific Basic Bank Account Number (BBAN).\n\nThe check digits enable a sanity check of the bank account number to confirm its integrity even before submitting a transaction.\n\nTask\n\nValidate the following fictitious IBAN:    GB82 WEST 1234 5698 7654 32\n\nDetails of the algorithm can be found on the Wikipedia page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsubset IBAN of Str where sub ($_ is copy) {\n    s:g/\\s//;\n    return False if m/<-alnum>/ or .chars != <\n        AD 24 AE 23 AL 28 AT 20 AZ 28 BA 20 BE 16 BG 22 BH 22 BR 29 CH 21\n        CR 21 CY 28 CZ 24 DE 22 DK 18 DO 28 EE 20 ES 24 FI 18 FO 18 FR 27\n        GB 22 GE 22 GI 23 GL 18 GR 27 GT 28 HR 21 HU 28 IE 22 IL 23 IS 26\n        IT 27 KW 30 KZ 20 LB 28 LI 21 LT 20 LU 20 LV 21 MC 27 MD 24 ME 22\n        MK 19 MR 27 MT 31 MU 30 NL 18 NO 15 PK 24 PL 28 PS 29 PT 25 RO 24\n        RS 22 SA 24 SE 24 SI 19 SK 24 SM 27 TN 24 TR 26 VG 24\n    >.hash{.substr(0,2).uc};\n \n    s/(.**4)(.+)/$1$0/;\n    return .subst(:g, /\\D/, { :36(~$_) }) % 97 == 1;\n}\n\nsay \"$_ is {$_ ~~ IBAN ?? 'valid' !! 'invalid' }\" for \n'GB82 WEST 1234 5698 7654 32',\n'gb82 west 1234 5698 7654 32',\n'GB82 TEST 1234 5698 7654 32';\n\n```\n\nOutput:\n\n```\nGB82 WEST 1234 5698 7654 32 is valid.\ngb82 west 1234 5698 7654 32 is valid.\nGB82 TEST 1234 5698 7654 32 is invalid.\n\n```"}]}
{"messages": [{"role": "user", "content": "Iccanobif primes are prime numbers that, when reversed, are a Fibonacci number.\n\nTask\n\n* Find and display the first 10 iccanobif primes.\n\nStretch\n\n* Find and display the digit count of the next 15 iccanobif primes.\n\nSee also\n\n* OEIS:A036797 - Iccanobif (or iccanobiF) primes: primes which are Fibonacci numbers when reversed"}, {"role": "assistant", "content": "```\nsub abbr ($_) { (.chars < 41 ?? $_ !! .substr(0,20) ~ '..' ~ .substr(*-20)) ~ \" (digits: {.chars})\" }\n\nsay (++$).fmt('%2d') ~ ': ' ~ .flip.&abbr for (lazy (1,1,*+*…*).hyper.grep: {.flip.is-prime})[^25];\n\n```\n\nOutput:\n\n```\n 1: 2 (digits: 1)\n 2: 3 (digits: 1)\n 3: 5 (digits: 1)\n 4: 31 (digits: 2)\n 5: 43 (digits: 2)\n 6: 773 (digits: 3)\n 7: 7951 (digits: 4)\n 8: 64901 (digits: 5)\n 9: 52057 (digits: 5)\n10: 393121 (digits: 6)\n11: 56577108676171 (digits: 14)\n12: 940647607443258103531 (digits: 21)\n13: 5237879497657222310489731409575442761 (digits: 37)\n14: 9026258083384996860449366072142307801963 (digits: 40)\n15: 19900335674812302969..34431012073266446403 (digits: 80)\n16: 77841137362967479985..52312097783685331923 (digits: 104)\n17: 37722585901567604188..29174997072830756131 (digits: 137)\n18: 75736193894876131595..50767238644714305761 (digits: 330)\n19: 17890336847332837620..13175300695235035913 (digits: 406)\n20: 92327163101729115305..27061468856047302507 (digits: 409)\n21: 50420157810698056253..67335124247362214481 (digits: 503)\n22: 30511012474739380092..69296158361330018201 (digits: 888)\n23: 46818547042693694555..08664543144645856321 (digits: 1020)\n24: 87101347853037819884..20128396998865227391 (digits: 1122)\n25: 17451656022543765336..20100243761843652461 (digits: 1911)\n26: 48989340566288399474..02930339234215909399 (digits: 1947)\n27: 12746927684958209654..53436989647994940101 (digits: 2283)\n28: 35746826582658751012..25010735912438195633 (digits: 3727)\n29: 87987175281297657706..48748727893681871587 (digits: 4270)\n30: 81807376367113798363..13687506007959668569 (digits: 10527)\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nBuild an   identity matrix   of a size known at run-time.\n\nAn *identity matrix* is a square matrix of size ***n* × *n***,\n  \nwhere the diagonal elements are all **1**s (ones),\n  \nand all the other elements are all **0**s (zeroes).\n\nI\n\nn\n=\n\n\n[\n\n1\n\n0\n\n0\n\n⋯\n\n0\n\n\n0\n\n1\n\n0\n\n⋯\n\n0\n\n\n0\n\n0\n\n1\n\n⋯\n\n0\n\n\n⋮\n\n⋮\n\n⋮\n\n⋱\n\n⋮\n\n\n0\n\n0\n\n0\n\n⋯\n\n1\n]\n{\\displaystyle {\\displaystyle I\\_{n}={\\begin{bmatrix}1&0&0&\\cdots &0\\\\0&1&0&\\cdots &0\\\\0&0&1&\\cdots &0\\\\\\vdots &\\vdots &\\vdots &\\ddots &\\vdots \\\\0&0&0&\\cdots &1\\\\\\end{bmatrix}}}}\n\nRelated tasks\n\n* Spiral matrix\n* Zig-zag matrix\n* Ulam\\_spiral\\_(for\\_primes)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-15\n\n```\nsub identity-matrix($n) {\n    my @id;\n    for flat ^$n X ^$n -> $i, $j {\n        @id[$i][$j] = +($i == $j);\n    }\n    @id;\n}\n\n.say for identity-matrix(5);\n```\n\nOutput:\n\n```\n[1 0 0 0 0]\n[0 1 0 0 0]\n[0 0 1 0 0]\n[0 0 0 1 0]\n[0 0 0 0 1]\n```\n\nOn the other hand, this may be clearer and/or faster:\n\n```\nsub identity-matrix($n) {\n    my @id = [0 xx $n] xx $n;\n    @id[$_][$_] = 1 for ^$n;\n    @id;\n}\n```\n\nHere is yet an other way to do it:\n\n```\nsub identity-matrix($n) {\n    [1, |(0 xx $n-1)], *.rotate(-1) ... *[*-1]\n}\n```"}]}
{"messages": [{"role": "user", "content": "Idiomatically determine all the characters that can be used for *symbols*.\nThe word *symbols* is meant things like names of variables, procedures (i.e., named fragments of programs, functions, subroutines, routines), statement labels, events or conditions, and in general, anything a computer programmer can choose to *name*, but not being restricted to this list. *Identifiers* might be another name for *symbols*.\n\nThe method should find the characters regardless of the hardware architecture that is being used (ASCII, EBCDIC, or other).\n\nTask requirements\n\nDisplay the set of all the characters that can be used for symbols which can be used (allowed) by the computer program.\nYou may want to mention what hardware architecture is being used, and if applicable, the operating system.\n\nNote that most languages have additional restrictions on what characters can't be used for the first character of a variable or statement label, for instance. These type of restrictions needn't be addressed here (but can be mentioned).\n\nSee also\n\n* Idiomatically determine all the lowercase and uppercase letters."}, {"role": "assistant", "content": "(formerly Perl 6)\nAny Unicode character or combination of characters can be used for symbols in Raku. Here's some counting rods and some cuneiform:\n\n```\nsub postfix:<𒋦>($n) { say \"$n trilobites\" }\n\nsub term:<𝍧> { unival('𝍧') }\n\n𝍧𒋦\n\n```\n\nOutput:\n\n```\n8 trilobites\n```\n\nAnd here is a Zalgo-text symbol:\n\n```\nsub Z̧̔ͩ͌͑̉̎A̢̲̙̮̹̮͍̎L̔ͧ́͆G̰̬͎͔̱̅ͣͫO͙̔ͣ̈́̈̽̎ͣ ($n) { say \"$n COMES\" }\n\n\nZ̧̔ͩ͌͑̉̎A̢̲̙̮̹̮͍̎L̔ͧ́͆G̰̬͎͔̱̅ͣͫO͙̔ͣ̈́̈̽̎ͣ 'HE'\n\n```\n\nOutput:\n\n```\nHE COMES\n```\n\nOf course, as in other languages, most of the characters you'll typically see in names are going to be alphanumerics from ASCII (or maybe Unicode), but that's a convention, not a limitation, due to the syntactic category notation demonstrated above, which can introduce any sequence of characters as a term or operator.\n\nActually, the above is a slight prevarication. The syntactic category notation does not allow you to use whitespace in the definition of a new symbol. But that leaves many more characters allowed than not allowed. Hence, it is much easier to enumerate the characters that *cannot* be used in symbols:\n\n```\nsay .fmt(\"%4x\"),\"\\t\", uniname($_)\n    if uniprop($_,'Z')\n        for 0..0x1ffff;\n\n```\n\nOutput:\n\n```\n  20\tSPACE\n  a0\tNO-BREAK SPACE\n1680\tOGHAM SPACE MARK\n2000\tEN QUAD\n2001\tEM QUAD\n2002\tEN SPACE\n2003\tEM SPACE\n2004\tTHREE-PER-EM SPACE\n2005\tFOUR-PER-EM SPACE\n2006\tSIX-PER-EM SPACE\n2007\tFIGURE SPACE\n2008\tPUNCTUATION SPACE\n2009\tTHIN SPACE\n200a\tHAIR SPACE\n2028\tLINE SEPARATOR\n2029\tPARAGRAPH SEPARATOR\n202f\tNARROW NO-BREAK SPACE\n205f\tMEDIUM MATHEMATICAL SPACE\n3000\tIDEOGRAPHIC SPACE\n```\n\nWe enforce the whitespace restriction to prevent insanity in the readers of programs.\nThat being said, even the whitespace restriction is arbitrary, and can be bypassed by deriving a new grammar and switching to it. We view all other languages as dialects of Raku, even the insane ones. :-)"}]}
{"messages": [{"role": "user", "content": "Idiomatically determine all the lowercase and uppercase letters   (of the Latin [English] alphabet)   being used currently by a computer programming language.\nThe method should find the letters regardless of the hardware architecture that is being used (ASCII, EBCDIC, or other).\n\nTask requirements\n\nDisplay the set of all:\n\n:   :   :   :   :   :   * lowercase letters\n                        * uppercase letters\n\nthat can be used (allowed) by the computer program,\n\nwhere   *letter*   is a member of the Latin (English) alphabet:     **a** ──► **z**     and     **A** ──► **Z**.\n\nYou may want to mention what hardware architecture is being used, and if applicable, the operating system.\n\nSee also\n\n* Idiomatically determine all the characters that can be used for symbols."}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku supports all the Unicode categories of characters natively. The constant 0x1fffd is *not* a typo for 0x10ffff: we're restricting the range of characters to the first two Unicode planes, since the 3rd plane is reserved for ideographs (category Lo, \"letter other\"), and the subsequent planes contain no letters (yet).\n\n```\ngiven (0..0x1fffd).chrs {\n    say \"Lowercase: \", .comb(/<:Ll>/);\n    say \"Uppercase: \", .comb(/<:Lu>/);\n    say \"Titlecase: \", .comb(/<:Lt>/);\n}\n\n```\n\n```\nLowercase: a b c d e f g h i j k l m n o p q r s t u v w x y z µ ß à á â ã ä å æ ç è é ê ë ì í î ï ð ñ ò ó ô õ ö ø ù ú û ü ý þ ÿ ā ă ą ć ĉ ċ č ď đ ē ĕ ė ę ě ĝ ğ ġ ģ ĥ ħ ĩ ī ĭ į ı ij ĵ ķ ĸ ĺ ļ ľ ŀ ł ń ņ ň ʼn ŋ ō ŏ ő œ ŕ ŗ ř ś ŝ ş š ţ ť ŧ ũ ū ŭ ů ű ų ŵ ŷ ź ż ž ſ ƀ ƃ ƅ ƈ ƌ ƍ ƒ ƕ ƙ ƚ ƛ ƞ ơ ƣ ƥ ƨ ƪ ƫ ƭ ư ƴ ƶ ƹ ƺ ƽ ƾ ƿ dž lj nj ǎ ǐ ǒ ǔ ǖ ǘ ǚ ǜ ǝ ǟ ǡ ǣ ǥ ǧ ǩ ǫ ǭ ǯ ǰ dz ǵ ǹ ǻ ǽ ǿ ȁ ȃ ȅ ȇ ȉ ȋ ȍ ȏ ȑ ȓ ȕ ȗ ș ț ȝ ȟ ȡ ȣ ȥ ȧ ȩ ȫ ȭ ȯ ȱ ȳ ȴ ȵ ȶ ȷ ȸ ȹ ȼ ȿ ɀ ɂ ɇ ɉ ɋ ɍ ɏ ɐ ɑ ɒ ɓ ɔ ɕ ɖ ɗ ɘ ə ɚ ɛ ɜ ɝ ɞ ɟ ɠ ɡ ɢ ɣ ɤ ɥ ɦ ɧ ɨ ɩ ɪ ɫ ɬ ɭ ɮ ɯ ɰ ɱ ɲ ɳ ɴ ɵ ɶ ɷ ɸ ɹ ɺ ɻ ɼ ɽ ɾ ɿ ʀ ʁ ʂ ʃ ʄ ʅ ʆ ʇ ʈ ʉ ʊ ʋ ʌ ʍ ʎ ʏ ʐ ʑ ʒ ʓ ʕ ʖ ʗ ʘ ʙ ʚ ʛ ʜ ʝ ʞ ʟ ʠ ʡ ʢ ʣ ʤ ʥ ʦ ʧ ʨ ʩ ʪ ʫ ʬ ʭ ʮ ʯ ͱ ͳ ͷ ͻ ͼ ͽ ΐ ά έ ή ί ΰ α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ ς σ τ υ φ χ ψ ω ϊ ϋ ό ύ ώ ϐ ϑ ϕ ϖ ϗ ϙ ϛ ϝ ϟ ϡ ϣ ϥ ϧ ϩ ϫ ϭ ϯ ϰ ϱ ϲ ϳ ϵ ϸ ϻ ϼ а б в г д е ж з и й к л м н о п р с т у ф х ц ч ш щ ъ ы ь э ю я ѐ ё ђ ѓ є ѕ і ї ј љ њ ћ ќ ѝ ў џ ѡ ѣ ѥ ѧ ѩ ѫ ѭ ѯ ѱ ѳ ѵ ѷ ѹ ѻ ѽ ѿ ҁ ҋ ҍ ҏ ґ ғ ҕ җ ҙ қ ҝ ҟ ҡ ң ҥ ҧ ҩ ҫ ҭ ү ұ ҳ ҵ ҷ ҹ һ ҽ ҿ ӂ ӄ ӆ ӈ ӊ ӌ ӎ ӏ ӑ ӓ ӕ ӗ ә ӛ ӝ ӟ ӡ ӣ ӥ ӧ ө ӫ ӭ ӯ ӱ ӳ ӵ ӷ ӹ ӻ ӽ ӿ ԁ ԃ ԅ ԇ ԉ ԋ ԍ ԏ ԑ ԓ ԕ ԗ ԙ ԛ ԝ ԟ ԡ ԣ ԥ ԧ ա բ գ դ ե զ է ը թ ժ ի լ խ ծ կ հ ձ ղ ճ մ յ ն շ ո չ պ ջ ռ ս վ տ ր ց ւ փ ք օ ֆ և ᴀ ᴁ ᴂ ᴃ ᴄ ᴅ ᴆ ᴇ ᴈ ᴉ ᴊ ᴋ ᴌ ᴍ ᴎ ᴏ ᴐ ᴑ ᴒ ᴓ ᴔ ᴕ ᴖ ᴗ ᴘ ᴙ ᴚ ᴛ ᴜ ᴝ ᴞ ᴟ ᴠ ᴡ ᴢ ᴣ ᴤ ᴥ ᴦ ᴧ ᴨ ᴩ ᴪ ᴫ ᵫ ᵬ ᵭ ᵮ ᵯ ᵰ ᵱ ᵲ ᵳ ᵴ ᵵ ᵶ ᵷ ᵹ ᵺ ᵻ ᵼ ᵽ ᵾ ᵿ ᶀ ᶁ ᶂ ᶃ ᶄ ᶅ ᶆ ᶇ ᶈ ᶉ ᶊ ᶋ ᶌ ᶍ ᶎ ᶏ ᶐ ᶑ ᶒ ᶓ ᶔ ᶕ ᶖ ᶗ ᶘ ᶙ ᶚ ḁ ḃ ḅ ḇ ḉ ḋ ḍ ḏ ḑ ḓ ḕ ḗ ḙ ḛ ḝ ḟ ḡ ḣ ḥ ḧ ḩ ḫ ḭ ḯ ḱ ḳ ḵ ḷ ḹ ḻ ḽ ḿ ṁ ṃ ṅ ṇ ṉ ṋ ṍ ṏ ṑ ṓ ṕ ṗ ṙ ṛ ṝ ṟ ṡ ṣ ṥ ṧ ṩ ṫ ṭ ṯ ṱ ṳ ṵ ṷ ṹ ṻ ṽ ṿ ẁ ẃ ẅ ẇ ẉ ẋ ẍ ẏ ẑ ẓ ẕ ẖ ẗ ẘ ẙ ẚ ẛ ẜ ẝ ẟ ạ ả ấ ầ ẩ ẫ ậ ắ ằ ẳ ẵ ặ ẹ ẻ ẽ ế ề ể ễ ệ ỉ ị ọ ỏ ố ồ ổ ỗ ộ ớ ờ ở ỡ ợ ụ ủ ứ ừ ử ữ ự ỳ ỵ ỷ ỹ ỻ ỽ ỿ ἀ ἁ ἂ ἃ ἄ ἅ ἆ ἇ ἐ ἑ ἒ ἓ ἔ ἕ ἠ ἡ ἢ ἣ ἤ ἥ ἦ ἧ ἰ ἱ ἲ ἳ ἴ ἵ ἶ ἷ ὀ ὁ ὂ ὃ ὄ ὅ ὐ ὑ ὒ ὓ ὔ ὕ ὖ ὗ ὠ ὡ ὢ ὣ ὤ ὥ ὦ ὧ ὰ ά ὲ έ ὴ ή ὶ ί ὸ ό ὺ ύ ὼ ώ ᾀ ᾁ ᾂ ᾃ ᾄ ᾅ ᾆ ᾇ ᾐ ᾑ ᾒ ᾓ ᾔ ᾕ ᾖ ᾗ ᾠ ᾡ ᾢ ᾣ ᾤ ᾥ ᾦ ᾧ ᾰ ᾱ ᾲ ᾳ ᾴ ᾶ ᾷ ι ῂ ῃ ῄ ῆ ῇ ῐ ῑ ῒ ΐ ῖ ῗ ῠ ῡ ῢ ΰ ῤ ῥ ῦ ῧ ῲ ῳ ῴ ῶ ῷ ℊ ℎ ℏ ℓ ℯ ℴ ℹ ℼ ℽ ⅆ ⅇ ⅈ ⅉ ⅎ ↄ ⰰ ⰱ ⰲ ⰳ ⰴ ⰵ ⰶ ⰷ ⰸ ⰹ ⰺ ⰻ ⰼ ⰽ ⰾ ⰿ ⱀ ⱁ ⱂ ⱃ ⱄ ⱅ ⱆ ⱇ ⱈ ⱉ ⱊ ⱋ ⱌ ⱍ ⱎ ⱏ ⱐ ⱑ ⱒ ⱓ ⱔ ⱕ ⱖ ⱗ ⱘ ⱙ ⱚ ⱛ ⱜ ⱝ ⱞ ⱡ ⱥ ⱦ ⱨ ⱪ ⱬ ⱱ ⱳ ⱴ ⱶ ⱷ ⱸ ⱹ ⱺ ⱻ ⲁ ⲃ ⲅ ⲇ ⲉ ⲋ ⲍ ⲏ ⲑ ⲓ ⲕ ⲗ ⲙ ⲛ ⲝ ⲟ ⲡ ⲣ ⲥ ⲧ ⲩ ⲫ ⲭ ⲯ ⲱ ⲳ ⲵ ⲷ ⲹ ⲻ ⲽ ⲿ ⳁ ⳃ ⳅ ⳇ ⳉ ⳋ ⳍ ⳏ ⳑ ⳓ ⳕ ⳗ ⳙ ⳛ ⳝ ⳟ ⳡ ⳣ ⳤ ⳬ ⳮ ⳳ ⴀ ⴁ ⴂ ⴃ ⴄ ⴅ ⴆ ⴇ ⴈ ⴉ ⴊ ⴋ ⴌ ⴍ ⴎ ⴏ ⴐ ⴑ ⴒ ⴓ ⴔ ⴕ ⴖ ⴗ ⴘ ⴙ ⴚ ⴛ ⴜ ⴝ ⴞ ⴟ ⴠ ⴡ ⴢ ⴣ ⴤ ⴥ ⴧ ⴭ ꙁ ꙃ ꙅ ꙇ ꙉ ꙋ ꙍ ꙏ ꙑ ꙓ ꙕ ꙗ ꙙ ꙛ ꙝ ꙟ ꙡ ꙣ ꙥ ꙧ ꙩ ꙫ ꙭ ꚁ ꚃ ꚅ ꚇ ꚉ ꚋ ꚍ ꚏ ꚑ ꚓ ꚕ ꚗ ꜣ ꜥ ꜧ ꜩ ꜫ ꜭ ꜯ ꜰ ꜱ ꜳ ꜵ ꜷ ꜹ ꜻ ꜽ ꜿ ꝁ ꝃ ꝅ ꝇ ꝉ ꝋ ꝍ ꝏ ꝑ ꝓ ꝕ ꝗ ꝙ ꝛ ꝝ ꝟ ꝡ ꝣ ꝥ ꝧ ꝩ ꝫ ꝭ ꝯ ꝱ ꝲ ꝳ ꝴ ꝵ ꝶ ꝷ ꝸ ꝺ ꝼ ꝿ ꞁ ꞃ ꞅ ꞇ ꞌ ꞎ ꞑ ꞓ ꞡ ꞣ ꞥ ꞧ ꞩ ꟺ ff fi fl ffi ffl ſt st ﬓ ﬔ ﬕ ﬖ ﬗ ａ ｂ ｃ ｄ ｅ ｆ ｇ ｈ ｉ ｊ ｋ ｌ ｍ ｎ ｏ ｐ ｑ ｒ ｓ ｔ ｕ ｖ ｗ ｘ ｙ ｚ 𐐨 𐐩 𐐪 𐐫 𐐬 𐐭 𐐮 𐐯 𐐰 𐐱 𐐲 𐐳 𐐴 𐐵 𐐶 𐐷 𐐸 𐐹 𐐺 𐐻 𐐼 𐐽 𐐾 𐐿 𐑀 𐑁 𐑂 𐑃 𐑄 𐑅 𐑆 𐑇 𐑈 𐑉 𐑊 𐑋 𐑌 𐑍 𐑎 𐑏 𝐚 𝐛 𝐜 𝐝 𝐞 𝐟 𝐠 𝐡 𝐢 𝐣 𝐤 𝐥 𝐦 𝐧 𝐨 𝐩 𝐪 𝐫 𝐬 𝐭 𝐮 𝐯 𝐰 𝐱 𝐲 𝐳 𝑎 𝑏 𝑐 𝑑 𝑒 𝑓 𝑔 𝑖 𝑗 𝑘 𝑙 𝑚 𝑛 𝑜 𝑝 𝑞 𝑟 𝑠 𝑡 𝑢 𝑣 𝑤 𝑥 𝑦 𝑧 𝒂 𝒃 𝒄 𝒅 𝒆 𝒇 𝒈 𝒉 𝒊 𝒋 𝒌 𝒍 𝒎 𝒏 𝒐 𝒑 𝒒 𝒓 𝒔 𝒕 𝒖 𝒗 𝒘 𝒙 𝒚 𝒛 𝒶 𝒷 𝒸 𝒹 𝒻 𝒽 𝒾 𝒿 𝓀 𝓁 𝓂 𝓃 𝓅 𝓆 𝓇 𝓈 𝓉 𝓊 𝓋 𝓌 𝓍 𝓎 𝓏 𝓪 𝓫 𝓬 𝓭 𝓮 𝓯 𝓰 𝓱 𝓲 𝓳 𝓴 𝓵 𝓶 𝓷 𝓸 𝓹 𝓺 𝓻 𝓼 𝓽 𝓾 𝓿 𝔀 𝔁 𝔂 𝔃 𝔞 𝔟 𝔠 𝔡 𝔢 𝔣 𝔤 𝔥 𝔦 𝔧 𝔨 𝔩 𝔪 𝔫 𝔬 𝔭 𝔮 𝔯 𝔰 𝔱 𝔲 𝔳 𝔴 𝔵 𝔶 𝔷 𝕒 𝕓 𝕔 𝕕 𝕖 𝕗 𝕘 𝕙 𝕚 𝕛 𝕜 𝕝 𝕞 𝕟 𝕠 𝕡 𝕢 𝕣 𝕤 𝕥 𝕦 𝕧 𝕨 𝕩 𝕪 𝕫 𝖆 𝖇 𝖈 𝖉 𝖊 𝖋 𝖌 𝖍 𝖎 𝖏 𝖐 𝖑 𝖒 𝖓 𝖔 𝖕 𝖖 𝖗 𝖘 𝖙 𝖚 𝖛 𝖜 𝖝 𝖞 𝖟 𝖺 𝖻 𝖼 𝖽 𝖾 𝖿 𝗀 𝗁 𝗂 𝗃 𝗄 𝗅 𝗆 𝗇 𝗈 𝗉 𝗊 𝗋 𝗌 𝗍 𝗎 𝗏 𝗐 𝗑 𝗒 𝗓 𝗮 𝗯 𝗰 𝗱 𝗲 𝗳 𝗴 𝗵 𝗶 𝗷 𝗸 𝗹 𝗺 𝗻 𝗼 𝗽 𝗾 𝗿 𝘀 𝘁 𝘂 𝘃 𝘄 𝘅 𝘆 𝘇 𝘢 𝘣 𝘤 𝘥 𝘦 𝘧 𝘨 𝘩 𝘪 𝘫 𝘬 𝘭 𝘮 𝘯 𝘰 𝘱 𝘲 𝘳 𝘴 𝘵 𝘶 𝘷 𝘸 𝘹 𝘺 𝘻 𝙖 𝙗 𝙘 𝙙 𝙚 𝙛 𝙜 𝙝 𝙞 𝙟 𝙠 𝙡 𝙢 𝙣 𝙤 𝙥 𝙦 𝙧 𝙨 𝙩 𝙪 𝙫 𝙬 𝙭 𝙮 𝙯 𝚊 𝚋 𝚌 𝚍 𝚎 𝚏 𝚐 𝚑 𝚒 𝚓 𝚔 𝚕 𝚖 𝚗 𝚘 𝚙 𝚚 𝚛 𝚜 𝚝 𝚞 𝚟 𝚠 𝚡 𝚢 𝚣 𝚤 𝚥 𝛂 𝛃 𝛄 𝛅 𝛆 𝛇 𝛈 𝛉 𝛊 𝛋 𝛌 𝛍 𝛎 𝛏 𝛐 𝛑 𝛒 𝛓 𝛔 𝛕 𝛖 𝛗 𝛘 𝛙 𝛚 𝛜 𝛝 𝛞 𝛟 𝛠 𝛡 𝛼 𝛽 𝛾 𝛿 𝜀 𝜁 𝜂 𝜃 𝜄 𝜅 𝜆 𝜇 𝜈 𝜉 𝜊 𝜋 𝜌 𝜍 𝜎 𝜏 𝜐 𝜑 𝜒 𝜓 𝜔 𝜖 𝜗 𝜘 𝜙 𝜚 𝜛 𝜶 𝜷 𝜸 𝜹 𝜺 𝜻 𝜼 𝜽 𝜾 𝜿 𝝀 𝝁 𝝂 𝝃 𝝄 𝝅 𝝆 𝝇 𝝈 𝝉 𝝊 𝝋 𝝌 𝝍 𝝎 𝝐 𝝑 𝝒 𝝓 𝝔 𝝕 𝝰 𝝱 𝝲 𝝳 𝝴 𝝵 𝝶 𝝷 𝝸 𝝹 𝝺 𝝻 𝝼 𝝽 𝝾 𝝿 𝞀 𝞁 𝞂 𝞃 𝞄 𝞅 𝞆 𝞇 𝞈 𝞊 𝞋 𝞌 𝞍 𝞎 𝞏 𝞪 𝞫 𝞬 𝞭 𝞮 𝞯 𝞰 𝞱 𝞲 𝞳 𝞴 𝞵 𝞶 𝞷 𝞸 𝞹 𝞺 𝞻 𝞼 𝞽 𝞾 𝞿 𝟀 𝟁 𝟂 𝟄 𝟅 𝟆 𝟇 𝟈 𝟉 𝟋\nUppercase: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö Ø Ù Ú Û Ü Ý Þ Ā Ă Ą Ć Ĉ Ċ Č Ď Đ Ē Ĕ Ė Ę Ě Ĝ Ğ Ġ Ģ Ĥ Ħ Ĩ Ī Ĭ Į İ IJ Ĵ Ķ Ĺ Ļ Ľ Ŀ Ł Ń Ņ Ň Ŋ Ō Ŏ Ő Œ Ŕ Ŗ Ř Ś Ŝ Ş Š Ţ Ť Ŧ Ũ Ū Ŭ Ů Ű Ų Ŵ Ŷ Ÿ Ź Ż Ž Ɓ Ƃ Ƅ Ɔ Ƈ Ɖ Ɗ Ƌ Ǝ Ə Ɛ Ƒ Ɠ Ɣ Ɩ Ɨ Ƙ Ɯ Ɲ Ɵ Ơ Ƣ Ƥ Ʀ Ƨ Ʃ Ƭ Ʈ Ư Ʊ Ʋ Ƴ Ƶ Ʒ Ƹ Ƽ DŽ LJ NJ Ǎ Ǐ Ǒ Ǔ Ǖ Ǘ Ǚ Ǜ Ǟ Ǡ Ǣ Ǥ Ǧ Ǩ Ǫ Ǭ Ǯ DZ Ǵ Ƕ Ƿ Ǹ Ǻ Ǽ Ǿ Ȁ Ȃ Ȅ Ȇ Ȉ Ȋ Ȍ Ȏ Ȑ Ȓ Ȕ Ȗ Ș Ț Ȝ Ȟ Ƞ Ȣ Ȥ Ȧ Ȩ Ȫ Ȭ Ȯ Ȱ Ȳ Ⱥ Ȼ Ƚ Ⱦ Ɂ Ƀ Ʉ Ʌ Ɇ Ɉ Ɋ Ɍ Ɏ Ͱ Ͳ Ͷ Ά Έ Ή Ί Ό Ύ Ώ Α Β Γ Δ Ε Ζ Η Θ Ι Κ Λ Μ Ν Ξ Ο Π Ρ Σ Τ Υ Φ Χ Ψ Ω Ϊ Ϋ Ϗ ϒ ϓ ϔ Ϙ Ϛ Ϝ Ϟ Ϡ Ϣ Ϥ Ϧ Ϩ Ϫ Ϭ Ϯ ϴ Ϸ Ϲ Ϻ Ͻ Ͼ Ͽ Ѐ Ё Ђ Ѓ Є Ѕ І Ї Ј Љ Њ Ћ Ќ Ѝ Ў Џ А Б В Г Д Е Ж З И Й К Л М Н О П Р С Т У Ф Х Ц Ч Ш Щ Ъ Ы Ь Э Ю Я Ѡ Ѣ Ѥ Ѧ Ѩ Ѫ Ѭ Ѯ Ѱ Ѳ Ѵ Ѷ Ѹ Ѻ Ѽ Ѿ Ҁ Ҋ Ҍ Ҏ Ґ Ғ Ҕ Җ Ҙ Қ Ҝ Ҟ Ҡ Ң Ҥ Ҧ Ҩ Ҫ Ҭ Ү Ұ Ҳ Ҵ Ҷ Ҹ Һ Ҽ Ҿ Ӏ Ӂ Ӄ Ӆ Ӈ Ӊ Ӌ Ӎ Ӑ Ӓ Ӕ Ӗ Ә Ӛ Ӝ Ӟ Ӡ Ӣ Ӥ Ӧ Ө Ӫ Ӭ Ӯ Ӱ Ӳ Ӵ Ӷ Ӹ Ӻ Ӽ Ӿ Ԁ Ԃ Ԅ Ԇ Ԉ Ԋ Ԍ Ԏ Ԑ Ԓ Ԕ Ԗ Ԙ Ԛ Ԝ Ԟ Ԡ Ԣ Ԥ Ԧ Ա Բ Գ Դ Ե Զ Է Ը Թ Ժ Ի Լ Խ Ծ Կ Հ Ձ Ղ Ճ Մ Յ Ն Շ Ո Չ Պ Ջ Ռ Ս Վ Տ Ր Ց Ւ Փ Ք Օ Ֆ Ⴀ Ⴁ Ⴂ Ⴃ Ⴄ Ⴅ Ⴆ Ⴇ Ⴈ Ⴉ Ⴊ Ⴋ Ⴌ Ⴍ Ⴎ Ⴏ Ⴐ Ⴑ Ⴒ Ⴓ Ⴔ Ⴕ Ⴖ Ⴗ Ⴘ Ⴙ Ⴚ Ⴛ Ⴜ Ⴝ Ⴞ Ⴟ Ⴠ Ⴡ Ⴢ Ⴣ Ⴤ Ⴥ Ⴧ Ⴭ Ḁ Ḃ Ḅ Ḇ Ḉ Ḋ Ḍ Ḏ Ḑ Ḓ Ḕ Ḗ Ḙ Ḛ Ḝ Ḟ Ḡ Ḣ Ḥ Ḧ Ḩ Ḫ Ḭ Ḯ Ḱ Ḳ Ḵ Ḷ Ḹ Ḻ Ḽ Ḿ Ṁ Ṃ Ṅ Ṇ Ṉ Ṋ Ṍ Ṏ Ṑ Ṓ Ṕ Ṗ Ṙ Ṛ Ṝ Ṟ Ṡ Ṣ Ṥ Ṧ Ṩ Ṫ Ṭ Ṯ Ṱ Ṳ Ṵ Ṷ Ṹ Ṻ Ṽ Ṿ Ẁ Ẃ Ẅ Ẇ Ẉ Ẋ Ẍ Ẏ Ẑ Ẓ Ẕ ẞ Ạ Ả Ấ Ầ Ẩ Ẫ Ậ Ắ Ằ Ẳ Ẵ Ặ Ẹ Ẻ Ẽ Ế Ề Ể Ễ Ệ Ỉ Ị Ọ Ỏ Ố Ồ Ổ Ỗ Ộ Ớ Ờ Ở Ỡ Ợ Ụ Ủ Ứ Ừ Ử Ữ Ự Ỳ Ỵ Ỷ Ỹ Ỻ Ỽ Ỿ Ἀ Ἁ Ἂ Ἃ Ἄ Ἅ Ἆ Ἇ Ἐ Ἑ Ἒ Ἓ Ἔ Ἕ Ἠ Ἡ Ἢ Ἣ Ἤ Ἥ Ἦ Ἧ Ἰ Ἱ Ἲ Ἳ Ἴ Ἵ Ἶ Ἷ Ὀ Ὁ Ὂ Ὃ Ὄ Ὅ Ὑ Ὓ Ὕ Ὗ Ὠ Ὡ Ὢ Ὣ Ὤ Ὥ Ὦ Ὧ Ᾰ Ᾱ Ὰ Ά Ὲ Έ Ὴ Ή Ῐ Ῑ Ὶ Ί Ῠ Ῡ Ὺ Ύ Ῥ Ὸ Ό Ὼ Ώ ℂ ℇ ℋ ℌ ℍ ℐ ℑ ℒ ℕ ℙ ℚ ℛ ℜ ℝ ℤ Ω ℨ K Å ℬ ℭ ℰ ℱ Ⅎ ℳ ℾ ℿ ⅅ Ↄ Ⰰ Ⰱ Ⰲ Ⰳ Ⰴ Ⰵ Ⰶ Ⰷ Ⰸ Ⰹ Ⰺ Ⰻ Ⰼ Ⰽ Ⰾ Ⰿ Ⱀ Ⱁ Ⱂ Ⱃ Ⱄ Ⱅ Ⱆ Ⱇ Ⱈ Ⱉ Ⱊ Ⱋ Ⱌ Ⱍ Ⱎ Ⱏ Ⱐ Ⱑ Ⱒ Ⱓ Ⱔ Ⱕ Ⱖ Ⱗ Ⱘ Ⱙ Ⱚ Ⱛ Ⱜ Ⱝ Ⱞ Ⱡ Ɫ Ᵽ Ɽ Ⱨ Ⱪ Ⱬ Ɑ Ɱ Ɐ Ɒ Ⱳ Ⱶ Ȿ Ɀ Ⲁ Ⲃ Ⲅ Ⲇ Ⲉ Ⲋ Ⲍ Ⲏ Ⲑ Ⲓ Ⲕ Ⲗ Ⲙ Ⲛ Ⲝ Ⲟ Ⲡ Ⲣ Ⲥ Ⲧ Ⲩ Ⲫ Ⲭ Ⲯ Ⲱ Ⲳ Ⲵ Ⲷ Ⲹ Ⲻ Ⲽ Ⲿ Ⳁ Ⳃ Ⳅ Ⳇ Ⳉ Ⳋ Ⳍ Ⳏ Ⳑ Ⳓ Ⳕ Ⳗ Ⳙ Ⳛ Ⳝ Ⳟ Ⳡ Ⳣ Ⳬ Ⳮ Ⳳ Ꙁ Ꙃ Ꙅ Ꙇ Ꙉ Ꙋ Ꙍ Ꙏ Ꙑ Ꙓ Ꙕ Ꙗ Ꙙ Ꙛ Ꙝ Ꙟ Ꙡ Ꙣ Ꙥ Ꙧ Ꙩ Ꙫ Ꙭ Ꚁ Ꚃ Ꚅ Ꚇ Ꚉ Ꚋ Ꚍ Ꚏ Ꚑ Ꚓ Ꚕ Ꚗ Ꜣ Ꜥ Ꜧ Ꜩ Ꜫ Ꜭ Ꜯ Ꜳ Ꜵ Ꜷ Ꜹ Ꜻ Ꜽ Ꜿ Ꝁ Ꝃ Ꝅ Ꝇ Ꝉ Ꝋ Ꝍ Ꝏ Ꝑ Ꝓ Ꝕ Ꝗ Ꝙ Ꝛ Ꝝ Ꝟ Ꝡ Ꝣ Ꝥ Ꝧ Ꝩ Ꝫ Ꝭ Ꝯ Ꝺ Ꝼ Ᵹ Ꝿ Ꞁ Ꞃ Ꞅ Ꞇ Ꞌ Ɥ Ꞑ Ꞓ Ꞡ Ꞣ Ꞥ Ꞧ Ꞩ Ɦ Ａ Ｂ Ｃ Ｄ Ｅ Ｆ Ｇ Ｈ Ｉ Ｊ Ｋ Ｌ Ｍ Ｎ Ｏ Ｐ Ｑ Ｒ Ｓ Ｔ Ｕ Ｖ Ｗ Ｘ Ｙ Ｚ 𐐀 𐐁 𐐂 𐐃 𐐄 𐐅 𐐆 𐐇 𐐈 𐐉 𐐊 𐐋 𐐌 𐐍 𐐎 𐐏 𐐐 𐐑 𐐒 𐐓 𐐔 𐐕 𐐖 𐐗 𐐘 𐐙 𐐚 𐐛 𐐜 𐐝 𐐞 𐐟 𐐠 𐐡 𐐢 𐐣 𐐤 𐐥 𐐦 𐐧 𝐀 𝐁 𝐂 𝐃 𝐄 𝐅 𝐆 𝐇 𝐈 𝐉 𝐊 𝐋 𝐌 𝐍 𝐎 𝐏 𝐐 𝐑 𝐒 𝐓 𝐔 𝐕 𝐖 𝐗 𝐘 𝐙 𝐴 𝐵 𝐶 𝐷 𝐸 𝐹 𝐺 𝐻 𝐼 𝐽 𝐾 𝐿 𝑀 𝑁 𝑂 𝑃 𝑄 𝑅 𝑆 𝑇 𝑈 𝑉 𝑊 𝑋 𝑌 𝑍 𝑨 𝑩 𝑪 𝑫 𝑬 𝑭 𝑮 𝑯 𝑰 𝑱 𝑲 𝑳 𝑴 𝑵 𝑶 𝑷 𝑸 𝑹 𝑺 𝑻 𝑼 𝑽 𝑾 𝑿 𝒀 𝒁 𝒜 𝒞 𝒟 𝒢 𝒥 𝒦 𝒩 𝒪 𝒫 𝒬 𝒮 𝒯 𝒰 𝒱 𝒲 𝒳 𝒴 𝒵 𝓐 𝓑 𝓒 𝓓 𝓔 𝓕 𝓖 𝓗 𝓘 𝓙 𝓚 𝓛 𝓜 𝓝 𝓞 𝓟 𝓠 𝓡 𝓢 𝓣 𝓤 𝓥 𝓦 𝓧 𝓨 𝓩 𝔄 𝔅 𝔇 𝔈 𝔉 𝔊 𝔍 𝔎 𝔏 𝔐 𝔑 𝔒 𝔓 𝔔 𝔖 𝔗 𝔘 𝔙 𝔚 𝔛 𝔜 𝔸 𝔹 𝔻 𝔼 𝔽 𝔾 𝕀 𝕁 𝕂 𝕃 𝕄 𝕆 𝕊 𝕋 𝕌 𝕍 𝕎 𝕏 𝕐 𝕬 𝕭 𝕮 𝕯 𝕰 𝕱 𝕲 𝕳 𝕴 𝕵 𝕶 𝕷 𝕸 𝕹 𝕺 𝕻 𝕼 𝕽 𝕾 𝕿 𝖀 𝖁 𝖂 𝖃 𝖄 𝖅 𝖠 𝖡 𝖢 𝖣 𝖤 𝖥 𝖦 𝖧 𝖨 𝖩 𝖪 𝖫 𝖬 𝖭 𝖮 𝖯 𝖰 𝖱 𝖲 𝖳 𝖴 𝖵 𝖶 𝖷 𝖸 𝖹 𝗔 𝗕 𝗖 𝗗 𝗘 𝗙 𝗚 𝗛 𝗜 𝗝 𝗞 𝗟 𝗠 𝗡 𝗢 𝗣 𝗤 𝗥 𝗦 𝗧 𝗨 𝗩 𝗪 𝗫 𝗬 𝗭 𝘈 𝘉 𝘊 𝘋 𝘌 𝘍 𝘎 𝘏 𝘐 𝘑 𝘒 𝘓 𝘔 𝘕 𝘖 𝘗 𝘘 𝘙 𝘚 𝘛 𝘜 𝘝 𝘞 𝘟 𝘠 𝘡 𝘼 𝘽 𝘾 𝘿 𝙀 𝙁 𝙂 𝙃 𝙄 𝙅 𝙆 𝙇 𝙈 𝙉 𝙊 𝙋 𝙌 𝙍 𝙎 𝙏 𝙐 𝙑 𝙒 𝙓 𝙔 𝙕 𝙰 𝙱 𝙲 𝙳 𝙴 𝙵 𝙶 𝙷 𝙸 𝙹 𝙺 𝙻 𝙼 𝙽 𝙾 𝙿 𝚀 𝚁 𝚂 𝚃 𝚄 𝚅 𝚆 𝚇 𝚈 𝚉 𝚨 𝚩 𝚪 𝚫 𝚬 𝚭 𝚮 𝚯 𝚰 𝚱 𝚲 𝚳 𝚴 𝚵 𝚶 𝚷 𝚸 𝚹 𝚺 𝚻 𝚼 𝚽 𝚾 𝚿 𝛀 𝛢 𝛣 𝛤 𝛥 𝛦 𝛧 𝛨 𝛩 𝛪 𝛫 𝛬 𝛭 𝛮 𝛯 𝛰 𝛱 𝛲 𝛳 𝛴 𝛵 𝛶 𝛷 𝛸 𝛹 𝛺 𝜜 𝜝 𝜞 𝜟 𝜠 𝜡 𝜢 𝜣 𝜤 𝜥 𝜦 𝜧 𝜨 𝜩 𝜪 𝜫 𝜬 𝜭 𝜮 𝜯 𝜰 𝜱 𝜲 𝜳 𝜴 𝝖 𝝗 𝝘 𝝙 𝝚 𝝛 𝝜 𝝝 𝝞 𝝟 𝝠 𝝡 𝝢 𝝣 𝝤 𝝥 𝝦 𝝧 𝝨 𝝩 𝝪 𝝫 𝝬 𝝭 𝝮 𝞐 𝞑 𝞒 𝞓 𝞔 𝞕 𝞖 𝞗 𝞘 𝞙 𝞚 𝞛 𝞜 𝞝 𝞞 𝞟 𝞠 𝞡 𝞢 𝞣 𝞤 𝞥 𝞦 𝞧 𝞨 𝟊\nTitlecase: Dž Lj Nj Dz ᾈ ᾉ ᾊ ᾋ ᾌ ᾍ ᾎ ᾏ ᾘ ᾙ ᾚ ᾛ ᾜ ᾝ ᾞ ᾟ ᾨ ᾩ ᾪ ᾫ ᾬ ᾭ ᾮ ᾯ ᾼ ῌ ῼ\n```"}]}
{"messages": [{"role": "user", "content": "**Idoneal numbers** (also called **suitable** numbers or **convenient** numbers) are the positive integers **D** such that any integer expressible in only one way as **x2 ± Dy2** (where **x2** is relatively prime to **Dy2**) is a prime power or twice a prime power.\n\nA positive integer **n** is idoneal if and only if it cannot be written as **ab + bc + ac** for distinct positive integers **a**, **b**, and **c** with **0 < a < b < c**.\n\nThere are only **65** known iodoneal numbers and is likely that no others exist. If there *are* others, it has been proven that there are at most, two more, and that no others exist below 1,000,000.\n\nTask\n\n* Find and display at least the first **50** idoneal numbers (between 1 and 255).\n\nStretch\n\n* Find and display all **65** known idoneal numbers.\n\nSee also\n\n* Wikipedia: Idoneal numbers * OEIS:A000926 - Euler's \"numerus idoneus\" (or \"numeri idonei\", or idoneal, or suitable, or convenient numbers) * O'Halloran numbers"}, {"role": "assistant", "content": "First 60 in less than 1/2 second. The remaining 5 take another ~5 seconds.\n\n```\nsub is-idoneal ($n) {\n    my $idoneal = True;\n    I: for 1 .. $n -> $a {\n        for $a ^.. $n -> $b {\n            last if $a × $b + $a + $b > $n; # short circuit\n            for $b ^.. $n -> $c {\n                $idoneal = False and last I if (my $sum = $a × $b + $b × $c + $c × $a) == $n;\n                last if $sum > $n; # short circuit\n            }\n        }\n    }\n    $idoneal\n}\n\n$_».fmt(\"%4d\").put for (1..1850).hyper(:32batch).grep( &is-idoneal ).batch(10)\n\n```\n\nOutput:\n\n```\n   1    2    3    4    5    6    7    8    9   10\n  12   13   15   16   18   21   22   24   25   28\n  30   33   37   40   42   45   48   57   58   60\n  70   72   78   85   88   93  102  105  112  120\n 130  133  165  168  177  190  210  232  240  253\n 273  280  312  330  345  357  385  408  462  520\n 760  840 1320 1365 1848\n```"}]}
{"messages": [{"role": "user", "content": "One class of image digital filters is described by a rectangular matrix of real coefficients called kernel convoluted in a sliding window of image pixels. Usually the kernel is square \n\nK\n\nk\nl\n{\\displaystyle {\\displaystyle K\\_{kl}}}\n, where *k*, *l* are in the range -*R*,-*R*+1,..,*R*-1,*R*. *W*=2*R*+1 is the kernel width.\n\nThe filter determines the new value of a **grayscale image** pixel P*ij* as a convolution of the image pixels in the window centered in *i*, *j* and the kernel values:\n\n> P\n>\n> i\n> j\n> =\n>\n>\n> ∑\n>\n> k\n> =\n> −\n> R\n>\n> R\n>\n> ∑\n>\n> l\n> =\n> −\n> R\n>\n> R\n>\n> P\n>\n> i\n> +\n> k\n>  \n> j\n> +\n> l\n>\n> K\n>\n> k\n> l\n> {\\displaystyle {\\displaystyle P\\_{ij}=\\displaystyle \\sum \\_{k=-R}^{R}\\sum \\_{l=-R}^{R}P\\_{i+k\\ j+l}K\\_{kl}}}\n\n**Color images** are usually split into the channels which are filtered independently. A color model can be changed as well, i.e. filtration is performed not necessarily in RGB. Common kernels sizes are 3x3 and 5x5. The complexity of filtrating grows quadratically (O(*n*2)) with the kernel width.\n\n**Task**: Write a generic convolution 3x3 kernel filter. Optionally show some end user filters that use this generic one.\n\n*(You can use, to test the functions below, these input and output solutions.)*"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Perl 5 PDL library\n\n```\nuse PDL:from<Perl5>;\nuse PDL::Image2D:from<Perl5>;\n\nmy $kernel = pdl [[-2, -1, 0],[-1, 1, 1], [0, 1, 2]]; # emboss\n\nmy $image = rpic 'frog.png';\nmy $smoothed = conv2d $image, $kernel, {Boundary => 'Truncate'};\nwpic $smoothed, 'frog_convolution.png';\n\n```\n\nCompare offsite images: frog.png vs.\nfrog\\_convolution.png\n\n### Imagemagick library\n\n```\n# Note: must install version from github NOT version from CPAN which needs to be updated. \n# Reference:\n# https://github.com/azawawi/perl6-magickwand\n# http://www.imagemagick.org/Usage/convolve/\n \nuse v6;\n \nuse MagickWand;\n \n# A new magic wand\nmy $original = MagickWand.new;\n \n# Read an image\n$original.read(\"./Lenna100.jpg\") or die;\n \nmy $o = $original.clone;\n \n# using coefficients from kernel \"Sobel\"\n# http://www.imagemagick.org/Usage/convolve/#sobel\n$o.convolve( [ 1, 0, -1,\n               2, 0, -2,\n               1, 0, -1] );\n \n$o.write(\"Lenna100-convoluted.jpg\") or die;\n \n# And cleanup on exit\nLEAVE {\n  $original.cleanup   if $original.defined;\n  $o.cleanup if $o.defined;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Generate a random black and white   **320**x**240**   image continuously,\nshowing FPS (frames per second).\n\nA sample image\n:   sample"}, {"role": "assistant", "content": "(formerly Perl 6)\nVariant of a script packaged with the SDL2::Raw module.\n\n```\nuse NativeCall;\nuse SDL2::Raw;\n\nmy int ($w, $h) = 320, 240;\n\nSDL_Init(VIDEO);\n\nmy SDL_Window $window = SDL_CreateWindow(\n    \"White Noise - Raku\",\n    SDL_WINDOWPOS_CENTERED_MASK, SDL_WINDOWPOS_CENTERED_MASK,\n    $w, $h,\n    RESIZABLE\n);\n\nmy SDL_Renderer $renderer = SDL_CreateRenderer( $window, -1, ACCELERATED +| TARGETTEXTURE );\n\nmy $noise_texture = SDL_CreateTexture($renderer, %PIXELFORMAT<RGB332>, STREAMING, $w, $h);\n\nmy $pixdatabuf = CArray[int64].new(0, $w, $h, $w);\n\nsub render {\n    my int $pitch;\n    my int $cursor;\n\n    # work-around to pass the pointer-pointer.\n    my $pixdata = nativecast(Pointer[int64], $pixdatabuf);\n    SDL_LockTexture($noise_texture, SDL_Rect, $pixdata, $pitch);\n\n    $pixdata = nativecast(CArray[int8], Pointer.new($pixdatabuf[0]));\n\n    loop (my int $row; $row < $h; $row = $row + 1) {\n        loop (my int $col; $col < $w; $col = $col + 1) {\n            $pixdata[$cursor + $col] = Bool.roll ?? 0xff !! 0x0;\n        }\n        $cursor = $cursor + $pitch;\n    }\n\n    SDL_UnlockTexture($noise_texture);\n\n    SDL_RenderCopy($renderer, $noise_texture, SDL_Rect, SDL_Rect);\n    SDL_RenderPresent($renderer);\n}\n\nmy $event = SDL_Event.new;\n\nmain: loop {\n\n    while SDL_PollEvent($event) {\n        my $casted_event = SDL_CastEvent($event);\n\n        given $casted_event {\n            when *.type == QUIT {\n                last main;\n            }\n        }\n    }\n\n    render();\n    print fps;\n}\n\nsay '';\n\nsub fps {\n    state $fps-frames = 0;\n    state $fps-now    = now;\n    state $fps        = '';\n    $fps-frames++;\n    if now - $fps-now >= 1 {\n        $fps = [~] \"\\b\" x 40, ' ' x 20, \"\\b\" x 20 ,\n            sprintf \"FPS: %5.2f  \", ($fps-frames / (now - $fps-now)).round(.01);\n        $fps-frames = 0;\n        $fps-now = now;\n    }\n    $fps\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Imaginary base numbers are a non-standard positional numeral system which uses an imaginary number as its radix. The most common is quater-imaginary with radix 2i.\n\n*The quater-imaginary numeral system was first proposed by Donald Knuth in 1955 as a submission for a high school science talent search. [Ref.]*\n\nOther imaginary bases are possible too but are not as widely discussed and aren't specifically named.\n\n**Task:** Write a set of procedures (functions, subroutines, however they are referred to in your language) to convert base 10 numbers to an imaginary base and back.\n\nAt a minimum, support quater-imaginary (base 2i).\n\nFor extra kudos, support positive or negative bases 2i through 6i (or higher).\n\nAs a stretch goal, support converting non-integer numbers ( E.G. 227.65625+10.859375i ) to an imaginary base.\n\nSee Wikipedia: Quater-imaginary\\_base for more details.\n\nFor reference, here are some some decimal and complex numbers converted to quater-imaginary.\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| | Base 10 | Base 2*i* | | --- | --- | | 1 | 1 | | 2 | 2 | | 3 | 3 | | 4 | 10300 | | 5 | 10301 | | 6 | 10302 | | 7 | 10303 | | 8 | 10200 | | 9 | 10201 | | 10 | 10202 | | 11 | 10203 | | 12 | 10100 | | 13 | 10101 | | 14 | 10102 | | 15 | 10103 | | 16 | 10000 | | | Base 10 | Base 2*i* | | --- | --- | | −1 | 103 | | −2 | 102 | | −3 | 101 | | −4 | 100 | | −5 | 203 | | −6 | 202 | | −7 | 201 | | −8 | 200 | | −9 | 303 | | −10 | 302 | | −11 | 301 | | −12 | 300 | | −13 | 1030003 | | −14 | 1030002 | | −15 | 1030001 | | −16 | 1030000 | | | Base 10 | Base 2*i* | | --- | --- | | 1*i* | 10.2 | | 2*i* | 10.0 | | 3*i* | 20.2 | | 4*i* | 20.0 | | 5*i* | 30.2 | | 6*i* | 30.0 | | 7*i* | 103000.2 | | 8*i* | 103000.0 | | 9*i* | 103010.2 | | 10*i* | 103010.0 | | 11*i* | 103020.2 | | 12*i* | 103020.0 | | 13*i* | 103030.2 | | 14*i* | 103030.0 | | 15*i* | 102000.2 | | 16*i* | 102000.0 | | | Base 10 | Base 2*i* | | --- | --- | | −1*i* | 0.2 | | −2*i* | 1030.0 | | −3*i* | 1030.2 | | −4*i* | 1020.0 | | −5*i* | 1020.2 | | −6*i* | 1010.0 | | −7*i* | 1010.2 | | −8*i* | 1000.0 | | −9*i* | 1000.2 | | −10*i* | 2030.0 | | −11*i* | 2030.2 | | −12*i* | 2020.0 | | −13*i* | 2020.2 | | −14*i* | 2010.0 | | −15*i* | 2010.2 | | −16*i* | 2000.0 | |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Explicit\n\n**Works with**: Rakudo version 2017.01\n\nThese are generalized imaginary-base conversion routines. They only work for imaginary bases, not complex. (Any real portion of the radix must be zero.) Theoretically they could be made to work for any imaginary base; in practice, they are limited to integer bases from -6i to -2i and 2i to 6i. Bases -1i and 1i exist but require special handling and are not supported. Bases larger than 6i (or -6i) require digits outside of base 36 to express them, so aren't as standardized, are implementation dependent and are not supported. Note that imaginary number coefficients are stored as floating point numbers in Raku so some rounding error may creep in during calculations. The precision these conversion routines use is configurable; we are using 6 decimal, um... radicimal(?) places of precision here.\n\nImplements minimum, extra kudos and stretch goals.\n\n```\nmulti sub base ( Real $num, Int $radix where -37 < * < -1, :$precision = -15 ) {\n    return '0' unless $num;\n    my $value  = $num;\n    my $result = '';\n    my $place  = 0;\n    my $upper-bound = 1 / (-$radix + 1);\n    my $lower-bound = $radix * $upper-bound;\n\n    $value = $num / $radix ** ++$place until $lower-bound <= $value < $upper-bound;\n\n    while ($value or $place > 0) and $place > $precision {\n        my $digit = ($radix * $value - $lower-bound).Int;\n        $value    =  $radix * $value - $digit;\n        $result ~= '.' unless $place or $result.contains: '.';\n        $result ~= $digit == -$radix ?? ($digit-1).base(-$radix)~'0' !! $digit.base(-$radix);\n        $place--\n    }\n    $result\n}\n\nmulti sub base (Numeric $num, Complex $radix where *.re == 0, :$precision = -8 ) {\n    die \"Base $radix out of range\" unless -6 <= $radix.im <= -2 or 2 <= $radix.im <= 6;\n    my ($re, $im) = $num.Complex.reals;\n    my ($re-wh, $re-fr) =             $re.&base( -$radix.im².Int, :precision($precision) ).split: '.';\n    my ($im-wh, $im-fr) = ($im/$radix.im).&base( -$radix.im².Int, :precision($precision) ).split: '.';\n    $_ //= '' for $re-fr, $im-fr;\n\n    sub zip (Str $a, Str $b) {\n        my $l = '0' x ($a.chars - $b.chars).abs;\n        ([~] flat ($a~$l).comb Z flat ($b~$l).comb).subst(/ '0'+ $ /, '') || '0'\n    }\n\n    my $whole = flip zip $re-wh.flip, $im-wh.flip;\n    my $fraction = zip $im-fr, $re-fr;\n    $fraction eq 0 ?? \"$whole\" !! \"$whole.$fraction\"\n}\n\nmulti sub parse-base (Str $str, Complex $radix where *.re == 0) {\n    return -1 * $str.substr(1).&parse-base($radix) if $str.substr(0,1) eq '-';\n    my ($whole, $frac) = $str.split: '.';\n    my $fraction = 0;\n    $fraction = [+] $frac.comb.kv.map: { $^v.parse-base($radix.im².Int) * $radix ** -($^k+1) } if $frac;\n    $fraction + [+] $whole.flip.comb.kv.map: { $^v.parse-base($radix.im².Int) * $radix ** $^k }\n}\n\n# TESTING\nfor 0, 2i, 1, 2i, 5, 2i, -13, 2i, 9i, 2i, -3i, 2i, 7.75-7.5i, 2i, .25, 2i, # base 2i tests\n    5+5i,  2i, 5+5i,  3i, 5+5i,  4i, 5+5i,  5i, 5+5i,  6i, # same value, positive imaginary bases\n    5+5i, -2i, 5+5i, -3i, 5+5i, -4i, 5+5i, -5i, 5+5i, -6i, # same value, negative imaginary bases\n    227.65625+10.859375i, 4i, # larger test value\n    31433.3487654321-2902.4480452675i, 6i # heh\n  -> $v, $r {\nmy $ibase = $v.&base($r, :precision(-6));\nprintf \"%33s.&base\\(%2si\\) = %-11s : %13s.&parse-base\\(%2si\\) = %s\\n\",\n  $v, $r.im, $ibase, \"'$ibase'\", $r.im, $ibase.&parse-base($r).round(1e-10).narrow;\n}\n\n```\n\nOutput:\n\n```\n                                0.&base( 2i) = 0           :           '0'.&parse-base( 2i) = 0\n                                1.&base( 2i) = 1           :           '1'.&parse-base( 2i) = 1\n                                5.&base( 2i) = 10301       :       '10301'.&parse-base( 2i) = 5\n                              -13.&base( 2i) = 1030003     :     '1030003'.&parse-base( 2i) = -13\n                             0+9i.&base( 2i) = 103010.2    :    '103010.2'.&parse-base( 2i) = 0+9i\n                            -0-3i.&base( 2i) = 1030.2      :      '1030.2'.&parse-base( 2i) = 0-3i\n                        7.75-7.5i.&base( 2i) = 11210.31    :    '11210.31'.&parse-base( 2i) = 7.75-7.5i\n                             0.25.&base( 2i) = 1.03        :        '1.03'.&parse-base( 2i) = 0.25\n                             5+5i.&base( 2i) = 10331.2     :     '10331.2'.&parse-base( 2i) = 5+5i\n                             5+5i.&base( 3i) = 25.3        :        '25.3'.&parse-base( 3i) = 5+5i\n                             5+5i.&base( 4i) = 25.C        :        '25.C'.&parse-base( 4i) = 5+5i\n                             5+5i.&base( 5i) = 15          :          '15'.&parse-base( 5i) = 5+5i\n                             5+5i.&base( 6i) = 15.6        :        '15.6'.&parse-base( 6i) = 5+5i\n                             5+5i.&base(-2i) = 11321.2     :     '11321.2'.&parse-base(-2i) = 5+5i\n                             5+5i.&base(-3i) = 1085.6      :      '1085.6'.&parse-base(-3i) = 5+5i\n                             5+5i.&base(-4i) = 10F5.4      :      '10F5.4'.&parse-base(-4i) = 5+5i\n                             5+5i.&base(-5i) = 10O5        :        '10O5'.&parse-base(-5i) = 5+5i\n                             5+5i.&base(-6i) = 5.U         :         '5.U'.&parse-base(-6i) = 5+5i\n             227.65625+10.859375i.&base( 4i) = 10234.5678  :  '10234.5678'.&parse-base( 4i) = 227.65625+10.859375i\n31433.3487654321-2902.4480452675i.&base( 6i) = PERL6.ROCKS : 'PERL6.ROCKS'.&parse-base( 6i) = 31433.3487654321-2902.4480452675i\n```\n\n### Module\n\n**Works with**: Rakudo version 2020.02\n\nUsing the module Base::Any from the Raku ecosystem.\n\nDoes everything the explicit version does but also handles a **much** larger range of imaginary bases.\n\nDoing pretty much the same tests as the explicit version.\n\n```\nuse Base::Any;\n\n# TESTING\nfor 0, 2i, 1, 2i, 5, 2i, -13, 2i, 9i, 2i, -3i, 2i, 7.75-7.5i, 2i, .25, 2i, # base 2i tests\n    5+5i,  2i, 5+5i,  3i, 5+5i,  4i, 5+5i,  5i, 5+5i,  6i, # same value, positive imaginary bases\n    5+5i, -2i, 5+5i, -3i, 5+5i, -4i, 5+5i, -5i, 5+5i, -6i, # same value, negative imaginary bases\n    227.65625+10.859375i, 4i, # larger test value\n    31433.3487654321-2902.4480452675i, 6i, # heh\n    -3544.29+26541.468i, -10i\n  -> $v, $r {\n    my $ibase = $v.&to-base($r, :precision(-6));\n    printf \"%33s.&to-base\\(%3si\\) = %-11s : %13s.&from-base\\(%3si\\) = %s\\n\",\n    $v, $r.im, $ibase, \"'$ibase'\", $r.im, $ibase.&from-base($r).round(1e-10).narrow;\n}\n\n```\n\nOutput:\n\n```\n                                0.&to-base(  2i) = 0           :           '0'.&from-base(  2i) = 0\n                                1.&to-base(  2i) = 1           :           '1'.&from-base(  2i) = 1\n                                5.&to-base(  2i) = 10301       :       '10301'.&from-base(  2i) = 5\n                              -13.&to-base(  2i) = 1030003     :     '1030003'.&from-base(  2i) = -13\n                             0+9i.&to-base(  2i) = 103010.2    :    '103010.2'.&from-base(  2i) = 0+9i\n                            -0-3i.&to-base(  2i) = 1030.2      :      '1030.2'.&from-base(  2i) = 0-3i\n                        7.75-7.5i.&to-base(  2i) = 11210.31    :    '11210.31'.&from-base(  2i) = 7.75-7.5i\n                             0.25.&to-base(  2i) = 1.03        :        '1.03'.&from-base(  2i) = 0.25\n                             5+5i.&to-base(  2i) = 10331.2     :     '10331.2'.&from-base(  2i) = 5+5i\n                             5+5i.&to-base(  3i) = 25.3        :        '25.3'.&from-base(  3i) = 5+5i\n                             5+5i.&to-base(  4i) = 25.C        :        '25.C'.&from-base(  4i) = 5+5i\n                             5+5i.&to-base(  5i) = 15          :          '15'.&from-base(  5i) = 5+5i\n                             5+5i.&to-base(  6i) = 15.6        :        '15.6'.&from-base(  6i) = 5+5i\n                             5+5i.&to-base( -2i) = 11321.2     :     '11321.2'.&from-base( -2i) = 5+5i\n                             5+5i.&to-base( -3i) = 1085.6      :      '1085.6'.&from-base( -3i) = 5+5i\n                             5+5i.&to-base( -4i) = 10F5.4      :      '10F5.4'.&from-base( -4i) = 5+5i\n                             5+5i.&to-base( -5i) = 10O5        :        '10O5'.&from-base( -5i) = 5+5i\n                             5+5i.&to-base( -6i) = 5.U         :         '5.U'.&from-base( -6i) = 5+5i\n             227.65625+10.859375i.&to-base(  4i) = 10234.5678  :  '10234.5678'.&from-base(  4i) = 227.65625+10.859375i\n31433.3487654321-2902.4480452675i.&to-base(  6i) = PERL6.ROCKS : 'PERL6.ROCKS'.&from-base(  6i) = 31433.3487654321-2902.4480452675i\n              -3544.29+26541.468i.&to-base(-10i) = Raku.FTW    :    'Raku.FTW'.&from-base(-10i) = -3544.29+26541.468i\n```"}]}
{"messages": [{"role": "user", "content": "Some programming languages have implicit type conversion. Type conversion is also known as *coercion*.\n\nFor example:\n\n```\nCOMPL z := 1;\n```\n\nHere the assignment \"**:=**\" implicitly converts the **integer** 1, to the **complex** number\n\n1\n+\n0\ni\n{\\displaystyle {\\displaystyle 1+0i}}\n\nin the programming language ALGOL 68.\n\nThe alternative would be to *explicitly* convert a value from one type to another, using a *function* or some other mechanism (e.g. an explicit cast).\n\nTask\n\nDemonstrate various type conversions and give an example of an *implicit type conversion* path from the smallest possible variable size to the largest possible variable size. (Where the size of the underlying variable's data strictly increases).\n\nIn strongly typed languages *some* types are actually mutually incompatible. In this case the language may have disjoint type conversion paths, or even branching type conversion paths. Give an example if your language does this.\n\nLanguages that don't support *any* *implicit type conversion* can be added to the /Omit category.\n\nIndicate if your language supports *user defined* type conversion definitions and give an example of such a definition.   (E.g. define an *implicit type conversion* from **real** to **complex** numbers, or from **char** to an array of **char** of length 1.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku was designed with a specific goal of maximizing the principle of DWIM (Do What I Mean) while simultaneously minimizing the principle of DDWIDM (Don't Do What I Don't Mean). Implicit type conversion is a natural and basic feature.\n\nVariable names in Raku are prepended with a sigil.\nThe most basic variable container type is a scalar, with the sigil dollar sign: $x.\nA single scalar variable in list context will be converted to a list of one element regardless of the variables structure.\n(A scalar variable may be bound to any object, including a collective object.\nA scalar variable is always treated as a singular item, regardless of whether the object is essentially composite or unitary.\nThere is no implicit conversion from singular to plural; a plural object within a singular container must be explicitly decontainerized somehow.\nUse of a subscript is considered sufficiently explicit though.)\n\nThe type of object contained in a scalar depends on how you assign it and how you use it.\n\n```\nmy $x;\n\n$x = 1234;      say $x.WHAT; # (Int) Integer\n$x = 12.34;     say $x.WHAT; # (Rat) Rational\n$x = 1234e-2;   say $x.WHAT; # (Num) Floating point Number\n$x = 1234+i;    say $x.WHAT; # (Complex)\n$x = '1234';    say $x.WHAT; # (Str) String\n$x = (1,2,3,4); say $x.WHAT; # (List)\n$x = [1,2,3,4]; say $x.WHAT; # (Array)\n$x = 1 .. 4;    say $x.WHAT; # (Range)\n$x = (1 => 2);  say $x.WHAT; # (Pair)\n$x = {1 => 2};  say $x.WHAT; # (Hash)\n$x = {1, 2};    say $x.WHAT; # (Block)\n$x = sub {1};   say $x.WHAT; # (Sub) Code Reference\n$x = True;      say $x.WHAT; # (Bool) Boolean\n\n```\n\nObjects may be converted between various types many times during an operation. Consider the following line of code.\n\n```\nsay :16(([+] 1234.ords).sqrt.floor ~ \"beef\");\n\n```\n\nIn English: Take the floor of the square root of the sum of the ordinals of the digits of the integer 1234, concatenate that number with the string 'beef', interpret the result as a hexadecimal number and print it.\n\nBroken down step by step:\n\n```\nmy $x = 1234;                                  say $x, ' ', $x.WHAT; # 1234 (Int)\n$x = 1234.ords;                                say $x, ' ', $x.WHAT; # 49 50 51 52 (List)\n$x = [+] 1234.ords;                            say $x, ' ', $x.WHAT; # 202 (Int)\n$x = ([+] 1234.ords).sqrt;                     say $x, ' ', $x.WHAT; # 14.2126704035519 (Num)\n$x = ([+] 1234.ords).sqrt.floor;               say $x, ' ', $x.WHAT; # 14 (Int)\n$x = ([+] 1234.ords).sqrt.floor ~ \"beef\";      say $x, ' ', $x.WHAT; # 14beef (Str)\n$x = :16(([+] 1234.ords).sqrt.floor ~ \"beef\"); say $x, ' ', $x.WHAT; # 1359599 (Int)\n\n```\n\nSome types are not implicitly converted.\nFor instance, you must explicitly request and cast to Complex numbers and FatRat numbers.\n(A normal Rat number has a denominator that is limited to 64 bits, with underflow to floating point to prevent performance degradation; a FatRat, in contrast, has an unlimited denominator size, and can chew up all your memory if you're not careful.)\n\n```\nmy $x;\n$x = (-1).sqrt;           say $x, ' ', $x.WHAT; # NaN (Num)\n$x = (-1).Complex.sqrt;   say $x, ' ', $x.WHAT; # 6.12323399573677e-17+1i (Complex)\n\n$x = (22/7) * 2;          say $x, ' ', $x.WHAT; # 6.285714 (Rat)\n$x /= 10**10;             say $x, ' ', $x.WHAT; # 0.000000000629 (Rat)\n$x /= 10**10;             say $x, ' ', $x.WHAT; # 6.28571428571429e-20 (Num)\n\n$x = (22/7).FatRat * 2;   say $x, ' ', $x.WHAT; # 6.285714 (FatRat)\n$x /= 10**10;             say $x, ' ', $x.WHAT; # 0.000000000629 (FatRat)\n$x /= 10**10;             say $x, ' ', $x.WHAT; # 0.0000000000000000000629 (FatRat)\n\n```\n\nUser defined types will support implicit casting if the object has Bridge method that tells it how to do so, or if the operators in question supply multiple dispatch variants that allow for coercions.\nNote that Raku does not support implicit assignment coercion to typed variables.\nHowever, different-sized storage types (int16, int32, int64, for example) are not considered different types, and such assignment merely enforces a constraint that will throw an exception if the size is exceeded. (The calculations on the right side of the assignment are done in an arbitrarily large type such as Int.)\n\nTypes may be explicitly cast by using a bridge method (.Int, .Rat, .Str, whatever) or by using a coercion operator:\n\n```\n    + or -      numify\n    ~           stringify\n    ? or !      boolify\n    i (postfix) complexify\n    $()         singularize\n    @()         pluralize\n    %()         hashify\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate the language's ability to include source code from other files.\n\nSee Also\n\n* Compiler/Simple file inclusion pre processor"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku provides a module system that is based primarily on importation of symbols rather than\non inclusion of textual code:\n\n```\nuse MyModule;\n```\n\nHowever, one can evaluate code from a file:\n\n```\nrequire 'myfile.p6';\n```\n\nOne can even do that at compile time:\n\n```\nBEGIN require 'myfile.p6'\n```\n\nNone of these are true inclusion, unless the require cheats and modifies the current input string of the parser. To get a true textual inclusion, one could define an unhygienic textual macro like this:\n\n```\nmacro include(AST $file) { slurp $file.eval }\ninclude('myfile.p6');\n```"}]}
{"messages": [{"role": "user", "content": "A consummate number is a non-negative integer that can be formed by some integer **N** divided by the the digital sum of **N**.\n\nFor instance\n\n**47** is a consummate number.\n\n```\n   846 / (8 + 4 + 6) = 47\n\n```\n\nOn the other hand, there are integers that *can not* be formed by a ratio of **any** integer over its digital sum. These numbers are known as **inconsummate numbers**.\n\n**62** is an inconsummate number. There is **no** integer ratio of an integer to its digital sum that will result in **62**.\n\n*The base that a number is expressed in will affect whether it is inconsummate or not. This task will be restricted to base 10.*\n\nTask\n\n* Write a routine to find inconsummate numbers in base 10;\n* Use that routine to find and display the first fifty inconsummate numbers.\n\nStretch\n\n* Use that routine to find and display the one thousandth inconsummate number.\n\nSee also\n\n* Numbers Aplenty - Inconsummate numbers * OEIS:A003635 - Inconsummate numbers in base 10"}, {"role": "assistant", "content": "Not really pleased with this entry. It *works*, but seems inelegant.\n\n```\nmy $upto = 1000;\n\nmy @ratios = unique (^∞).race.map({($_ / .comb.sum).narrow})[^($upto²)].grep: Int;\nmy @incons = (sort keys (1..$upto * 10) (-) @ratios)[^$upto];\n\nput \"First fifty inconsummate numbers (in base 10):\\n\" ~ @incons[^50]».fmt(\"%3d\").batch(10).join: \"\\n\";\nput \"\\nOne thousandth: \" ~ @incons[999]\n\n```\n\nOutput:\n\n```\nFirst fifty inconsummate numbers (in base 10):\n 62  63  65  75  84  95 161 173 195 216\n261 266 272 276 326 371 372 377 381 383\n386 387 395 411 416 422 426 431 432 438\n441 443 461 466 471 476 482 483 486 488\n491 492 493 494 497 498 516 521 522 527\n\nOne thousandth: 6996\n```"}]}
{"messages": [{"role": "user", "content": "Note:   **Niven**   numbers are also called   **Harshad**   numbers.\n\n:   :   :   :   They are also called    **multidigital**   numbers.\n\n**Niven** numbers are positive integers which are evenly divisible by the sum of its\ndigits   (expressed in base ten).\n\n*Evenly divisible*   means   *divisible with no remainder*.\n\nTask\n:   * find the gap (difference) of a Niven number from the previous Niven number\n    * if the gap is   *larger*   than the (highest) previous gap,   then:\n\n    :   :   * show the index (occurrence) of the gap     (the 1st gap is   **1**)\n            * show the index of the Niven number that starts the gap     (1st Niven number is   **1**,   33rd Niven number is   **100**)\n            * show the Niven number that starts the gap\n            * show all numbers with comma separators where appropriate   (optional)\n            * I.E.:   the gap size of   **60**   starts at the   33,494th   Niven number which is Niven number   **297,864**\n\n    * show all increasing gaps up to the   ten millionth   (**10,000,000th**)   Niven number\n    * (optional)   show all gaps up to whatever limit is feasible/practical/realistic/reasonable/sensible/viable on your computer\n    * show all output here, on this page\n\nRelated task\n:   * Harshad or Niven series.\n\nAlso see\n:   * Journal of Integer Sequences, Vol. 6 (2004), Article 03.2.5, Large and Small Gaps Between Consecutive Niven Numbers.\n    * (PDF) version of the (above) article by Doyon."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\n```\nuse Lingua::EN::Numbers;\n\nunit sub MAIN (Int $threshold = 10000000);\n\nmy int $index = 0;\nmy int $last  = 0;\nmy int $gap   = 0;\n\nsay 'Gap    Index of gap  Starting Niven';\n\nfor 1..* -> \\count {\n    next unless count %% sum count.comb;\n    if (my \\diff = count - $last) > $gap {\n        $gap = diff;\n        printf \"%3d %15s %15s\\n\", $gap, comma($index || 1), comma($last || 1);\n    }\n    ++$index;\n    $last = count;\n    last if $index >= $threshold;\n}\n\n```\n\nOutput:\n\n```\nGap    Index of gap  Starting Niven\n  1               1               1\n  2              10              10\n  6              11              12\n  7              26              63\n  8              28              72\n 10              32              90\n 12              83             288\n 14             102             378\n 18             143             558\n 23             561           2,889\n 32             716           3,784\n 36           1,118           6,480\n 44           2,948          19,872\n 45           4,194          28,971\n 54           5,439          38,772\n 60          33,494         297,864\n 66          51,544         478,764\n 72          61,588         589,860\n 88          94,748         989,867\n 90         265,336       2,879,865\n 99         800,054       9,898,956\n108       3,750,017      49,989,744\n126       6,292,149      88,996,914\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nIncrement a numerical string."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsay my $s = \"12345\";\nsay ++$s;\n\n# or Unicode. How about Sinhala?\n\nsay \"෧෨෩෪෫ \", +\"෧෨෩෪෫\";\nsay \"෧෨෩෪෫\".succ, ' ', +\"෧෨෩෪෫\".succ;\n```\n\nOutput:\n\n```\n12345\n12346\n෧෨෩෪෫ 12345\n෧෨෩෪෬ 12346\n```"}]}
{"messages": [{"role": "user", "content": "It is known that the set of finite lists of positive integers is   countable.\n\nThis means that there exists a subset of natural integers which can be mapped to the set of finite lists of positive integers.\n\nTask\n\nImplement such a mapping:\n\n:   * write a function     *rank*     which assigns an integer to any finite, arbitrarily long list of arbitrary large positive integers.\n    * write a function   *unrank*   which is the   *rank*   inverse function.\n\nDemonstrate your solution by:\n\n:   * picking a random-length list of random positive integers\n    * turn it into an integer,   and\n    * get the list back.\n\nThere are many ways to do this.   Feel free to choose any one you like.\n\nExtra credit\n\nMake the   *rank*   function as a   bijection   and show   *unrank(n)*   for   **n**   varying from   **0**   to   **10**."}, {"role": "assistant", "content": "(formerly Perl 6)\nHere is a cheap solution using a base-11 encoding and string operations:\n\n```\nsub rank(*@n)      { :11(@n.join('A')) }\nsub unrank(Int $n) { $n.base(11).split('A') }\n\nsay my @n = (1..20).roll(12);\nsay my $n = rank(@n);\nsay unrank $n;\n\n```\n\nOutput:\n\n```\n1 11 16 1 3 9 0 2 15 7 19 10\n25155454474293912130094652799\n1 11 16 1 3 9 0 2 15 7 19 10\n```\n\nHere is a bijective solution that does not use string operations.\n\n```\nmulti infix:<rad> ()       { 0 }\nmulti infix:<rad> ($a)     { $a }\nmulti infix:<rad> ($a, $b) { $a * $*RADIX + $b }\n \nmulti expand(Int $n is copy, 1) { $n }\nmulti expand(Int $n is copy, Int $*RADIX) {\n    my \\RAD = $*RADIX;\n \n    my @reversed-digits = gather while $n > 0 {\n\ttake $n % RAD;\n\t$n div= RAD;\n    }\n \n    eager for ^RAD {\n\t[rad] reverse @reversed-digits[$_, * + RAD ... *]\n    }\n}\n \nmulti compress(@n where @n == 1) { @n[0] }\nmulti compress(@n is copy) {\n    my \\RAD = my $*RADIX = @n.elems;\n \n    [rad] reverse gather while @n.any > 0 {\n\t    (state $i = 0) %= RAD;\n\t    take @n[$i] % RAD;\n\t    @n[$i] div= RAD;\n\t    $i++;\n\t}\n}\n \nsub rank(@n) { compress (compress(@n), @n - 1)}\nsub unrank(Int $n) { my ($a, $b) = expand $n, 2; expand $a, $b + 1 }\n\nmy @list = (^10).roll((2..20).pick);\nmy $rank = rank @list;\nsay \"[$@list] -> $rank -> [{unrank $rank}]\";\n\nfor ^10 {\n    my @unrank = unrank $_;\n    say \"$_ -> [$@unrank] -> {rank @unrank}\";\n}\n\n```\n\nOutput:\n\n```\n[7 1 4 7 7 0 2 7 7 0 7 7] -> 20570633300796394530947471 -> [7 1 4 7 7 0 2 7 7 0 7 7]\n0 -> [0] -> 0\n1 -> [1] -> 1\n2 -> [0 0] -> 2\n3 -> [1 0] -> 3\n4 -> [2] -> 4\n5 -> [3] -> 5\n6 -> [0 1] -> 6\n7 -> [1 1] -> 7\n8 -> [0 0 0] -> 8\n9 -> [1 0 0] -> 9\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function which tests if infinity is supported for floating point numbers (this step should be omitted for languages where the language specification already demands the existence of infinity, e.g. by demanding IEEE numbers), and if so, returns positive infinity.   Otherwise, return the largest possible positive floating point number.\n\nFor languages with several floating point types, use the type of the literal constant   **1.5**   as floating point type.\n\nRelated task\n\n* Extreme floating point values"}, {"role": "assistant", "content": "(formerly Perl 6)\nInf support is required by language spec on all abstract Numeric types (in the absence of subset constraints) including Num, Rat and Int types. Native integers cannot support Inf, so attempting to assign Inf will result in an exception; native floats are expected to follow IEEE standards including +/- Inf and NaN.\n\n```\nmy $x = 1.5/0;       # Failure: catchable error, if evaluated will return: \"Attempt to divide by zero ... \nmy $y = (1.5/0).Num; # assigns 'Inf'\n\n```"}]}
{"messages": [{"role": "user", "content": "Multiple inheritance allows to specify that one class is a subclass of several other classes.\n\nSome languages allow multiple inheritance for arbitrary classes,   others restrict it to interfaces,   some don't allow it at all.\n\nTask\n\nWrite two classes (or interfaces) Camera and MobilePhone,   then write a class CameraPhone which is both a Camera and a MobilePhone.\n\nThere is no need to implement any functions for those classes."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2012.06\n\n```\nclass Camera {}\nclass MobilePhone {}\nclass CameraPhone is Camera is MobilePhone {}\n\nsay CameraPhone.^mro;     # undefined type object\nsay CameraPhone.new.^mro; # instantiated object\n\n```\n\nOutput:\n\n```\nCameraPhone() Camera() MobilePhone() Any() Mu()\nCameraPhone() Camera() MobilePhone() Any() Mu()\n```\n\nThe .^mro is not an ordinary method call,\nbut a call to the object's metaobject\nthat returns the method resolution order for this type."}]}
{"messages": [{"role": "user", "content": ":   :   :   *This task is about derived types;   for implementation inheritance, see Polymorphism.*\n\nInheritance is an operation of type algebra that creates a new type from one or several parent types.\n\nThe obtained type is called **derived type**.\n\nIt inherits some of the properties of its parent types.\n\nUsually inherited properties are:\n\n:   :   :   * methods\n            * components\n            * parts of the representation\n\nThe class of the new type is a   **subclass**   of the classes rooted in the parent types.\n\nWhen all (in certain sense) properties of the parents are preserved by the derived type,   it is said to be a Liskov subtype.\n\nWhen properties are preserved then the derived type is *substitutable* for its parents in all contexts.   Usually full substitutability is achievable only in some contexts.\n\nInheritance is\n\n:   :   :   * **single**, when only one parent is allowed\n            * **multiple**, otherwise\n\nSome single inheritance languages usually allow multiple inheritance for certain abstract types, interfaces in particular.\n\nInheritance can be considered as a relation parent-child.\n\nParent types are sometimes called **supertype**, the derived ones are **subtype**.   This relation is transitive and reflexive.\n\nTypes bound by the relation form a wp:Directed\\_acyclic\\_graph directed acyclic graph (ignoring reflexivity).\n\nWith single inheritance it becomes a tree.\n\nTask\n\nShow a tree of types which inherit from each other.\n\n:   :   :   At the top of the tree should be a class called   **Animal**.\n        :   The second level should have **Dog** and **Cat**.\n        :   Under   **Dog**   should be   **Lab**   and   **Collie**.\n        :   None of the classes need to have any functions,   the only thing they need to do is inherit from the specified superclasses   \n               (overriding functions should be shown in Polymorphism).\n\nThe tree should look like this:\n\n```\n                        Animal\n                          /\\\n                         /  \\\n                        /    \\\n                      Dog    Cat\n                      /\\\n                     /  \\\n                    /    \\\n                  Lab  Collie\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015-09-16\n\n```\nclass Animal {}\nclass Dog is Animal {}\nclass Cat is Animal {}\nclass Lab is Dog {}\nclass Collie is Dog {}\n\nsay Collie.^parents;     # undefined type object\nsay Collie.new.^parents; # instantiated object\n\n```\n\nOutput:\n\n```\n((Dog) (Animal))\n((Dog) (Animal))\n```\n\nThe .^parents notation indicates a method call to the object's metaobject rather than to the object itself."}]}
{"messages": [{"role": "user", "content": "Definition\n\nIn object-oriented programming, an **inner** or **nested class** is a class declared entirely within the body of another class or interface.\n\nIt is not the same as a **subclass** which is a class which inherits members from another class or classes and can be declared anywhere the parent class(es) are within scope. However, inner classes may nevertheless be subclasses of other classes as well.\n\nTask\n\nIf your language supports the object oriented paradigm, explain what support it has for inner classes and, if there is no support, what if anything can be done to simulate them.\n\nIllustrate your answer by creating an inner class with a constructor, an instance method and field and show how to instantiate it.\n\nIf your language does not support the object oriented paradigm, you may either omit this task or describe (and substitute in your example) any equivalent structure(s) which the language does have.\n\nReference\n\n* Wikipedia: Inner class\n\nRelated task\n\n* Classes"}, {"role": "assistant", "content": "Raku supports nested classes, however they are really only useful for grouping units of behavior together into a namespace. There is no particular benefit as far as access to private methods or attributes that can't be achieved by non-nested classes. Access to inner classes must use fully qualified paths.\n\n```\nclass Outer {\n    has $.value is rw;\n    method double { self.value ×= 2 }\n\n    class Inner {\n        has $.value is rw;\n    }\n}\n\n# New Outer instance with a value of 42.\nmy $outer = Outer.new(:value(42));\n\nsay .^name, ' ', .value given $outer;\n$outer.double;\nsay .^name, ' ', .value given $outer;\n\n# New Inner instance with no value set. Note need to specify fully qualified name.\nmy $inner = Outer::Inner.new;\n\n# Set a value after the fact.\n$inner.value = 16;\n\n# There is no way for the Inner object to call the Outer .double method.\n# It is a separate, distinct class, just in a funny namespace.\nsay .^name, ' ', .value given $inner;\n$inner.value /=2;\nsay .^name, ' ', .value given $inner;\n\n```\n\nOutput:\n\n```\nOuter 42\nOuter 84\nOuter::Inner 16\nOuter::Inner 8\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task\n\nRead from a text stream either word-by-word or line-by-line until the stream runs out of data.\n\nThe stream will have an unknown amount of data on it."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nIn Raku, filehandles etc. provide the `.lines` and `.words` methods which return lazy lists, and can thus they be iterated using a `for` loop...\n\n**Line-by-line** *(line endings are automatically stripped)*\n\n* From a file:\n\n  ```\n  for \"filename.txt\".IO.lines -> $line {\n      ...\n  }\n\n  ```\n* From standard input:\n\n  ```\n  for $*IN.lines -> $line {\n      ...\n  }\n\n  ```\n* From a pipe:\n\n  ```\n  for run(«find -iname *.txt», :out).out.lines -> $filename {\n      ...\n  }\n\n  ```\n* From a pipe, with custom line separator *(in this example to handle filenames containing newlines)*:\n\n  ```\n  for run(«find -iname *.txt -print0», :nl«\\0», :out).out.lines -> $filename {\n      ...\n  }\n\n  ```\n\n**Word-by-word**\n\n* From a file\n\n  ```\n  for \"filename.txt\".IO.words -> $word {\n      ...\n  }\n\n  ```\n* From standard input or a pipe, accordingly."}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nTask\n\nThe first line contains the number of lines to follow, followed by that number of lines of text on   STDIN.\n\nWrite to   STDOUT   each line of input by passing it to a method as an intermediate step. The code should demonstrate these 3 things.\n\nSample input with corresponding output\n\n**Input**\n\n```\n3\nhello\nhello world\nPack my Box with 5 dozen liquor jugs \n\n```\n\n**Output**\n\n```\nhello\nhello world\nPack my Box with 5 dozen liquor jugs\n\n```\n\nRelated tasks\n\n* Input/Output for Pairs of Numbers\n* File/Input and Output"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nShort version:\n\n```\nsay get for ^get;\n\n```\n\nVerbose version:\n\n```\nsub do-stuff ($line) {\n    say $line;\n}\n \nmy $n = +get;\nfor ^$n {\n    my $line = get;\n    do-stuff $line;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "From lines of input starting with a line containing the numbers of pairs to follows, followed by that number of pairs of integers separated by a space on separate lines from STDIN, output the sum of each pair to STDOUT.\n\nSample input with corresponding output\n\n**Input**\n\n```\n5\n1 2\n10 20\n-3 5\n100 2\n5 5\n```\n\n**Output**\n\n```\n3\n30\n2\n102\n10\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nfor ^get() { say [+] get.words }\n\n```\n\nThis does more than the task asks. It will sum as many numbers as you care to put on each line, and the numbers need not be integers, but may also be a mix of rational, floating-point, or complex numbers. More subtly, get can read from a file specified as a command-line argument, but defaults to taking STDIN if no filename is specified."}]}
{"messages": [{"role": "user", "content": "Get two integers from the user.\n\nThen,   display a message if the first integer is:\n\n:   :   :   :   * less than,\n                * equal to,   or\n                * greater than\n\nthe second integer.\n\nTest the condition   *for each case separately*,   so that   *all three comparison operators are used*   in the code.\n\nRelated task\n\n* String comparison"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $a = prompt(\"1st int: \").floor;\nmy $b = prompt(\"2nd int: \").floor;\n\nif $a < $b {\n    say 'Less';\n}\nelsif $a > $b {\n    say 'Greater';\n}\nelsif $a == $b {\n    say 'Equal';\n}\n```\n\nWith `<=>`:\n\n```\nsay <Less Equal Greater>[($a <=> $b) + 1];\n```\n\nA three-way comparison such as <=> actually returns an `Order` enum which stringifies into 'Decrease', 'Increase' or 'Same'. So if it's ok to use this particular vocabulary, you could say that this task is actually a built in:\n\n```\nsay prompt(\"1st int: \") <=> prompt(\"2nd int: \");\n```"}]}
{"messages": [{"role": "user", "content": "Write a function that prints the result of the division of two positive integers with infinite precision (only limited by the available memory), stopping before the period starts repeating itself. Return also the length of this period (0 if there is no period).\n\nDemonstrate it with the division 1/149, whose result is 0.0067114093959731543624161073825503355704697986577181208053691275167785234899328859060402684563758389261744966442953020134228187919463087248322147651, where the last 148 digits repeat endlessly.\n\nThe result could be stored as a string or simply output to the screen.  \nNote that the division of any two integers will always produce a period, but if the numerator is an exact multiple of the denominator, or if the denominator contains only the factors 2 and 5, the period will be 0. In the remaining cases, these possible 2's and 5's of the denominator produce a leading number of digits in the quotient, but have no effect on the period.\n\nReferences\n\n* Wikipedia: Long Division\n\nRelated\n\n* Long primes"}, {"role": "assistant", "content": "It's a built-in.\n\n```\nfor 0/1, 1/1, 1/3, 1/7, -83/60, 1/17, 10/13, 3227/555, 5**21/2**63, 1/149, 1/5261 -> $rat {\n    printf \"%35s - Period is %-5s: %s%s\\n\", $rat.nude.join('/'), .[1].chars, .[0], (.[1].comb Z~ \"\\c[COMBINING OVERLINE]\" xx *).join\n        given $rat.base-repeating\n}\n\n```\n\nOutput:\n\n```\n                                0/1 - Period is 0    : 0\n                                1/1 - Period is 0    : 1\n                                1/3 - Period is 1    : 0.3̅\n                                1/7 - Period is 6    : 0.1̅4̅2̅8̅5̅7̅\n                             -83/60 - Period is 1    : -1.383̅\n                               1/17 - Period is 16   : 0.0̅5̅8̅8̅2̅3̅5̅2̅9̅4̅1̅1̅7̅6̅4̅7̅\n                              10/13 - Period is 6    : 0.7̅6̅9̅2̅3̅0̅\n                           3227/555 - Period is 3    : 5.81̅4̅4̅\n476837158203125/9223372036854775808 - Period is 0    : 0.000051698788284564229679463043254372678347863256931304931640625\n                              1/149 - Period is 148  : 0.0̅0̅6̅7̅1̅1̅4̅0̅9̅3̅9̅5̅9̅7̅3̅1̅5̅4̅3̅6̅2̅4̅1̅6̅1̅0̅7̅3̅8̅2̅5̅5̅0̅3̅3̅5̅5̅7̅0̅4̅6̅9̅7̅9̅8̅6̅5̅7̅7̅1̅8̅1̅2̅0̅8̅0̅5̅3̅6̅9̅1̅2̅7̅5̅1̅6̅7̅7̅8̅5̅2̅3̅4̅8̅9̅9̅3̅2̅8̅8̅5̅9̅0̅6̅0̅4̅0̅2̅6̅8̅4̅5̅6̅3̅7̅5̅8̅3̅8̅9̅2̅6̅1̅7̅4̅4̅9̅6̅6̅4̅4̅2̅9̅5̅3̅0̅2̅0̅1̅3̅4̅2̅2̅8̅1̅8̅7̅9̅1̅9̅4̅6̅3̅0̅8̅7̅2̅4̅8̅3̅2̅2̅1̅4̅7̅6̅5̅1̅\n                             1/5261 - Period is 1052 : 0.0̅0̅0̅1̅9̅0̅0̅7̅7̅9̅3̅1̅9̅5̅2̅1̅0̅0̅3̅6̅1̅1̅4̅8̅0̅7̅0̅7̅0̅8̅9̅9̅0̅6̅8̅6̅1̅8̅1̅3̅3̅4̅3̅4̅7̅0̅8̅2̅3̅0̅3̅7̅4̅4̅5̅3̅5̅2̅5̅9̅4̅5̅6̅3̅7̅7̅1̅1̅4̅6̅1̅6̅9̅9̅2̅9̅6̅7̅1̅1̅6̅5̅1̅7̅7̅7̅2̅2̅8̅6̅6̅3̅7̅5̅2̅1̅3̅8̅3̅7̅6̅7̅3̅4̅4̅6̅1̅1̅2̅9̅0̅6̅2̅9̅1̅5̅7̅9̅5̅4̅7̅6̅1̅4̅5̅2̅1̅9̅5̅4̅0̅0̅1̅1̅4̅0̅4̅6̅7̅5̅9̅1̅7̅1̅2̅6̅0̅2̅1̅6̅6̅8̅8̅8̅4̅2̅4̅2̅5̅3̅9̅4̅4̅1̅1̅7̅0̅8̅8̅0̅0̅6̅0̅8̅2̅4̅9̅3̅8̅2̅2̅4̅6̅7̅2̅1̅1̅5̅5̅6̅7̅3̅8̅2̅6̅2̅6̅8̅7̅7̅0̅1̅9̅5̅7̅8̅0̅2̅6̅9̅9̅1̅0̅6̅6̅3̅3̅7̅1̅9̅8̅2̅5̅1̅2̅8̅3̅0̅2̅6̅0̅4̅0̅6̅7̅6̅6̅7̅7̅4̅3̅7̅7̅4̅9̅4̅7̅7̅2̅8̅5̅6̅8̅7̅1̅3̅1̅7̅2̅4̅0̅0̅6̅8̅4̅2̅8̅0̅5̅5̅5̅0̅2̅7̅5̅6̅1̅3̅0̅0̅1̅3̅3̅0̅5̅4̅5̅5̅2̅3̅6̅6̅4̅7̅0̅2̅5̅2̅8̅0̅3̅6̅4̅9̅4̅9̅6̅2̅9̅3̅4̅8̅0̅3̅2̅6̅9̅3̅4̅0̅4̅2̅9̅5̅7̅6̅1̅2̅6̅2̅1̅1̅7̅4̅6̅8̅1̅6̅1̅9̅4̅6̅3̅9̅8̅0̅2̅3̅1̅8̅9̅5̅0̅7̅6̅9̅8̅1̅5̅6̅2̅4̅4̅0̅6̅0̅0̅6̅4̅6̅2̅6̅4̅9̅6̅8̅6̅3̅7̅1̅4̅1̅2̅2̅7̅9̅0̅3̅4̅4̅0̅4̅1̅0̅5̅6̅8̅3̅3̅3̅0̅1̅6̅5̅3̅6̅7̅8̅0̅0̅7̅9̅8̅3̅2̅7̅3̅1̅4̅1̅9̅8̅8̅2̅1̅5̅1̅6̅8̅2̅1̅8̅9̅6̅9̅7̅7̅7̅6̅0̅8̅8̅1̅9̅6̅1̅6̅0̅4̅2̅5̅7̅7̅4̅5̅6̅7̅5̅7̅2̅7̅0̅4̅8̅0̅8̅9̅7̅1̅6̅7̅8̅3̅8̅8̅1̅3̅9̅1̅3̅7̅0̅4̅6̅1̅8̅8̅9̅3̅7̅4̅6̅4̅3̅6̅0̅3̅8̅7̅7̅5̅8̅9̅8̅1̅1̅8̅2̅2̅8̅4̅7̅3̅6̅7̅4̅2̅0̅6̅4̅2̅4̅6̅3̅4̅0̅9̅9̅9̅8̅0̅9̅9̅2̅2̅0̅6̅8̅0̅4̅7̅8̅9̅9̅6̅3̅8̅8̅5̅1̅9̅2̅9̅2̅9̅1̅0̅0̅9̅3̅1̅3̅8̅1̅8̅6̅6̅5̅6̅5̅2̅9̅1̅7̅6̅9̅6̅2̅5̅5̅4̅6̅4̅7̅4̅0̅5̅4̅3̅6̅2̅2̅8̅8̅5̅3̅8̅3̅0̅0̅7̅0̅3̅2̅8̅8̅3̅4̅8̅2̅2̅2̅7̅7̅1̅3̅3̅6̅2̅4̅7̅8̅6̅1̅6̅2̅3̅2̅6̅5̅5̅3̅8̅8̅7̅0̅9̅3̅7̅0̅8̅4̅2̅0̅4̅5̅2̅3̅8̅5̅4̅7̅8̅0̅4̅5̅9̅9̅8̅8̅5̅9̅5̅3̅2̅4̅0̅8̅2̅8̅7̅3̅9̅7̅8̅3̅3̅1̅1̅1̅5̅7̅5̅7̅4̅6̅0̅5̅5̅8̅8̅2̅9̅1̅1̅9̅9̅3̅9̅1̅7̅5̅0̅6̅1̅7̅7̅5̅3̅2̅7̅8̅8̅4̅4̅3̅2̅6̅1̅7̅3̅7̅3̅1̅2̅2̅9̅8̅0̅4̅2̅1̅9̅7̅3̅0̅0̅8̅9̅3̅3̅6̅6̅2̅8̅0̅1̅7̅4̅8̅7̅1̅6̅9̅7̅3̅9̅5̅9̅3̅2̅3̅3̅2̅2̅5̅6̅2̅2̅5̅0̅5̅2̅2̅7̅1̅4̅3̅1̅2̅8̅6̅8̅2̅7̅5̅9̅9̅3̅1̅5̅7̅1̅9̅4̅4̅4̅9̅7̅2̅4̅3̅8̅6̅9̅9̅8̅6̅6̅9̅4̅5̅4̅4̅7̅6̅3̅3̅5̅2̅9̅7̅4̅7̅1̅9̅6̅3̅5̅0̅5̅0̅3̅7̅0̅6̅5̅1̅9̅6̅7̅3̅0̅6̅5̅9̅5̅7̅0̅4̅2̅3̅8̅7̅3̅7̅8̅8̅2̅5̅3̅1̅8̅3̅8̅0̅5̅3̅6̅0̅1̅9̅7̅6̅8̅1̅0̅4̅9̅2̅3̅0̅1̅8̅4̅3̅7̅5̅5̅9̅3̅9̅9̅3̅5̅3̅7̅3̅5̅0̅3̅1̅3̅6̅2̅8̅5̅8̅7̅7̅2̅0̅9̅6̅5̅5̅9̅5̅8̅9̅4̅3̅1̅6̅6̅6̅9̅8̅3̅4̅6̅3̅2̅1̅9̅9̅2̅0̅1̅6̅7̅2̅6̅8̅5̅8̅0̅1̅1̅7̅8̅4̅8̅3̅1̅7̅8̅1̅0̅3̅0̅2̅2̅2̅3̅9̅1̅1̅8̅0̅3̅8̅3̅9̅5̅7̅4̅2̅2̅5̅4̅3̅2̅4̅2̅7̅2̅9̅5̅1̅9̅1̅0̅2̅8̅3̅2̅1̅6̅1̅1̅8̅6̅0̅8̅6̅2̅9̅5̅3̅8̅1̅1̅0̅6̅2̅5̅3̅5̅6̅3̅9̅6̅1̅2̅2̅4̅1̅0̅1̅8̅8̅1̅7̅7̅1̅5̅2̅6̅3̅2̅5̅7̅9̅3̅5̅7̅5̅3̅6̅5̅9̅\n```"}]}
{"messages": [{"role": "user", "content": "Some languages support one or more integer types of the underlying processor.\n\nThis integer types have fixed size;   usually   **8**-bit,   **16**-bit,   **32**-bit,   or   **64**-bit.\n  \nThe integers supported by such a type can be   *signed*   or   *unsigned*.\n\nArithmetic for machine level integers can often be done by single CPU instructions.\n  \nThis allows high performance and is the main reason to support machine level integers.\n\nDefinition\n\nAn integer overflow happens when the result of a computation does not fit into the fixed size integer.\nThe result can be too small or too big to be representable in the fixed size integer.\n\nTask\n\nWhen a language has fixed size integer types, create a program that\ndoes arithmetic computations for the fixed size integers of the language.\n\nThese computations must be done such that the result would overflow.\n\nThe program should demonstrate what the following expressions do.\n\nFor 32-bit signed integers:\n\n:   :   :   :   :   | Expression | Result that does not fit into a 32-bit signed integer |\n                    | --- | --- |\n                    | -(-2147483647-1) | 2147483648 |\n                    | 2000000000 + 2000000000 | 4000000000 |\n                    | -2147483647 - 2147483647 | -4294967294 |\n                    | 46341 \\* 46341 | 2147488281 |\n                    | (-2147483647-1) / -1 | 2147483648 |\n\nFor 64-bit signed integers:\n\n:   :   :   | Expression | Result that does not fit into a 64-bit signed integer |\n            | --- | --- |\n            | -(-9223372036854775807-1) | 9223372036854775808 |\n            | 5000000000000000000+5000000000000000000 | 10000000000000000000 |\n            | -9223372036854775807 - 9223372036854775807 | -18446744073709551614 |\n            | 3037000500 \\* 3037000500 | 9223372037000250000 |\n            | (-9223372036854775807-1) / -1 | 9223372036854775808 |\n\nFor 32-bit unsigned integers:\n\n:   :   :   :   :   | Expression | Result that does not fit into a 32-bit unsigned integer |\n                    | --- | --- |\n                    | -4294967295 | -4294967295 |\n                    | 3000000000 + 3000000000 | 6000000000 |\n                    | 2147483647 - 4294967295 | -2147483648 |\n                    | 65537 \\* 65537 | 4295098369 |\n\nFor 64-bit unsigned integers:\n\n:   :   :   | Expression | Result that does not fit into a 64-bit unsigned integer |\n            | --- | --- |\n            | -18446744073709551615 | -18446744073709551615 |\n            | 10000000000000000000 + 10000000000000000000 | 20000000000000000000 |\n            | 9223372036854775807 - 18446744073709551615 | -9223372036854775808 |\n            | 4294967296 \\* 4294967296 | 18446744073709551616 |\n\nNotes\n:   * When the integer overflow does trigger an exception show how the exception is caught.\n    * When the integer overflow produces some value,   print it.\n    * It should be explicitly noted when an integer overflow is not recognized,   the program continues with wrong results.\n    * This should be done for signed and unsigned integers of various sizes supported by the computer programming language.\n    * When a language has no fixed size integer type,   or when no integer overflow can occur for other reasons,   this should be noted.\n    * It is okay to mention,   when a language supports unlimited precision integers,   but this task is NOT the place to demonstrate the   \n        capabilities of unlimited precision integers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\nThe Raku program below does **not** recognize a signed integer overflow and the program **continues with wrong results**.\n\n```\nmy int64 ($a, $b, $c) = 9223372036854775807, 5000000000000000000, 3037000500;\n.say for -(-$a - 1), $b + $b, -$a - $a, $c * $c, (-$a - 1)/-1;\n\n```\n\nOutput:\n\n```\n-9223372036854775808\n-8446744073709551616\n2\n-9223372036709301616\n9223372036854775808\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a program that computes an approximation of the principal   Nth   root of   X   as the largest integer less than or equal to   R   for which   RN=X.\n\n──where:\n\n```\n       N  is a positive integer. \n       X  is a non-negative integer. \n       R  (the root)   is a non-negative real number. \n\n```\n\nNo arbitrary limits should be placed on the magnitudes of the numbers involved.\n\nExample:   With   N=3   and   X=8   you would calculate the number   **2**   because   \n\n2\n\n3\n=\n8\n{\\displaystyle {\\displaystyle 2^{3}=8}}\n\nExample:   With   N=3   and   X=9  you would again calculate the number   **2**   because **2** is the largest integer less than or equal to the root   R.\n\nExample:   With   N=2   and   X=2×1002,000   you would calculate a large integer consisting of the first   2,001   digits (in order) of the square root of two."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n```\nsub integer_root ( Int $p where * >= 2, Int $n --> Int ) {\n    my Int $d = $p - 1;\n    (\n      10**($n.chars div $p),\n      { ( $d * $^x   +   $n div ($x ** $d) ) div $p } ...\n      -> $a, $, $c { $a == $c }\n    ).tail(2).min;\n}\n\nsay integer_root( 2, 2 * 100 ** 2000 );\n\n```\n\nOutput:\n\n```\n141421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157273501384623091229702492483605585073721264412149709993583141322266592750559275579995050115278206057147010955997160597027453459686201472851741864088919860955232923048430871432145083976260362799525140798968725339654633180882964062061525835239505474575028775996172983557522033753185701135437460340849884716038689997069900481503054402779031645424782306849293691862158057846311159666871301301561856898723723528850926486124949771542183342042856860601468247207714358548741556570696776537202264854470158588016207584749226572260020855844665214583988939443709265918003113882464681570826301005948587040031864803421948972782906410450726368813137398552561173220402450912277002269411275736272804957381089675040183698683684507257993647290607629969413804756548237289971803268024744206292691248590521810044598421505911202494413417285314781058036033710773091828693147101711116839165817268894197587165821521282295184884720896946338628915628827659526351405422676532396946175112916024087155101351504553812875600526314680171274026539694702403005174953188629256313851881634780015693691768818523786840522878376293892143006558695686859645951555016447245098368960368873231143894155766510408839142923381132060524336294853170499157717562285497414389991880217624309652065642118273167262575395947172559346372386322614827426222086711558395999265211762526989175409881593486400834570851814722318142040704265090565323333984364578657967965192672923998753666172159825788602633636178274959942194037777536814262177387991945513972312740668983299898953867288228563786977496625199665835257761989393228453447356947949629521688914854925389047558288345260965240965428893945386466257449275563819644103169798330618520193793849400571563337205480685405758679996701213722394758214263065851322174088323829472876173936474678374319600015921888073478576172522118674904249773669292073110963697216089337086611567345853348332952546758516447107578486024636008\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a program that, when run, would display all integers from   **1**   to     ****∞****     (or any relevant implementation limit),   in sequence   (i.e.   1, 2, 3, 4, etc)   if given enough time.\n\nAn example may not be able to reach arbitrarily-large numbers based on implementations limits.   For example, if integers are represented as a 32-bit unsigned value with 0 as the smallest representable value, the largest representable value would be 4,294,967,295.   Some languages support arbitrarily-large numbers as a built-in feature, while others make use of a module or library.\n\nIf appropriate, provide an example which reflect the language implementation's common built-in limits as well as an example which supports arbitrarily large numbers, and describe the nature of such limitations—or lack thereof."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n.say for 1..*\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate any interactive (or command line) help offered by the language implementation.\n\nThis can be for exploring features or syntax, or perhaps a simple message on where to find more information."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku help is generally in a specialized text format known as POD (Plain Old Documentation). It is sometimes referred to as POD6 to distinguish it from Perl 5 POD which is slightly different and not completely compatible. Raku has a local command line help app: p6doc. zef install p6doc It also has online browsable HTML documentation at docs.raku.org. If you want to download the HTML docs for a local copy, or just prefer to browse the documentation as a single page docs.raku.org/perl6.html may be more to your preference. If you prefer a different format, there are utilities available to convert the POD docs to several different formats; Markdown, PDF, Latex, plain text, etc.\n\nIndividual Raku scripts are to some extent self-documenting. If the script has a MAIN sub, and it is called with improper parameters, it will display an automatically generated help message showing the various possible parameters, which are required, which are optional, and what type each takes:\n\n```\nsub MAIN(\n    Str $run,             #= Task or file name\n    Str :$lang = 'raku',  #= Language, default raku\n    Int :$skip = 0,       #= Skip # to jump partially into a list\n    Bool :f(:$force),     #= Override any skip parameter\n) {\n    # do whatever\n}\n\n```\n\nWhen saved locally as main.raku and invoked with no (or wrong) passed parameters:\n\n```\nUsage:\n  main.raku [--lang=<Str>] [--skip=<Int>] [-f|--force] <run>\n  \n    <run>           Task or file name\n    --lang=<Str>    Language, default raku\n    --skip=<Int>    Skip # to jump partially into a list\n    -f|--force      Override any skip parameter\n\n```"}]}
{"messages": [{"role": "user", "content": "Many language implementations come with an *interactive mode*.\n\nThis is a command-line interpreter that reads lines from the user and evaluates these lines as statements or expressions.\n\nAn interactive mode may also be known as a *command mode*,   a *read-eval-print loop* (REPL),   or a *shell*.\n\nTask\n\nShow how to start this mode.\n\nThen, as a small example of its use, interactively create a function of two strings and a separator that returns the strings separated by two concatenated instances of the separator   (the 3rd argument).\n\nExample\n\n```\n             f('Rosetta',  'Code',  ':')   \n\n```\n\nshould return\n\n```\n             'Rosetta::Code'               \n\n```\n\nNote\n\nThis task is   *not*   about creating your own interactive mode."}, {"role": "assistant", "content": "(formerly Perl 6)\nUsing Rakudo.\n\n```\n$ rakudo/perl6\n> sub f($str1,$str2,$sep) { $str1~$sep x 2~$str2 };\nf\n> f(\"Rosetta\",\"Code\",\":\");\nRosetta::Code\n>\n\n```"}]}
{"messages": [{"role": "user", "content": "A number wheel has:\n\n* A *name* which is an uppercase letter.\n* A set of ordered *values* which are either *numbers* or *names*.\n\nA *number* is generated/yielded from a named wheel by:\n\n:   1. Starting at the first value of the named wheel and advancing through subsequent values and wrapping around to the first value to form a \"wheel\":\n\n    :   1.a If the value is a number, yield it.\n    :   1.b If the value is a name, yield the next value from the named wheel\n    :   1.c Advance the position of this wheel.\n\nGiven the wheel\n\n:   `A: 1 2 3`\n\nthe number 1 is first generated, then 2, then 3, 1, 2, 3, 1, ...\n\n**Note:** When more than one wheel is defined as a set of intersecting wheels then the\nfirst named wheel is assumed to be the one that values are generated from.\n\nExamples\n\nGiven the wheels:\n\n```\n   A: 1 B 2\n   B: 3 4\n\n```\n\nThe series of numbers generated starts:\n\n```\n   1, 3, 2, 1, 4, 2, 1, 3, 2, 1, 4, 2, 1, 3, 2...\n\n```\n\nThe intersections of number wheels can be more complex, (and might loop forever),\nand wheels may be multiply connected.\n\n**Note:** If a named wheel is referenced more than\nonce by one or many other wheels, then there is only one position of the wheel\nthat is advanced by each and all references to it.\n\nE.g.\n\n```\n A:  1 D D\n D:  6 7 8\n Generates:\n   1 6 7 1 8 6 1 7 8 1 6 7 1 8 6 1 7 8 1 6 ...    \n\n```\n\nTask\n\nGenerate and show the first twenty terms of the sequence of numbers generated\nfrom these groups:\n\n```\n   Intersecting Number Wheel group:\n     A:  1 2 3\n   \n   Intersecting Number Wheel group:\n     A:  1 B 2\n     B:  3 4\n   \n   Intersecting Number Wheel group:\n     A:  1 D D\n     D:  6 7 8\n   \n   Intersecting Number Wheel group:\n     A:  1 B C\n     B:  3 4\n     C:  5 B\n\n```\n\nShow your output here, on this page."}, {"role": "assistant", "content": "(formerly Perl 6)\nA succinct Raku example using a few additional language features. Wheels are implemented as infinite repeating sequences, allowing a single iterator to keep track of the current position. This means the code contains no position tracking whatsoever.\n\n```\n#| advance rotates a named wheel $n by consuming an item from an infinite sequence. It is called\n#| from within a gather block and so can use take in order to construct an infinite, lazy sequence\n#| of result values\nsub advance($g, $n) {\n\tgiven $g{$n}.pull-one {\n\t\twhen /\\d/ { take $_ }\n\t\tdefault   { samewith $g, $_ } # samewith re-calls this function with new parameters\n\t}\n}\n\n#| Input groups are a hash containing each wheel name as the key, and a list of values constructed\n#| using <> to split on whitespace. They are transformed using xx * to repeat the list infinitely.\n#| We then retrieve the underlying iterator in order for wheel position to be persistent. Each group\n#| is then aggregated into a lazy output sequence using an infinite loop inside a gather block.\n[\n\t{A => <1 2 3>},\n\t{A => <1 B 2>, B => <3 4>},\n\t{A => <1 D D>, D => <6 7 8>},\n\t{A => <1 B C>, B => <3 4>, C => <5 B>},\n]\n\t#| %() converts a list of pairs produced by map into a hash. $^k and $^v are implicit variables.\n\t#| They are processed in alphabetical order and make the block arity 2, called with two vars.\n\t#| .kv gets the list of wheel names and wheel values from the input entry\n\t==> map({ %(.kv.map: { $^k => (|$^v xx *).iterator }) })\n\t#| gather constructs a lazy sequence, in which we infinitely loop advancing wheel A\n\t==> map({ gather { loop { advance $_, 'A' }} })\n\t#| state variables are only initialised once, and are kept between invocations.\n\t==> map({ state $i = 1; say \"Group {$i++}, First 20 values: $_[^20]\" })\n\n```\n\nOutput:\n\n```\nGroup 1, First 20 values: 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2\nGroup 2, First 20 values: 1 3 2 1 4 2 1 3 2 1 4 2 1 3 2 1 4 2 1 3\nGroup 3, First 20 values: 1 6 7 1 8 6 1 7 8 1 6 7 1 8 6 1 7 8 1 6\nGroup 4, First 20 values: 1 3 5 1 4 3 1 4 5 1 3 4 1 3 5 1 4 3 1 4\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n* verify the version/revision of your currently running (compiler/interpreter/byte-compiler/runtime environment/whatever your language uses) and exit if it is too old.\n* check whether the variable \"bloop\" exists and whether the math-function \"abs()\" is available and if yes compute *abs(bloop)*.\n\nExtra credit\n\n* Report the number of integer variables in global scope, and their sum."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $bloop = -123;\n\nif MY::{'$bloop'}.defined and CORE::{'&abs'}.defined { say abs $bloop }\n\nmy @ints = ($_ when Int for PROCESS::.values);\nsay \"Number of PROCESS vars of type Int: \", +@ints;\nsay \"PROCESS vars of type Int add up to \", [+] @ints;\n\n```\n\nOutput:\n\n```\n123\nNumber of PROCESS vars of type Int: 1\nPROCESS vars of type Int add up to 28785\n```\n\nObviously Raku doesn't maintain a lot of global integer variables... :-)\n\nNevertheless, you can use similar code to access all the variables in any package you like,\nsuch as the GLOBAL package, which typically has absolutely nothing in it. Since the PROCESS package is even more global than GLOBAL, we used that instead. Go figure..."}]}
{"messages": [{"role": "user", "content": "To build the **inventory sequence**, first take inventory of what numbers are already in the sequence, then, starting with 0 add the count of each number in turn to the end of the sequence. When you reach a number that has a count of **0**, stop, add the **0** to the end of the sequence, and then restart the inventory from **0**.\n\nE.G.\n:   Start taking inventory; how many **0**s are there? **0**. Add a **0** to the end of the sequence and restart the inventory. **(0)**\n\n:   How many **0**s are there? **1**. Add a **1** to the end of the sequence. How many **1**s are there? **1**. Add a **1** to the end of the sequence. How many **2**s are there? **0**. Add a **0** to the end of the sequence and restart the inventory. **(0 1 1 0)**\n\n:   *and so on.*\n\nTask\n\n* Find and display the first **100** elements of the sequence.\n* Find and display the position and value of the first element greater than or equal to **1000**.\n\nStretch\n\n* Find and display the position and value of the first element greater than or equal to **2000**, **3000** ... **10,000**.\n* Plot a graph of the first **10,000** elements of the sequence.\n\nSee also\n\n* OEIS:A342585 - Inventory sequence * Numberphile: The inventory sequence"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\n\nmy ($i, %i) = 0;\n\nmy @inventory = (^∞).map: {\n    my $count = %i{$i} // 0;\n    $i = $count ?? $i+1 !! 0;\n    ++%i{$count};\n    $count\n}\n\nsay \"Inventory sequence, first 100 elements:\\n\" ~\n  @inventory[^100].batch(20)».fmt(\"%2d\").join: \"\\n\";\n\nsay '';\n\nfor (1..10).map: * × 1000 {\n    my $k = @inventory.first: * >= $_, :k;\n    printf \"First element >= %6s is %6s in position: %s\\n\",\n      .&comma, @inventory[$k].&comma, comma $k;\n}\n\n\nuse SVG;\nuse SVG::Plot;\n\nmy @x = ^10000;\n\n'Inventory-raku.svg'.IO.spurt:\n SVG.serialize: SVG::Plot.new(\n    background  => 'white',\n    width       => 1000,\n    height      => 600,\n    plot-width  => 950,\n    plot-height => 550,\n    x           => @x,\n    values      => [@inventory[@x],],\n    title       => \"Inventory Sequence - First {+@x} values (zero indexed)\",\n).plot: :lines;\n\n```\n\nOutput:\n\n```\nInventory sequence, first 100 elements:\n 0  1  1  0  2  2  2  0  3  2  4  1  1  0  4  4  4  1  4  0\n 5  5  4  1  6  2  1  0  6  7  5  1  6  3  3  1  0  7  9  5\n 3  6  4  4  2  0  8  9  6  4  9  4  5  2  1  3  0  9 10  7\n 5 10  6  6  3  1  4  2  0 10 11  8  6 11  6  9  3  2  5  3\n 2  0 11 11 10  8 11  7  9  4  3  6  4  5  0 12 11 10  9 13\n\nFirst element >=  1,000 is  1,001 in position: 24,255\nFirst element >=  2,000 is  2,009 in position: 43,301\nFirst element >=  3,000 is  3,001 in position: 61,708\nFirst element >=  4,000 is  4,003 in position: 81,456\nFirst element >=  5,000 is  5,021 in position: 98,704\nFirst element >=  6,000 is  6,009 in position: 121,342\nFirst element >=  7,000 is  7,035 in position: 151,756\nFirst element >=  8,000 is  8,036 in position: 168,804\nFirst element >=  9,000 is  9,014 in position: 184,428\nFirst element >= 10,000 is 10,007 in position: 201,788\n```\n\n*converted to a .png to reduce size for display here:*"}]}
{"messages": [{"role": "user", "content": "An Inverted Index is a data structure used to create full text search.\n\nTask\n\nGiven a set of text files, implement a program to create an inverted index.\n\nAlso create a user interface to do a search using that inverted index which returns a list of files that contain the query term / terms.\n\nThe search index can be in memory."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-16\n\n```\nsub MAIN (*@files) {\n    my %norm;\n    do for @files -> $file {\n        %norm.push: $file X=> slurp($file).lc.words;\n    }\n    (my %inv).push: %norm.invert.unique;\n\n    while prompt(\"Search terms: \").words -> @words {\n        for @words -> $word {\n            say \"$word => {%inv.{$word.lc}//'(not found)'}\";\n        }\n    }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "**Inverted syntax with conditional expressions**\n\nIn traditional syntax conditional expressions are usually shown before the action within a statement or code block:\n\n```\n IF raining=true THEN needumbrella=true\n```\n\nIn inverted syntax, the action is listed before the conditional expression in the statement or code block:\n\n```\n needumbrella=true IF raining=true\n```\n\n**Inverted syntax with assignment**\n\nIn traditional syntax, assignments are usually expressed with the variable appearing before the expression:\n\n```\n a = 6\n```\n\nIn inverted syntax, the expression appears before the variable:\n\n```\n 6 = a\n```\n\n**Task**\n\nThe task is to demonstrate support for inverted syntax forms within the language by showing both the traditional and inverted forms."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku has statement modifiers:\n\n```\nif $guess == 6 { say \"Wow! Lucky Guess!\" }          # Traditional\nsay 'Wow! Lucky Guess!' if $guess == 6;             # Inverted\nunless $guess == 6 { say \"Huh! You Guessed Rong!\" } # Traditional\nsay 'Huh! You Guessed Rong!' unless $guess == 6;    # Inverted\n\n```\n\nRaku can also invert the syntax of loops:\n\n```\nwhile $i { --$i }\n--$i while $i;\n\nuntil $x > 10 { $x++ }\n$x++ until $x > 10;\n\nfor 1..10 { .say if $_ %% 2 }\n.say if $_ %% 2 for 1..10;  # list comprehension\n\n```\n\nRaku has a system of metaoperators that modify the characteristics of normal operators. Among these is the R metaoperator, which is able to reverse the arguments of most infix operators (including user-defined ones).\nSo a reversed assignment is easy to write:\n\n```\n42 R= $_; say $_;   # prints 42\n\n```\n\nSince, much like list operators, assignment loosens the precedence of the following expression to allow comma lists, reverse assignment of a list requires parens where the normal assignment would not:\n\n```\nmy @a = 1,2,3;\n(1,2,3) R= my @a;\n\n```\n\nHowever, generally in that case you'd use a feed operator anyway, which is like an object pipe, but unlike Unix pipes works in either direction:\n\n```\nmy @a <== 1,2,3;\n1,2,3 ==> my @a;\n\n```\n\nWe think this is much more readable than a reversed assignment.\n\nOne other interesting inversion is the ability to put the conditional of a repeat loop at either end, with identical test-after semantics:\n\n```\nrepeat {\n    $_ = prompt \"Gimme a number: \";\n} until /^\\d+$/;\n\nrepeat until /^\\d+$/ {\n    $_ = prompt \"Gimme a number: \";\n}\n\n```\n\nThis might seem relatively useless, but it allows a variable to be declared in the conditional that isn't actually set until the loop body:\n\n```\nrepeat until my $answer ~~ 42 {\n    $answer = prompt \"Gimme an answer: \";\n}\n\n```\n\nThis would require a prior declaration (and two extra semicolons, horrors)\nif written in the non-inverted form with the conditional at the bottom:\n\n```\nmy $answer;\nrepeat {\n    $answer = prompt \"Gimme an answer: \";\n} until $answer ~~ 42;\n\n```\n\nYou can't just put the my on the $answer in the block because the conditional is outside the scope of the block, and would not see the declaration."}]}
{"messages": [{"role": "user", "content": "Named pipe, or FIFO, is a way of providing inter-process communications (IPC). The task is to demonstrate how it works, create two pipes, say, \"in\" and \"out\" (choose suitable names for your system), and write a program that works the two pipes such that:\n\n1. Data written to the \"in\" FIFO will be discarded except the byte count, which will be added to a total tally kept by the program;\n2. Whenever another process reads the \"out\" FIFO, it should receive the total count so far.\n\nPossible issues:\n\n* Chances are you don't already have \"in\" and \"out\" pipes lying around. Create them within your program or without, at your discretion. You may assume they are already created for you.\n* Your program may assume it's the sole reader on \"in\" and the sole writer on \"out\".\n* Read/write operations on pipes are generally blocking. Make your program responsive to both pipes, so that it won't block trying to read the \"in\" pipe while leaving another process hanging on the other end of \"out\" pipe indefinitely -- or vice versa. You probably need to either poll the pipes or use multi-threading.\n* You may assume other processes using the pipes behave; specificially, your program may assume the process at the other end of a pipe will not unexpectedly break away before you finish reading or writing."}, {"role": "assistant", "content": "|  |\n| --- |\n| This example is **incorrect**. Please fix the code and remove this message.  ***Details:*** Blocks on the read pipe and not able to empty/update the write pipe according to the task requirement |\n\nCouldn't figure out how to get around the IO blockages as per the talk page so any help would be appreciated, thanks in advance.\n\n```\n# 20200923 Added Raku programming solution\n\nuse NativeCall;\nuse UUID; # cannot mix File::Temp with mkfifo well so use this as tmpnam\n\nmy ($in, $out) = <in out>.map: { \"/tmp/$_-\" ~ UUID.new } ;\n\nsub mkfifo(Str $pathname, int32 $mode --> int32) is native('libc.so.6') is symbol('mkfifo') {*}\n\n($in,$out).map: { die $!.message if mkfifo($_, 0o666) } ; # c style exit code\n\nsay \"In  pipe: \", $in;\nsay \"Out pipe: \", $out;\n\nmy atomicint $CharCount = 0;\n\nsignal(SIGINT).tap: {\n   ($in,$out).map: { .IO.unlink or die } ;\n   say \"\\nBye.\" and exit;\n}\n\nloop {\n   given $in.IO.watch { # always true even when nothing is spinning ?\n\n      say \"Current count: \", $CharCount  ⚛+= $in.IO.open.readchars.codes;\n\n      given $out.IO.open(:update :truncate) { # both truncate and flush aren't\n         .flush or die ;                      # working on pipes so without a\n         .spurt: \"$CharCount\\t\"               # prior consumer it just appends\n      }\n      $out.IO.open.close or die;\n   }\n   sleep ½;\n}\n\n```\n\nOutput:\n\nTerminal 1\n\n```\nnamed-pipe.raku\nIn  pipe: /tmp/in-b49e4cdf-80b6-49da-b4a3-2810f1eeeb6a\nOut pipe: /tmp/out-44fcd0db-ce02-47b4-bdd3-34833f3dd621\nCurrent count: 5\nCurrent count: 10\nCurrent count: 15\n^C\nBye.\n```\n\nTerminal 2\n\n```\necho asdf > /tmp/in-b49e4cdf-80b6-49da-b4a3-2810f1eeeb6a\ncat /tmp/out-44fcd0db-ce02-47b4-bdd3-34833f3dd621\n5       ^C\necho qwer > /tmp/in-b49e4cdf-80b6-49da-b4a3-2810f1eeeb6a\necho uiop > /tmp/in-b49e4cdf-80b6-49da-b4a3-2810f1eeeb6a\ncat /tmp/out-44fcd0db-ce02-47b4-bdd3-34833f3dd621      \n10      15      ^C\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nValidate the check digit of an ISBN-13 code:\n\n:   :   * Multiply every other digit by  **3**.\n        * Add these numbers and the other digits.\n        * Take the remainder of this number after division by  **10**.\n        * If it is  **0**,   the ISBN-13 check digit is correct.\n\nYou might use the following codes for testing:\n\n:   :   :   :   * 978-0596528126       (good)\n                * 978-0596528120         (bad)\n                * 978-1788399081       (good)\n                * 978-1788399083         (bad)\n\nShow output here, on this page\n\nSee also\n:   * for details:   13-digit ISBN method of validation.       (installs cookies.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\nAlso test a value that has a zero check digit.\n\n```\nsub check-digit ($isbn) {\n     (10 - (sum (|$isbn.comb(/<[0..9]>/)) »*» (1,3)) % 10).substr: *-1\n}\n\n{\n    my $check = .substr(*-1);\n    my $check-digit = check-digit .chop;\n    say \"$_ : \", $check == $check-digit ??\n        'Good' !!\n        \"Bad check-digit $check; should be $check-digit\"\n} for words <\n    978-0596528126\n    978-0596528120\n    978-1788399081\n    978-1788399083\n    978-2-74839-908-0\n    978-2-74839-908-5\n>;\n\n```\n\nOutput:\n\n```\n978-0596528126 : Good\n978-0596528120 : Bad check-digit 9; should be 2\n978-1788399081 : Good\n978-1788399083 : Bad check-digit 3; should be 1\n978-2-74839-908-0 : Good\n978-2-74839-908-5 : Bad check-digit 5; should be 0\n\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nFor the purposes of this task, an **isogram** means a string where each character present is used the same number of times and an **n-isogram** means an isogram where each character present is used exactly **n** times.\n\nA **heterogram** means a string in which no character occurs more than once. It follows that a **heterogram** is the same thing as a **1-isogram**.\n\nExamples\n\n*caucasus* is a **2-isogram** because the letters c, a, u and s all occur twice.\n\n*atmospheric* is a **heterogram** because all its letters are used once only.\n\nTask\n\nUsing **unixdict.txt** and ignoring capitalization:\n\n**1)** Find and display here all words which are **n-isograms** where **n > 1**.\n\nPresent the results as a single list but sorted as follows:\n\na. By decreasing order of **n**;\n\nb. Then by decreasing order of word length;\n\nc. Then by ascending lexicographic order.\n  \n  \n**2)** Secondly, find and display here all words which are **heterograms** and have more than **10** characters.\n\nAgain present the results as a single list but sorted as per b. and c. above.\n\nReference\n\n* Wikipedia: Heterogram\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nmy $file = 'unixdict.txt';\n\nmy @words = $file.IO.slurp.words.race.map: { $_ => .comb.Bag };\n\n.say for (6...2).map: -> $n {\n    next unless my @iso = @words.race.grep({.value.values.all == $n})».key;\n    \"\\n({+@iso}) {$n}-isograms:\\n\" ~ @iso.sort({[-.chars, ~$_]}).join: \"\\n\";\n}\n\nmy $minchars = 10;\n\nsay \"\\n({+$_}) heterograms with more than $minchars characters:\\n\" ~\n  .sort({[-.chars, ~$_]}).join: \"\\n\" given\n  @words.race.grep({.key.chars >$minchars && .value.values.max == 1})».key;\n\n```\n\nOutput:\n\n```\n(2) 3-isograms:\naaa\niii\n\n(31) 2-isograms:\nberiberi\nbilabial\ncaucasus\ncouscous\nteammate\nappall\nemmett\nhannah\nmurmur\ntartar\ntestes\nanna\ncoco\ndada\ndeed\ndodo\ngogo\nisis\njuju\nlulu\nmimi\nnoon\notto\npapa\npeep\npoop\nteet\ntete\ntoot\ntutu\nii\n\n(32) heterograms with more than 10 characters:\nambidextrous\nbluestocking\nexclusionary\nincomputable\nlexicography\nloudspeaking\nmalnourished\natmospheric\nblameworthy\ncentrifugal\nchristendom\nconsumptive\ncountervail\ncountryside\ncountrywide\ndisturbance\ndocumentary\nearthmoving\nexculpatory\ngeophysical\ninscrutable\nmisanthrope\nproblematic\nselfadjoint\nstenography\nsulfonamide\nswitchblade\nswitchboard\nswitzerland\nthunderclap\nvaledictory\nvoluntarism\n```"}]}
{"messages": [{"role": "user", "content": "Sometimes a function is needed to find the integer square root of   **X**,   where   **X**   can be a\nreal non─negative number.\n\nOften   **X**   is actually a non─negative integer.\n\nFor the purposes of this task,   **X**   can be an integer or a real number,   but if it\nsimplifies things in your computer programming language,   assume it's an integer.\n\nOne of the most common uses of   **`Isqrt`**   is in the division of an integer by all factors   (or\nprimes)   up to the   \n√ X     of that\ninteger,   either to find the factors of that integer,   or to determine primality.\n\nAn alternative method for finding the   **`Isqrt`**   of a number is to\ncalculate:        floor( sqrt(X) )\n\n:   :   * where   **sqrt**    is the   square root   function for non─negative real numbers,   and\n        * where   **floor**   is the   floor   function for real numbers.\n\nIf the hardware supports the computation of (real) square roots,   the above method might be a faster method for\nsmall numbers that don't have very many significant (decimal) digits.\n\nHowever, floating point arithmetic is limited in the number of   (binary or decimal)   digits that it can support.\n\nPseudo─code using quadratic residue\n\nFor this task, the integer square root of a non─negative number will be computed using a version\nof   *quadratic residue*,   which has the advantage that no   *floating point*   calculations are\nused,   only integer arithmetic.\n\nFurthermore, the two divisions can be performed by bit shifting,   and the one multiplication can also be be performed by bit shifting or additions.\n\nThe disadvantage is the limitation of the size of the largest integer that a particular computer programming language can support.\n\nPseudo─code of a procedure for finding the integer square root of   **X**       (all variables are integers):\n\n```\n         q ◄── 1                                /*initialize  Q  to unity.  */\n                                  /*find a power of 4 that's greater than X.*/\n                  perform  while q <= x         /*perform while  Q <= X.    */\n                  q ◄── q * 4                   /*multiply  Q  by  four.    */\n                  end  /*perform*/\n                                                /*Q  is now greater than  X.*/\n         z ◄── x                                /*set  Z  to the value of X.*/\n         r ◄── 0                                /*initialize  R  to zero.   */\n                  perform  while q > 1          /*perform while  Q > unity. */\n                  q ◄── q ÷ 4                   /*integer divide by  four.  */\n                  t ◄── z - r - q               /*compute value of  T.      */\n                  r ◄── r ÷ 2                   /*integer divide by  two.   */\n                  if t >= 0  then do            \n                                  z ◄── t       /*set  Z  to value of  T.   */\n                                  r ◄── r + q   /*compute new value of  R.  */\n                                  end\n                  end  /*perform*/\n                                                /*R  is now the  Isqrt(X).  */\n\n         /* Sidenote: Also, Z is now the remainder after square root (i.e.  */\n         /*           R^2 + Z = X, so if Z = 0 then X is a perfect square). */\n\n```\n\nAnother version for the (above)   1st   **perform**   is:\n\n```\n                  perform  until q > X          /*perform until  Q > X.     */\n                  q ◄── q * 4                   /*multiply  Q  by  four.    */\n                  end  /*perform*/\n\n```\n\nInteger square roots of some values:\n\n```\nIsqrt( 0)  is   0               Isqrt(60)  is  7                Isqrt( 99)  is   9\nIsqrt( 1)  is   1               Isqrt(61)  is  7                Isqrt(100)  is  10\nIsqrt( 2)  is   1               Isqrt(62)  is  7                Isqrt(102)  is  10\nIsqrt( 3)  is   1               Isqrt(63)  is  7\nIsqrt( 4)  is   2               Isqrt(64)  is  8                Isqet(120)  is  10\nIsqrt( 5)  is   2               Isqrt(65)  is  8                Isqrt(121)  is  11\nIsqrt( 6)  is   2               Isqrt(66)  is  8                Isqrt(122)  is  11\nIsqrt( 7)  is   2               Isqrt(67)  is  8\nIsqrt( 8)  is   2               Isqrt(68)  is  8                Isqrt(143)  is  11\nIsqrt( 9)  is   3               Isqrt(69)  is  8                Isqrt(144)  is  12\nIsqrt(10)  is   3               Isqrt(70)  is  8                Isqrt(145)  is  12\n\n```\n\nTask\n\nCompute and show all output here   (on this page)   for:\n\n:   :   * the `Isqrt` of the     integers     from     **0** ───► **65**    (inclusive), shown in a horizontal format.\n        * the `Isqrt` of the   odd powers  from   **71** ───► **773**   (inclusive), shown in a   vertical   format.\n        * use commas in the displaying of larger numbers.\n\nYou can show more numbers for the 2nd requirement if the displays fits on one screen on Rosetta Code.\n  \nIf your computer programming language only supports smaller integers,   show what you can.\n\nRelated tasks\n:   * sequence of non-squares\n    * integer roots\n    * square root by hand"}, {"role": "assistant", "content": "There is a task Integer roots that covers a similar operation, with the caveat that it will calculate **any** nth root (including 2) not just **square** roots.\n\nSee the Integer roots Raku entry.\n\nQuadratic residue algorithm follows:\n\n```\nuse Lingua::EN::Numbers;\n\nsub isqrt ( \\x ) { my ( $X, $q, $r, $t ) =  x, 1, 0 ;\n    $q +<= 2 while $q ≤ $X ;\n    while $q > 1 {\n        $q +>= 2; $t = $X - $r - $q; $r +>= 1;\n        if $t ≥ 0 { $X = $t; $r += $q }\n    }\n    $r\n}\n\nsay (^66)».&{ isqrt $_ }.Str ;\n\n(1, 3…73)».&{ \"7**$_: \" ~ comma(isqrt 7**$_) }».say\n\n```\n\nOutput:\n\n```\n0 1 1 1 2 2 2 2 2 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8\n7**1: 2\n7**3: 18\n7**5: 129\n7**7: 907\n7**9: 6,352\n7**11: 44,467\n7**13: 311,269\n7**15: 2,178,889\n7**17: 15,252,229\n7**19: 106,765,608\n7**21: 747,359,260\n7**23: 5,231,514,822\n7**25: 36,620,603,758\n7**27: 256,344,226,312\n7**29: 1,794,409,584,184\n7**31: 12,560,867,089,291\n7**33: 87,926,069,625,040\n7**35: 615,482,487,375,282\n7**37: 4,308,377,411,626,977\n7**39: 30,158,641,881,388,842\n7**41: 211,110,493,169,721,897\n7**43: 1,477,773,452,188,053,281\n7**45: 10,344,414,165,316,372,973\n7**47: 72,410,899,157,214,610,812\n7**49: 506,876,294,100,502,275,687\n7**51: 3,548,134,058,703,515,929,815\n7**53: 24,836,938,410,924,611,508,707\n7**55: 173,858,568,876,472,280,560,953\n7**57: 1,217,009,982,135,305,963,926,677\n7**59: 8,519,069,874,947,141,747,486,745\n7**61: 59,633,489,124,629,992,232,407,216\n7**63: 417,434,423,872,409,945,626,850,517\n7**65: 2,922,040,967,106,869,619,387,953,625\n7**67: 20,454,286,769,748,087,335,715,675,381\n7**69: 143,180,007,388,236,611,350,009,727,669\n7**71: 1,002,260,051,717,656,279,450,068,093,686\n7**73: 7,015,820,362,023,593,956,150,476,655,802\n```"}]}
{"messages": [{"role": "user", "content": "If you add the square of the digits of a Natural number (an integer bigger than zero), you always end with either 1 or 89:\n\n```\n15 -> 26 -> 40 -> 16 -> 37 -> 58 -> 89\n7 -> 49 -> 97 -> 130 -> 10 -> 1\n```\n\nAn example in Python:\n\n```\n>>> step = lambda x: sum(int(d) ** 2 for d in str(x))\n>>> iterate = lambda x: x if x in [1, 89] else iterate(step(x))\n>>> [iterate(x) for x in xrange(1, 20)]\n[1, 89, 89, 89, 89, 89, 1, 89, 89, 1, 89, 89, 1, 89, 89, 89, 89, 89, 1]\n\n```\n\nTask\n:   Count how many number chains for integers 1 <= n < 100\\_000\\_000 end with a value 89.\n\nOr, for much less credit - (showing that your algorithm and/or language is slow):\n\n:   Count how many number chains for integers 1 <= n < 1\\_000\\_000 end with a value 89.\n\nThis problem derives from the Project Euler problem 92.\n\nFor a quick algorithm for this task see the talk page\n\nRelated tasks\n\n* Combinations with repetitions\n* Digital root\n* Digital root/Multiplicative digital root\n* Happy numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\nThis fairly abstract version does caching and filtering to reduce the number of values it needs to check and moves calculations out of the hot loop, but is still interminably slow... even for just up to 1,000,000.\n\n```\nconstant @sq = ^10 X** 2;\nmy $cnt = 0;\n\nsub Euler92($n) {\n    $n == any(1,89) ?? $n !!\n    (state %){$n} //= Euler92( [+] @sq[$n.comb] )\n}\n\nfor 1 .. 1_000_000 -> $n {\n   my $i = +$n.comb.sort.join;\n   ++$cnt if Euler92($i) == 89;\n}\n \nsay $cnt;\n\n```\n\nOutput:\n\n```\n856929\n```\n\nAll is not lost, however. Through the use of gradual typing, Raku scales down as well as up, so this jit-friendly version is performant enough to brute force the larger calculation:\n\n```\nmy @cache;\n@cache[1] = 1;\n@cache[89] = 89;\n\nsub Euler92(int $n) {\n    $n < 649  # 99,999,999 sums to 648, so no point remembering more\n        ?? (@cache.AT-POS($n) //= ids($n))\n        !! ids($n)\n}\n\nsub ids(int $num --> int) {\n    my int $n = $num;\n    my int $ten = 10;\n    my int $sum = 0;\n    my int $t;\n    my int $c;\n    repeat until $n == 89 or $n == 1 {\n        $sum = 0;\n        repeat {\n            $t = $n div $ten;\n            $c = $n - $t * $ten;\n            $sum = $sum + $c * $c;\n        } while $n = $t;\n        $n = @cache.AT-POS($sum) // $sum;\n    }\n    $n;\n}\n\nmy int $cnt = 0;\nfor 1 .. 100_000_000 -> int $n {\n   $cnt = $cnt + 1 if Euler92($n) == 89;\n}\nsay $cnt;\n\n```\n\nOutput:\n\n```\n85744333\n```\n\nWhich is better, but is still pretty slow.\n\nThe biggest gains are often from choosing the right algorithm.\n\n```\nsub endsWithOne($n --> Bool) {\n    my $digit;\n    my $sum = 0;\n    my $nn = $n;\n    loop {\n        while $nn > 0 {\n            $digit = $nn % 10;\n            $sum += $digit²;\n            $nn = $nn div 10;\n        }\n        return True  if $sum == 1;\n        return False if $sum == 89;\n        $nn = $sum;\n        $sum = 0;\n    }\n}\n\nmy $k = 8; # 10**8\nmy @sums is default(0) = 1,0;\nmy $s;\nfor 1 .. $k -> $n {\n    for $n*81 … 1 -> $i {\n        for 1 .. 9 -> $j {\n            $s = $j²;\n            last if $s > $i;\n            @sums[$i] += @sums[$i - $s];\n        }\n    }\n}\n\nmy $ends-with-one = sum flat @sums[(1 .. $k*81).grep: { endsWithOne($_) }], +endsWithOne(10**$k);\n\nsay 10**$k - $ends-with-one;\n\n```\n\nOutput:\n\n```\n85744333\n```"}]}
{"messages": [{"role": "user", "content": "Iterators are a design pattern that can be used to access elements of a container without depending on the\nimplementation or type of the container.\n\nTask\n\n* Create an array like container to hold the days of the week and a linked-list like container to hold colors.\n* Print all of the elements of each container.\n* Print the first, fourth, and fifth elements of each container.\n* Print the last, fourth to last, and fifth to last of each container.\n\nIf you language supports iterators, use them. Otherwise show how access to elements can be\nseparated from the containers that hold them."}, {"role": "assistant", "content": "Raku has iterators, but is rare for casual users to ever explicitly use them. Operators and functions that are designed to work on Iterable objects generally have the iteration semantics built in; so don't need an iterator to be explicitly called. It is far, **far** more common to use object slices to do the task example operations.\n\nRakus iterators are one direction only (not reversible), since they are designed to be able to work with infinite streams. It is difficult to reverse a stream that has no end. If the object / collection is finite, it may be reversed, but that is a separate operation from iteration.\n\nOnce an iteration has been reified, it is discarded unless explicitly cached. This allows effortless iteration through multi-gigabyte sized data objects and streams without filling up main memory.\n\nThe following example iterates though a hash of Positional Iterable objects and demonstrates both using explicit iterators, and object slice operations on each; then has a semi contrived example of where directly using iterators may be actually useful in Raku; collating unique ascending values from several infinite sequence generators.\n\n```\nmy %positional-iterable-types =\n    array    => [<Sunday Monday Tuesday Wednesday Thursday Friday Saturday>],\n    list     => <Red Orange Yellow Green Blue Purple>,\n    range    => 'Rako' .. 'Raky',\n    sequence => (1.25, 1.5, * × * … * > 50),\n;\n\nsub first-fourth-fifth ($iterable) {\n    my $iterator = $iterable.iterator;\n    gather {\n        take $iterator.pull-one;\n        $iterator.skip-one xx 2;\n        take $iterator.pull-one;\n        take $iterator.pull-one;\n    }\n}\n \nsay \"Note: here we are iterating over the %positional-iterable-types hash, but\nthe order we get elements out is not the same as the order they were inserted.\nHashes are not guaranteed to be in any specific order, in fact, they are\nguaranteed to _not_ be in any specific order.\";\n \nfor %positional-iterable-types.values {\n    say \"\\nType \" ~ .^name ~ ', contents: ' ~ $_ ~\n    \"\\nUsing iterators    : first, fourth and fifth from start: \" ~ first-fourth-fifth($_) ~ ', and from end: ' ~ first-fourth-fifth(.reverse) ~\n    \"\\nUsing object slices: first, fourth and fifth from start: \" ~ .[0, 3, 4] ~ ', and from end: ' ~ .[*-1, *-4, *-5] ~ \"\\n\";\n};\n\n\nsay \"\\nWhere iterators really shine; when you are collating the values from several infinite generators.\";\nmy @i = (1, * × 2 … *).iterator, (1, * × 3 … *).iterator, (1, * × 5 … *).iterator;\nmy @v = @i[0].pull-one, @i[1].pull-one, @i[2].pull-one;\n\nmy @seq = lazy gather loop {\n    take my $min := @v.min;\n    for ^@v { @v[$_] = @i[$_].pull-one if @v[$_] == $min };\n}\n\nsay @seq[^25];\n\n```\n\nOutput:\n\n```\nNote: here we are iterating over the %positional-iterable-types hash, but\nthe order we get elements out is not the same as the order they were inserted.\nHashes are not guaranteed to be in any specific order, in fact, they are\nguaranteed to _not_ be in any specific order.\n\nType Range, contents: Rako Rakp Rakq Rakr Raks Rakt Raku Rakv Rakw Rakx Raky\nUsing iterators    : first, fourth and fifth from start: Rako Rakr Raks, and from end: Raky Rakv Raku\nUsing object slices: first, fourth and fifth from start: Rako Rakr Raks, and from end: Raky Rakv Raku\n\n\nType Seq, contents: 1.25 1.5 1.875 2.8125 5.273438 14.831543 78.2132149\nUsing iterators    : first, fourth and fifth from start: 1.25 2.8125 5.273438, and from end: 78.2132149 2.8125 1.875\nUsing object slices: first, fourth and fifth from start: 1.25 2.8125 5.273438, and from end: 78.2132149 2.8125 1.875\n\n\nType Array, contents: Sunday Monday Tuesday Wednesday Thursday Friday Saturday\nUsing iterators    : first, fourth and fifth from start: Sunday Wednesday Thursday, and from end: Saturday Wednesday Tuesday\nUsing object slices: first, fourth and fifth from start: Sunday Wednesday Thursday, and from end: Saturday Wednesday Tuesday\n\n\nType List, contents: Red Orange Yellow Green Blue Purple\nUsing iterators    : first, fourth and fifth from start: Red Green Blue, and from end: Purple Yellow Orange\nUsing object slices: first, fourth and fifth from start: Red Green Blue, and from end: Purple Yellow Orange\n\n\nWhere iterators really shine; when you are collating the values from several infinite generators.\n(1 2 3 4 5 8 9 16 25 27 32 64 81 125 128 243 256 512 625 729 1024 2048 2187 3125 4096)\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Jaccard index. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThe **Jaccard index**, also known as the **Jaccard similarity coefficient**, is a statistic used for gauging the similarity and diversity of sample sets. It was developed by Paul Jaccard, originally giving the French name *coefficient de communauté*, and independently formulated again by T. Tanimoto. Thus, the **Tanimoto index** or **Tanimoto coefficient** are also used in some fields. However, they are identical in generally taking the ratio of **Intersection over Union**. The Jaccard coefficient measures similarity between finite sample sets, and is defined as the size of the intersection divided by the size of the union of the sample sets:\n\n:   J(A, B) = |A ∩ B|/|A ∪ B|\n\nDefine sets as follows, using any linear data structure:\n\n```\nA = {}\nB = {1, 2, 3, 4, 5}\nC = {1, 3, 5, 7, 9}\nD = {2, 4, 6, 8, 10}\nE = {2, 3, 5, 7}\nF = {8}\n\n```\n\nWrite a program that computes the Jaccard index for every ordered pairing (to show that J(A, B) and J(B, A) are the same) of these sets, including self-pairings."}, {"role": "assistant", "content": "```\nsub J(\\A, \\B) { A ∪ B ?? (A ∩ B) / (A ∪ B) !! A ∪ B == A ∩ B ?? 1 !! 0 }\n\nmy %p =\n  A => < >,\n  B => <1 2 3 4 5>,\n  C => <1 3 5 7 9>,\n  D => <2 4 6 8 10>,\n  E => <2 3 5 7>,\n  F => <8>,\n;\n\n.say for %p.sort;\nsay '';\nsay \"J({.join: ','}) = \", J |%p{$_} for [X] <A B C D E F> xx 2;\n\n```\n\nOutput:\n\n```\nA => ()\nB => (1 2 3 4 5)\nC => (1 3 5 7 9)\nD => (2 4 6 8 10)\nE => (2 3 5 7)\nF => 8\n\nJ(A,A) = 1\nJ(A,B) = 0\nJ(A,C) = 0\nJ(A,D) = 0\nJ(A,E) = 0\nJ(A,F) = 0\nJ(B,A) = 0\nJ(B,B) = 1\nJ(B,C) = 0.428571\nJ(B,D) = 0.25\nJ(B,E) = 0.5\nJ(B,F) = 0\nJ(C,A) = 0\nJ(C,B) = 0.428571\nJ(C,C) = 1\nJ(C,D) = 0\nJ(C,E) = 0.5\nJ(C,F) = 0\nJ(D,A) = 0\nJ(D,B) = 0.25\nJ(D,C) = 0\nJ(D,D) = 1\nJ(D,E) = 0.125\nJ(D,F) = 0.2\nJ(E,A) = 0\nJ(E,B) = 0.5\nJ(E,C) = 0.5\nJ(E,D) = 0.125\nJ(E,E) = 1\nJ(E,F) = 0\nJ(F,A) = 0\nJ(F,B) = 0\nJ(F,C) = 0\nJ(F,D) = 0.2\nJ(F,E) = 0\nJ(F,F) = 1\n```"}]}
{"messages": [{"role": "user", "content": "The **Jacobi symbol** is a multiplicative function that generalizes the Legendre symbol. Specifically, the Jacobi symbol (a | n) equals the product of the Legendre symbols (a | p\\_i)^(k\\_i), where n = p\\_1^(k\\_1)\\*p\\_2^(k\\_2)\\*...\\*p\\_i^(k\\_i) and the Legendre symbol (a | p) denotes the value of a ^ ((p-1)/2) (mod p)\n\n* (a | p) ≡   1     if a is a square (mod p)\n* (a | p) ≡ -1     if a is not a square (mod p)\n* (a | p) ≡   0     if a ≡ 0\n\nIf n is prime, then the Jacobi symbol (a | n) equals the Legendre symbol (a | n).\n\nTask\n\nCalculate the Jacobi symbol (a | n).\n\nReference\n\n* Wikipedia article on Jacobi symbol."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\n```\n# Jacobi function\nsub infix:<J> (Int $k is copy, Int $n is copy where * % 2) {\n    $k %= $n;\n    my $jacobi = 1;\n    while $k {\n        while $k %% 2 {\n            $k div= 2;\n            $jacobi *= -1 if $n % 8 == 3 | 5;\n        }\n        ($k, $n) = $n, $k;\n        $jacobi *= -1 if 3 == $n%4 & $k%4;\n        $k %= $n;\n    }\n    $n == 1 ?? $jacobi !! 0\n}\n\n# Testing\n\nmy $maxa = 30;\nmy $maxn = 29;\n\nsay 'n\\k ', (1..$maxa).fmt: '%3d';\nsay '   ', '-' x 4 * $maxa;\nfor 1,*+2 … $maxn -> $n {\n    print $n.fmt: '%3d';\n    for 1..$maxa -> $k {\n        print ($k J $n).fmt: '%4d';\n    }\n    print \"\\n\";\n}\n\n```\n\nOutput:\n\n```\nn\\k   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30\n   ------------------------------------------------------------------------------------------------------------------------\n  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1\n  3   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0\n  5   1  -1  -1   1   0   1  -1  -1   1   0   1  -1  -1   1   0   1  -1  -1   1   0   1  -1  -1   1   0   1  -1  -1   1   0\n  7   1   1  -1   1  -1  -1   0   1   1  -1   1  -1  -1   0   1   1  -1   1  -1  -1   0   1   1  -1   1  -1  -1   0   1   1\n  9   1   1   0   1   1   0   1   1   0   1   1   0   1   1   0   1   1   0   1   1   0   1   1   0   1   1   0   1   1   0\n 11   1  -1   1   1   1  -1  -1  -1   1  -1   0   1  -1   1   1   1  -1  -1  -1   1  -1   0   1  -1   1   1   1  -1  -1  -1\n 13   1  -1   1   1  -1  -1  -1  -1   1   1  -1   1   0   1  -1   1   1  -1  -1  -1  -1   1   1  -1   1   0   1  -1   1   1\n 15   1   1   0   1   0   0  -1   1   0   0  -1   0  -1  -1   0   1   1   0   1   0   0  -1   1   0   0  -1   0  -1  -1   0\n 17   1   1  -1   1  -1  -1  -1   1   1  -1  -1  -1   1  -1   1   1   0   1   1  -1   1  -1  -1  -1   1   1  -1  -1  -1   1\n 19   1  -1  -1   1   1   1   1  -1   1  -1   1  -1  -1  -1  -1   1   1  -1   0   1  -1  -1   1   1   1   1  -1   1  -1   1\n 21   1  -1   0   1   1   0   0  -1   0  -1  -1   0  -1   0   0   1   1   0  -1   1   0   1  -1   0   1   1   0   0  -1   0\n 23   1   1   1   1  -1   1  -1   1   1  -1  -1   1   1  -1  -1   1  -1   1  -1  -1  -1  -1   0   1   1   1   1  -1   1  -1\n 25   1   1   1   1   0   1   1   1   1   0   1   1   1   1   0   1   1   1   1   0   1   1   1   1   0   1   1   1   1   0\n 27   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0   1  -1   0\n 29   1  -1  -1   1   1   1   1  -1   1  -1  -1  -1   1  -1  -1   1  -1  -1  -1   1  -1   1   1   1   1  -1  -1   1   0   1\n```"}]}
{"messages": [{"role": "user", "content": "**Jacobsthal numbers** are an integer sequence related to Fibonacci numbers. Similar to Fibonacci, where each term is the sum of the previous two terms, each term is the sum of the previous, plus twice the one before that. Traditionally the sequence starts with the given terms 0, 1.\n\n```\n\n   J0 = 0\n   J1 = 1\n   Jn = Jn-1 + 2 × Jn-2\n\n\n```\n\nTerms may be calculated directly using one of several possible formulas:\n\n```\n\n   Jn = ( 2n - (-1)n ) / 3\n\n\n```\n\n**Jacobsthal-Lucas numbers** are very similar. They have the same recurrence relationship, the only difference is an initial starting value **J0 = 2** rather than **J0 = 0**.\n\nTerms may be calculated directly using one of several possible formulas:\n\n```\n   \n   JLn = 2n + (-1)n\n   \n\n```\n\n**Jacobsthal oblong numbers** is the sequence obtained from multiplying each **Jacobsthal number** **Jn** by its direct successor **Jn+1**.\n\n**Jacobsthal primes** are **Jacobsthal numbers** that are prime.\n\nTask\n\n* Find and display the first 30 **Jacobsthal numbers**\n* Find and display the first 30 **Jacobsthal-Lucas numbers**\n* Find and display the first 20 **Jacobsthal oblong numbers**\n* Find and display at least the first 10 **Jacobsthal primes**\n\nSee also\n\n* Wikipedia: Jacobsthal number * Numbers Aplenty - Jacobsthal number * OEIS:A001045 - Jacobsthal sequence (or Jacobsthal numbers) * OEIS:A014551 - Jacobsthal-Lucas numbers. * OEIS:A084175 - Jacobsthal oblong numbers * OEIS:A049883 - Primes in the Jacobsthal sequence * Related task: Fibonacci sequence * Related task: Leonardo numbers"}, {"role": "assistant", "content": "```\nmy $jacobsthal = cache lazy 0, 1, * × 2 + * … *;\nmy $jacobsthal-lucas = lazy 2, 1, * × 2 + * … *;\n\nsay \"First 30 Jacobsthal numbers:\";\nsay $jacobsthal[^30].batch(5)».fmt(\"%9d\").join: \"\\n\";\n\nsay \"\\nFirst 30 Jacobsthal-Lucas numbers:\";\nsay $jacobsthal-lucas[^30].batch(5)».fmt(\"%9d\").join: \"\\n\";\n\nsay \"\\nFirst 20 Jacobsthal oblong numbers:\";\nsay (^∞).map( { $jacobsthal[$_] × $jacobsthal[$_+1] } )[^20].batch(5)».fmt(\"%11d\").join: \"\\n\";\n\nsay \"\\nFirst 20 Jacobsthal primes:\";\nsay $jacobsthal.grep( &is-prime )[^20].join: \"\\n\";\n\n```\n\nOutput:\n\n```\nFirst 30 Jacobsthal numbers:\n        0         1         1         3         5\n       11        21        43        85       171\n      341       683      1365      2731      5461\n    10923     21845     43691     87381    174763\n   349525    699051   1398101   2796203   5592405\n 11184811  22369621  44739243  89478485 178956971\n\nFirst 30 Jacobsthal-Lucas numbers:\n        2         1         5         7        17\n       31        65       127       257       511\n     1025      2047      4097      8191     16385\n    32767     65537    131071    262145    524287\n  1048577   2097151   4194305   8388607  16777217\n 33554431  67108865 134217727 268435457 536870911\n\nFirst 20 Jacobsthal oblong numbers:\n          0           1           3          15          55\n        231         903        3655       14535       58311\n     232903      932295     3727815    14913991    59650503\n  238612935   954429895  3817763271 15270965703 61084037575\n\nFirst 20 Jacobsthal primes:\n3\n5\n11\n43\n683\n2731\n43691\n174763\n2796203\n715827883\n2932031007403\n768614336404564651\n201487636602438195784363\n845100400152152934331135470251\n56713727820156410577229101238628035243\n62357403192785191176690552862561408838653121833643\n1046183622564446793972631570534611069350392574077339085483\n267823007376498379256993682056860433753700498963798805883563\n5562466239377370006237035693149875298444543026970449921737087520370363869220418099018130434731\n95562442332919646317117537304253622533190207882011713489066201641121786503686867002917439712921903606443\n```"}]}
{"messages": [{"role": "user", "content": "The Jaro distance is a measure of edit distance between two strings; its inverse, called the *Jaro similarity*, is a measure of two strings' similarity: the higher the value, the more similar the strings are. The score is normalized such that   **0**   equates to no similarities and   **1**   is an exact match.\n\nDefinition\n\nThe Jaro similarity   \n\nd\n\nj\n{\\displaystyle {\\displaystyle d\\_{j}}}\n   of two given strings   \n\ns\n\n1\n{\\displaystyle {\\displaystyle s\\_{1}}}\n   and   \n\ns\n\n2\n{\\displaystyle {\\displaystyle s\\_{2}}}\n   is\n\n:   d\n\n    j\n    =\n\n    {\n\n    0\n\n\n    if \n    m\n    =\n    0\n\n    1\n    3\n\n    (\n\n    m\n\n\n    |\n\n    s\n\n    1\n\n    |\n    +\n\n\n    m\n\n\n    |\n\n    s\n\n    2\n\n    |\n    +\n\n    m\n    −\n    t\n    m\n    )\n\n\n    otherwise\n\n    {\\displaystyle {\\displaystyle d\\_{j}=\\left\\{{\\begin{array}{l l}0&{\\text{if }}m=0\\\\{\\frac {1}{3}}\\left({\\frac {m}{|s\\_{1}|}}+{\\frac {m}{|s\\_{2}|}}+{\\frac {m-t}{m}}\\right)&{\\text{otherwise}}\\end{array}}\\right.}}\n\nWhere:\n\n* m\n  {\\displaystyle {\\displaystyle m}}\n     is the number of *matching characters*;\n* t\n  {\\displaystyle {\\displaystyle t}}\n     is half the number of *transpositions*.\n\nTwo characters from   \n\ns\n\n1\n{\\displaystyle {\\displaystyle s\\_{1}}}\n   and   \n\ns\n\n2\n{\\displaystyle {\\displaystyle s\\_{2}}}\n   respectively, are considered *matching* only if they are the same and not farther apart than   \n\n⌊\n\nmax\n(\n\n|\n\ns\n\n1\n\n|\n,\n\n|\n\ns\n\n2\n\n|\n)\n2\n⌋\n−\n1\n{\\displaystyle {\\displaystyle \\left\\lfloor {\\frac {\\max(|s\\_{1}|,|s\\_{2}|)}{2}}\\right\\rfloor -1}}\n characters.\n\nEach character of   \n\ns\n\n1\n{\\displaystyle {\\displaystyle s\\_{1}}}\n   is compared with all its matching characters in   \n\ns\n\n2\n{\\displaystyle {\\displaystyle s\\_{2}}}\n. Each difference in position is half a *transposition*; that is, the number of transpositions is half the number of characters which are common to the two strings but occupy different positions in each one.\n\nExample\n\nGiven the strings   \n\ns\n\n1\n{\\displaystyle {\\displaystyle s\\_{1}}}\n   *DWAYNE*   and   \n\ns\n\n2\n{\\displaystyle {\\displaystyle s\\_{2}}}\n   *DUANE*   we find:\n\n* m\n  =\n  4\n  {\\displaystyle {\\displaystyle m=4}}\n* |\n\n  s\n\n  1\n\n  |\n  =\n  6\n  {\\displaystyle {\\displaystyle |s\\_{1}|=6}}\n* |\n\n  s\n\n  2\n\n  |\n  =\n  5\n  {\\displaystyle {\\displaystyle |s\\_{2}|=5}}\n* t\n  =\n  0\n  {\\displaystyle {\\displaystyle t=0}}\n\nWe find a Jaro score of:\n\n:   d\n\n    j\n    =\n\n\n    1\n    3\n\n    (\n\n    4\n    6\n    +\n\n\n    4\n    5\n    +\n\n    4\n    −\n    0\n    4\n    )\n    =\n    0.822\n    {\\displaystyle {\\displaystyle d\\_{j}={\\frac {1}{3}}\\left({\\frac {4}{6}}+{\\frac {4}{5}}+{\\frac {4-0}{4}}\\right)=0.822}}\n\nTask\n\nImplement the Jaro algorithm and show the similarity scores for each of the following pairs:\n\n* (\"MARTHA\", \"MARHTA\")\n* (\"DIXON\", \"DICKSONX\")\n* (\"JELLYFISH\", \"SMELLYFISH\")\n\nSee also\n\n* Jaro–Winkler distance on Wikipedia."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nsub jaro ($s, $t) {\n    return 1 if $s eq $t;\n\n    my $s-len = + my @s = $s.comb;\n    my $t-len = + my @t = $t.comb;\n    my $match-distance = ($s-len max $t-len) div 2 - 1;\n\n    my ($matches, @s-matches, @t-matches);\n    for ^@s -> $i {\n        my $start = 0 max $i - $match-distance;\n        my $end   = $i + $match-distance min ($t-len - 1);\n\n        for $start .. $end -> $j {\n            next if @t-matches[$j] or @s[$i] ne @t[$j];\n            (@s-matches[$i], @t-matches[$j]) = (1, 1);\n            $matches++ and last;\n        }\n    }\n    return 0 unless $matches;\n\n    my ($k, $transpositions) = (0, 0);\n    for ^@s -> $i {\n        next unless @s-matches[$i];\n        $k++ until  @t-matches[$k];\n        $transpositions++ if @s[$i] ne @t[$k];\n        $k++;\n    }\n\n    ( $matches/$s-len + $matches/$t-len + (($matches - $transpositions/2) / $matches) ) / 3\n}\n\nsay jaro(.key, .value).fmt: '%.3f' for\n    'MARTHA' => 'MARHTA', 'DIXON' => 'DICKSONX', 'JELLYFISH' => 'SMELLYFISH',\n    'I repeat myself' => 'I repeat myself', '' => '';\n\n```\n\nOutput:\n\n```\n0.944\n0.767\n0.896\n1.000\n1.000\n```"}]}
{"messages": [{"role": "user", "content": "The Jaro-Winkler distance is a metric for measuring the edit distance between words.\nIt is similar to the more basic Levenshtein distance but the Jaro distance also accounts\nfor transpositions between letters in the words. With the Winkler modification to the Jaro\nmetric, the Jaro-Winkler distance also adds an increase in similarity for words which\nstart with the same letters (prefix).\n\nThe Jaro-Winkler distance is a modification of the Jaro similarity metric, which\nmeasures the similarity between two strings. The Jaro similarity is 1.0 when strings are\nidentical and 0 when strings have no letters in common. Distance measures such as the\nJaro distance or Jaro-Winkler distance, on the other hand, are 0 when strings are\nidentical and 1 when they have no letters in common.\n\nThe Jaro similarity between two strings s1 and s2, simj, is defined as\n\n:   simj = 0     if m is 0.\n:   simj = ( (m / length of s1) + (m / length of s2) + (m - t) / m ) / 3     otherwise.\n\nWhere:\n\n* m\n  {\\displaystyle {\\displaystyle m}}\n     is the number of *matching characters (the same character within max(|s1|, |s2|)/2 - 1 of one another)*;\n* t\n  {\\displaystyle {\\displaystyle t}}\n     is half the number of *transpositions (a shared character placed in different positions)*.\n\nThe Winkler modification to Jaro is to check for identical prefixes of the strings.\n\nIf we define the number of initial (prefix) characters in common as:\n\n*l* = the length of a common prefix between strings, up to 4 characters\n\nand, additionally, select a multiplier (Winkler suggested 0.1) for the relative importance of the\nprefix for the word similarity:\n\n*p*    =   0.1\n\nThe Jaro-Winkler similarity can then be defined as\n\nsimw = simj + *l**p*(1 - simj)\n\nWhere:\n\n* simj   is the Jaro similarity.\n* *l*   is the number of matching characters at the beginning of the strings, up to 4.\n* *p*   is a factor to modify the amount to which the prefix similarity affects the metric.\n\nWinkler suggested this be 0.1.\n\nThe Jaro-Winkler distance between strings, which is 0.0 for identical strings, is then defined as\n\ndw = 1 - simw\n\nString metrics such as Jaro-Winkler distance are useful in applications such as spelling checkers,\nbecause letter transpositions are common typing errors and humans tend to misspell the middle portions\nof words more often than their beginnings. This may help a spelling checker program to generate\nbetter alternatives for misspelled word replacement.\n\nThe task\n\nUsing a dictionary of your choice and the following list of 9 commonly misspelled words:\n\n\"accomodate\", \"definately\", \"goverment​\", \"occured\", \"publically\", \"recieve​\", \"seperate\", \"untill\", \"wich​\"\n\n* Calculate the Jaro-Winkler distance between the misspelled word and words in the dictionary.\n\n* Use this distance to list close alternatives (at least two per word) to the misspelled words.\n\n* Show the calculated distances between the misspelled words and their potential replacements.\n\nSee also\n:   * Wikipedia page: Jaro–Winkler distance.\n    * Comparing string similarity algorithms. Comparison of algorithms on Medium"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.07\n\nA minor modification of the Jaro distance task entry.\n\nusing the unixdict.txt file from www.puzzlers.org\n\n```\nsub jaro-winkler ($s, $t) {\n\n    return 0 if $s eq $t;\n\n    my $s_len = + my @s = $s.comb;\n    my $t_len = + my @t = $t.comb;\n\n    my $match_distance = ($s_len max $t_len) div 2 - 1;\n\n    my @s_matches;\n    my @t_matches;\n    my $matches = 0;\n\n    for ^@s -> $i {\n\n        my $start = 0 max $i - $match_distance;\n        my $end = $i + $match_distance min ($t_len - 1);\n\n        for $start .. $end -> $j {\n            @t_matches[$j] and next;\n            @s[$i] eq @t[$j] or next;\n            @s_matches[$i] = 1;\n            @t_matches[$j] = 1;\n            $matches++;\n            last;\n        }\n    }\n\n    return 1 if $matches == 0;\n\n    my $k              = 0;\n    my $transpositions = 0;\n\n    for ^@s -> $i {\n        @s_matches[$i] or next;\n        until @t_matches[$k] { ++$k }\n        @s[$i] eq @t[$k] or ++$transpositions;\n        ++$k;\n    }\n\n    my $prefix = 0;\n\n    ++$prefix if @s[$_] eq @t[$_] for ^(min 4, $s_len, $t_len);\n\n    my $jaro = ($matches / $s_len + $matches / $t_len +\n        (($matches - $transpositions / 2) / $matches)) / 3;\n\n    1 - ($jaro + $prefix * .1 * ( 1 - $jaro) )\n}\n\n\nmy @words =  './unixdict.txt'.IO.slurp.words;\n\nfor <accomodate definately goverment occured publically recieve seperate untill wich>\n   -> $word {\n\n   my %result = @words.race.map: { $_ => jaro-winkler($word, $_) };\n\n   say \"\\nClosest 5 dictionary words with a Jaro-Winkler distance < .15 from $word:\";\n\n   printf \"%15s : %0.4f\\n\", .key, .value for %result.grep({ .value < .15 }).sort({+.value, ~.key}).head(5);\n}\n\n```\n\nOutput:\n\n```\nClosest 5 dictionary words with a Jaro-Winkler distance < .15 from accomodate:\n    accommodate : 0.0182\n      accordant : 0.1044\n       accolade : 0.1136\n      acclimate : 0.1219\n    accompanist : 0.1327\n\nClosest 5 dictionary words with a Jaro-Winkler distance < .15 from definately:\n         define : 0.0800\n       definite : 0.0850\n        defiant : 0.0886\n     definitive : 0.1200\n      designate : 0.1219\n\nClosest 5 dictionary words with a Jaro-Winkler distance < .15 from goverment:\n         govern : 0.0667\n       governor : 0.1167\n      governess : 0.1175\n     governance : 0.1330\n       coverlet : 0.1361\n\nClosest 5 dictionary words with a Jaro-Winkler distance < .15 from occured:\n       occurred : 0.0250\n          occur : 0.0571\n      occurrent : 0.0952\n        occlude : 0.1056\n      concurred : 0.1217\n\nClosest 5 dictionary words with a Jaro-Winkler distance < .15 from publically:\n         public : 0.0800\n    publication : 0.1327\n           pull : 0.1400\n       pullback : 0.1492\n\nClosest 5 dictionary words with a Jaro-Winkler distance < .15 from recieve:\n        receive : 0.0333\n        relieve : 0.0667\n          reeve : 0.0762\n      receptive : 0.0852\n      recessive : 0.0852\n\nClosest 5 dictionary words with a Jaro-Winkler distance < .15 from seperate:\n      desperate : 0.0708\n       separate : 0.0917\n      temperate : 0.1042\n       selenate : 0.1167\n           sept : 0.1167\n\nClosest 5 dictionary words with a Jaro-Winkler distance < .15 from untill:\n          until : 0.0333\n           till : 0.1111\n     huntsville : 0.1333\n        instill : 0.1357\n         unital : 0.1422\n\nClosest 5 dictionary words with a Jaro-Winkler distance < .15 from wich:\n          winch : 0.0533\n          witch : 0.0533\n          which : 0.0600\n        wichita : 0.0857\n         switch : 0.1111\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Jensen's Device. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThis task is an exercise in call by name.\n\n**Jensen's Device** is a computer programming technique devised by Danish computer scientist Jørn Jensen after studying the ALGOL 60 Report.\n\nThe following program was proposed to illustrate the technique. It computes the 100th harmonic number:\n\n```\nbegin\n   integer i;\n   real procedure sum (i, lo, hi, term);\n      value lo, hi;\n      integer i, lo, hi;\n      real term;\n      comment term is passed by-name, and so is i;\n   begin\n      real temp;\n      temp := 0;\n      for i := lo step 1 until hi do\n         temp := temp + term;\n      sum := temp\n   end;\n   comment note the correspondence between the mathematical notation and the call to sum;\n   print (sum (i, 1, 100, 1/i))\nend\n\n```\n\nThe above exploits call by name to produce the correct answer (5.187...). It depends on the assumption that an expression passed as an actual parameter to a procedure would be re-evaluated in the caller's context every time the corresponding formal parameter's value was required. If the last parameter to *sum* had been passed by value, and assuming the initial value of *i* were 1, the result would have been 100 × 1/1 = 100.\n\nMoreover, the *first* parameter to *sum*, representing the \"bound\" variable of the summation, must also be passed by name (or at least by reference), otherwise changes to it (made within *sum*) would not be visible in the caller's context when computing each of the values to be added.\n(On the other hand, the global variable does not have to use the same identifier, in this case *i*, as the formal parameter.)\n\nDonald Knuth later proposed the Man or Boy Test as a more rigorous exercise."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRather than playing tricks like Perl 5 does, the declarations of the formal parameters are quite straightforward in Raku:\n\n```\nsub sum($i is rw, $lo, $hi, &term) {\n    my $temp = 0;\n    loop ($i = $lo; $i <= $hi; $i++) {\n        $temp += term;\n    }\n    return $temp;\n}\n\nmy $i;\nsay sum $i, 1, 100, { 1 / $i };\n\n```\n\nNote that the C-style \"for\" loop is pronounced \"loop\" in Raku, and is the only loop statement that actually requires parens."}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a function which takes two string parameters: 'stones' and 'jewels' and returns an integer.\n\nBoth strings can contain any number of upper or lower case letters. However, in the case of 'jewels', all letters must be distinct.\n\nThe function should count (and return) how many 'stones' are 'jewels' or, in other words, how many letters in 'stones' are also letters in 'jewels'.\n\nNote that:\n\n:   1. Only letters in the ISO basic Latin alphabet i.e. 'A to Z' or 'a to z' need be considered.\n    2. A lower case letter is considered to be different from its upper case equivalent for this purpose, i.e., 'a' != 'A'.\n    3. The parameters do not need to have exactly the same names.\n    4. Validating the arguments is unnecessary.\n\nSo, for example, if passed \"aAAbbbb\" for 'stones' and \"aA\" for 'jewels', the function should return 3.\n\nThis task was inspired by this problem.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub count-jewels ( Str $j, Str $s --> Int ) {\n    my %counts_of_all = $s.comb.Bag;\n    my @jewel_list    = $j.comb.unique;\n\n    return %counts_of_all ∩ @jewel_list.Bag ?? %counts_of_all{ @jewel_list }.sum !! 0;\n}\n\nsay count-jewels 'aA' , 'aAAbbbb';\nsay count-jewels 'z'  , 'ZZ';\n\n```\n\nOutput:\n\n```\n3\n0\n```"}]}
{"messages": [{"role": "user", "content": "**Jordan-Pólya numbers** (or **J-P numbers** for short) are the numbers that can be obtained by multiplying together one or more (not necessarily distinct) factorials.\n\nExample\n\n480 is a J-P number because 480 = 2! x 2! x 5!.\n\nTask\n\nFind and show on this page the first **50** J-P numbers.\n\nWhat is the largest J-P number less than **100 million**?\n\nBonus\n\nFind and show on this page the **800**th, **1,800**th, **2,800**th and **3,800**th J-P numbers and also show their decomposition into factorials in highest to lowest order. Optionally, do the same for the **1,050**th J-P number.\n\nWhere there is more than one way to decompose a J-P number into factorials, choose the way which uses the largest factorials.\n\nHint: These J-P numbers are all less than 2^53.\n\nReferences\n\n* Wikipedia article : Jordan-Pólya number\n* OEIS sequence A001013: Jordan-Pólya numbers"}, {"role": "assistant", "content": "**Partial translation of Go**\n\n```\n# 20230719 Raku programming solution\n\nmy \\factorials = 1, | [\\*] 1..18; # with 0!\n\nsub JordanPolya (\\limit) {\n   my \\ix = (factorials.keys.first: factorials[*] >= limit) // factorials.end; \n   my ($k, @res) = 2, |factorials[0..ix];\n\n   while $k < @res.elems {\n      my \\rk = @res[$k];\n      for 2 .. @res.elems -> \\l {\n         my \\kl = $ = @res[l] * rk;\n         last if kl > limit;\n         loop {\n            my \\p = @res.keys.first: { @res[$_] >= kl } # performance\n            if p < @res.elems and @res[p] != kl {\n               @res.splice: p, 0, kl\n            } elsif p == @res.elems { \n               @res.append: kl \n            }\n            kl > limit/rk ?? ( last ) !! kl *= rk\n         }\n      }\n      $k++\n   }\n   return @res[1..*]\n}\n\nmy @result = JordanPolya 2**30 ; \nsay \"First 50 Jordan-Pólya numbers:\";\nsay [~] $_>>.fmt('%5s') for @result[^50].rotor(10);\nprint \"\\nThe largest Jordan-Pólya number before 100 million: \";\nsay @result.first: * < 100_000_000, :end;\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| Note:   jortSort is considered a work of satire.   It achieves its result in an intentionally roundabout way.   You are encouraged to write your solutions in the spirit of the original jortsort rather than trying to give the most concise or idiomatic solution. |\n\nJortSort is a sorting tool set that makes the user do the work and guarantees efficiency because you don't have to sort ever again.\n  \nIt was originally presented by Jenn \"Moneydollars\" Schiffer at the\nprestigious   JSConf.\n\nJortSort is a function that takes a single array of comparable objects as its argument.\n\nIt then sorts the array in ascending order and compares the sorted array to the originally provided array.\n\nIf the arrays match   (i.e. the original array was already sorted),   the function returns   **true**.\n\nIf the arrays do not match (i.e. the original array was not sorted), the function returns   **false**."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub jort-sort { @_ eqv @_.sort }\n\n```\n\nActually, there's a better internal sort that seems to work best for lists that are already completely sorted, but tends to fails for any other list. The name of this sort, [!after], is completely opaque, so we're pretty much forced to hide it inside a subroutine to prevent widespread panic.\n\n```\nsub jort-sort-more-better-sorta { [!after] @_ }\n\n```\n\nHowever, since Perl 6 has a really good inliner, there's really little point anyway in using the [!after] reduction operator directly, and jort-sort-more-better-sorta is really much more self-documenting, so please don't use the reduction operator if you can. For example:\n\nOutput:\n\n```\n$ perl6\n> [!after] <a b c>  # DON'T do it this way\nTrue\n> [!after] 1,3,2    # DON'T do it this way either\nFalse\n```\n\nPlease do your part to uphold and/or downhold our community standards."}]}
{"messages": [{"role": "user", "content": "Josephus problem is a math puzzle with a grim description: \n\nn\n{\\displaystyle {\\displaystyle n}}\n prisoners are standing on a circle, sequentially numbered from \n\n0\n{\\displaystyle {\\displaystyle 0}}\n to \n\nn\n−\n1\n{\\displaystyle {\\displaystyle n-1}}\n.\n\nAn executioner walks along the circle, starting from prisoner \n\n0\n{\\displaystyle {\\displaystyle 0}}\n,\nremoving every \n\nk\n{\\displaystyle {\\displaystyle k}}\n-th prisoner and killing him.\n\nAs the process goes on, the circle becomes smaller and smaller, until only one prisoner remains, who is then freed. >\n\nFor example, if there are \n\nn\n=\n5\n{\\displaystyle {\\displaystyle n=5}}\n prisoners and \n\nk\n=\n2\n{\\displaystyle {\\displaystyle k=2}}\n, the order the prisoners are killed in (let's call it the \"killing sequence\") will be 1, 3, 0, and 4, and the survivor will be #2.\n\nTask\n\nGiven any   \n\nn\n,\nk\n>\n0\n{\\displaystyle {\\displaystyle n,k>0}}\n,   find out which prisoner will be the final survivor.\n\nIn one such incident, there were 41 prisoners and every 3rd prisoner was being killed   (\n\nk\n=\n3\n{\\displaystyle {\\displaystyle k=3}}\n).\n\nAmong them was a clever chap name Josephus who worked out the problem, stood at the surviving position, and lived on to tell the tale.\n\nWhich number was he?\n\nExtra\n\nThe captors may be especially kind and let \n\nm\n{\\displaystyle {\\displaystyle m}}\n survivors free,\n  \nand Josephus might just have   \n\nm\n−\n1\n{\\displaystyle {\\displaystyle m-1}}\n   friends to save.\n\nProvide a way to calculate which prisoner is at any given position on the killing sequence.\n\nNotes\n\n1. You can always play the executioner and follow the procedure exactly as described, walking around the circle, counting (and cutting off) heads along the way. This would yield the complete killing sequence and answer the above questions, with a complexity of probably \n\n   O\n   (\n   k\n   n\n   )\n   {\\displaystyle {\\displaystyle O(kn)}}\n   . However, individually it takes no more than \n\n   O\n   (\n   m\n   )\n   {\\displaystyle {\\displaystyle O(m)}}\n    to find out which prisoner is the \n\n   m\n   {\\displaystyle {\\displaystyle m}}\n   -th to die.\n2. If it's more convenient, you can number prisoners from   \n\n   1\n   {\\displaystyle {\\displaystyle 1}}\n    to \n\n   n\n   {\\displaystyle {\\displaystyle n}}\n      instead.   If you choose to do so, please state it clearly.\n3. An alternative description has the people committing assisted suicide instead of being executed, and the last person simply walks away. These details are not relevant, at least not mathematically."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-11-12\n\nStraightforward implementation of the executioner's algorithm:\n\n```\nsub Execute(@prisoner, $k) {\n    until @prisoner == 1 {\n\t@prisoner.=rotate($k - 1);\n\t@prisoner.shift;\n    }\n}\n \nmy @prisoner = ^41;\nExecute @prisoner, 3;\nsay \"Prisoner {@prisoner} survived.\";\n\n# We don't have to use numbers.  Any list will do:\n\nmy @dalton = <Joe Jack William Averell Rantanplan>;\nExecute @dalton, 2;\nsay \"{@dalton} survived.\";\n\n```\n\nOutput:\n\n```\nPrisoner 30 survived.\nWilliam survived.\n```"}]}
{"messages": [{"role": "user", "content": "The task is to determine the joystick position and represent this on the display via a crosshair.\nFor a centred joystick, the crosshair should appear in the centre of the screen.\nIf the joystick is pushed left or right, then the cross hair should move left or right according to the extent that the joystick is pushed.\n\nIf the joystick is pushed forward or pulled back, then the crosshair should move up or down according to the extent that that joystick is pushed or pulled.\nThe edges of the display represent maximum extents for joystick movement.\n\nFor example, a joystick pushed fully forward would raise the crosshair to the top centre of the screen.\n\nA joystick pulled backwards and to the right would move the crosshair to the bottom right of the screen (except for a small area reserved to show joystick status). Implementations can use a graphical display method to produce the crosshair, or alternatively represent the crosshair using a plus symbol on\na terminal, and move the plus symbol position according to the joystick.\nThe bottom part of the display can hide or show an alphanumeric sequence to represent the buttons pressed.\n\nFor example, if pushbuttons 1,4 and 10 are depressed, we could display \"1 4 A\".\n\nThe implemented code should continue to redraw the crosshair according to the joystick position and show the current pushbutton statuses until the task is terminated.\nDigital joysticks that produce no extent data, should have their position indicated as full extent movement of the crosshair.\n\nFor the purpose of this task, we assume that the joystick is calibrated and that the first joystick is being used.   \nThe task implementer could at their option provide a solution that includes a joystick selection facility, enabling the user to choose which joystick is to be used for this task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.011\n\nLinux only terminal based joystick testing utility. Reads events from the joystick asynchronously, allows a main processing loop if desired. This uses the main loop to check for and compensate for a resized terminal but not really anything else. Hit control-c to exit; needs one extra event from the the joystick to exit completely. Only shows the first 3 axes, no matter how many are available. Tested with an Logitech extreme joystick and an Xbox controller.\n\n```\nuse experimental :pack;\n\n# Joysticks generally show up in the /dev/input/ directory as js(n) where n is\n# the number assigned by the OS. E.G. /dev/input/js1 . In my particular case:\n\nmy $device = '/dev/input/js0';\n\nmy $exit = 0;\n\nmy $event-stream = $device.IO.open(:bin);\nmy $js = $event-stream.Supply(:8size);\n\nmy %config; # joystick configuration: number of axes and buttons\nmy %event;  # global \"joystick event\"\n\n%config<button>.push: 0;\n\nmy $callback = sub { update };\n\nsub get-js-event ( $ev, &callback ) {\n    exit if $exit;\n    # 32 bit timestamp milliseconds. Allows easy checking for \"double-click\" button presses\n    %event<timestamp> = $ev.subbuf(0, 4).reverse.unpack('N');\n\n    # 16 bit (signed int16) value of current control\n    %event<value> = (my $v = $ev.subbuf(4, 2).unpack('S')) > 32767 ?? -65536 + $v !! $v;\n\n    # Two 8 bit integers, current event: control type, and control ID\n    (%event<type>, %event<number>) = $ev.subbuf(6).unpack('CC');\n\n    # Process the event\n    if %event<type> +& 128 {       # initialing\n        given %event<type> +& 3  { # enumeration of control inputs\n            when 1 { %config<button>.push: %event<number> }\n            when 2 { %config<axis>.push: %event<number> }\n        }\n    } else {\n        # Optional callback subroutine to run every time a js event is received\n        callback\n    }\n}\n\n# read events from the joystick driver asynchronously\nstart react whenever $js { $js.act: { get-js-event($_, $callback) } }\n\n# allow a short delay while driver initializes\nsleep .5;\n\n# clean up on exit\nsignal(SIGINT).tap: { \n    print \"\\e[0m\", \"\\n\" xx 50, \"\\e[H\\e[J\\e[?25hWaiting for one more joystick event...\\n\";\n    $exit = 1;\n    exit(0);\n}\n\nuse Terminal::ANSIColor;\n\nmy ($rows, $cols) = qx/stty size/.words; # get the terminal size\n\nmy $xhair = '╺╋╸';\nmy $axis  = '█';\nmy @btext = %config<button>.map: { sprintf( \"%2d\", $_) };\nmy @button = @btext.map: {color('bold white on_blue ') ~ $_ ~ color('reset')};\nmy ($x, $y, $z) = ($rows/2).floor, ($cols/2).floor, 0;\n\nsub update {\n    given %event<type> {\n        when 1 { # button event\n            given %event<value> {\n                when 0 { @button[%event<number>] = color('bold white on_blue ') ~ @btext[%event<number>] ~ color('reset') }\n                when 1 { @button[%event<number>] = color('bold white on_green') ~ @btext[%event<number>] ~ color('reset') }\n            }\n        }\n        when 2 { # axis events\n            given %event<number> {\n                when 0 { $y = ($cols / 2 + %event<value> / 32767 * $cols / 2).Int max 1 }\n                when 1 { $x = ($rows / 2 + %event<value> / 32767 * $rows / 2).Int max 2 }\n                when 2 { $z = (%event<value> / 32767 * 100).Int }\n                default { } # only using the first 3 axes, ignore ant others\n            }\n            $x min= $rows - 1;\n            $y min= $cols - 1;\n        }\n    }\n    print \"\\e[H\\e[J\\e[1;1H\";\n    print \"  \", join \"  \", flat @button, \"Axis 0: $x\", \"Axis 1: $y\" , \"Axis 2: $z%\\n\";\n    my $bar = ($z / 100 * $cols / 2).floor;\n    if $bar < 0 {\n        print ' ' x ($bar + $cols / 2).floor, color('bold green') ~ $axis x -$bar ~ color('reset');\n    } else {\n        print ' ' x $cols / 2, color('bold green') ~ $axis x $bar ~ color('reset');\n    }\n    print \"\\e[{$x};{$y}H\", color('bold yellow') ~ $xhair ~ color('reset');\n}\n\nprint \"\\e[?25l\"; # hide the cursor\nupdate; # initial update\n\n# Main loop, operates independently of the joystick event loop\nloop {\n    once say \" Joystick has {%config<axis>.elems} axes and {%config<button>.elems} buttons\";\n    sleep 1;\n    ($rows, $cols) = qx/stty size/.words;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Load a JSON string into a data structure.\nAlso, create a new data structure and serialize it into JSON.\n\nUse objects and arrays (as appropriate for your language)\nand make sure your JSON is valid (https://jsonformatter.org)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUsing JSON::Tiny\n\n```\nuse JSON::Tiny;\n\nsay from-json '{ \"foo\": 1, \"bar\": [10, \"apples\"] }';\nsay to-json   %( blue => [1,2], ocean => \"water\" );\n\n```\n\nOutput:\n\n```\n{bar => [10 apples], foo => 1}\n{ \"blue\" : [ 1, 2 ], \"ocean\" : \"water\" }\n```"}]}
{"messages": [{"role": "user", "content": "**JSON Pointer** is a syntax for targeting a value in a JSON (JavaScript Object Notation) document.\n\nStandardized in RFC 6901, a JSON Pointer is a Unicode string containing slash (`/`) separated tokens. Each token is either a potential property name for a JSON object, or a potential index for a JSON array. When a property name contains a slash (`/`) or a tilde (`~`), they are encoded as `~1` and `~0`, respectively.\n\nPseudocode\n\n*Evaluating* or *resolving* a JSON Pointer against an arbitrary JSON document might look like this.\n\n```\nset the current node to the document root\nFOR each token in the pointer\n  decode the token\n  IF the current node is an array\n    IF the token is a string representation of an array index AND the index is in range\n      set the current node to node[index]\n    ELSE\n      error condition\n    ENDIF\n  ELSE IF the current node is an object\n    IF the current node has a property matching token\n      set the current node to node[token]\n    ELSE\n      error condition\n    ENDIF\n  ELSE\n    error condition\n  ENDIF\nENDFOR\n\n```\n\nBarring any error conditions, the result is the value of the current node after the loop has completed. For example, evaluating the JSON Pointer `/foo/bar/1` against the JSON document `{\"foo\": {\"bar\": [\"hello\", \"world\"]}}`, would result in the value `\"world\"`.\n\nSee RFC 6901 for details.\n\nTask\n\nDemonstrate parsing and evaluation of JSON Pointers using, at least, the following examples. Display, on this page, either the resulting JSON value for each test case or a helpful error message.\n\nExample JSON document\n\n```\n{\n  \"wiki\": {\n    \"links\": [\n      \"https://rosettacode.org/wiki/Rosetta_Code\",\n      \"https://discord.com/channels/1011262808001880065\"\n    ]\n  },\n  \"\": \"Rosetta\",\n  \" \": \"Code\",\n  \"g/h\": \"chrestomathy\",\n  \"i~j\": \"site\",\n  \"abc\": [\"is\", \"a\"],\n  \"def\": { \"\": \"programming\" }\n}\n\n```\n\nExample JSON pointers\n\nJSON pointers are surrounded by quotes to emphasize whitespace and the empty pointer. The quotes are not part of the pointer.\n\n| JSON pointer | Expected result |\n| --- | --- |\n| `\"\"` | *The entire input document.* |\n| `\"/\"` | `\"Rosetta\"` |\n| `\"/ \"` | `\"Code\"` |\n| `\"/abc\"` | `[\"is\", \"a\"]` |\n| `\"/def/\"` | `\"programming\"` |\n| `\"/g~1h\"` | `\"chrestomathy\"` |\n| `\"/i~0j\"` | `\"site\"` |\n| `\"/wiki/links/0\"` | `\"https://rosettacode.org/wiki/Rosetta_Code\"` |\n| `\"/wiki/links/1\"` | `\"https://discord.com/channels/1011262808001880065\"` |\n| `\"/wiki/links/2\"` | *Error condition.* |\n| `\"/wiki/name\"` | *Error condition.* |\n| `\"/no/such/thing\"` | *Error condition.* |\n| `\"bad/pointer\"` | *Error condition.* |\n\nReference\n\n* RFC 6901 - JSON Pointer Internet Standards Track document\n\nRelated tasks\n\n* JSON"}, {"role": "assistant", "content": "```\n# 20240905 Raku programming solution\n\nuse JSON::Fast;\nuse JSON::Pointer;\n\nmy $json = from-json q:to/END/;\n{\n  \"wiki\": {\n    \"links\": [\n      \"https://rosettacode.org/wiki/Rosetta_Code\",\n      \"https://discord.com/channels/1011262808001880065\"\n    ]\n  },\n  \"\": \"Rosetta\",\n  \" \": \"Code\",\n  \"g/h\": \"chrestomathy\",\n  \"i~j\": \"site\",\n  \"abc\": [\"is\", \"a\"],\n  \"def\": { \"\": \"programming\" }\n}\nEND\n\nfor \"\",  \"/\",  \"/ \", \"/abc\",   \"/def\", \"/g~1h\", \"/i~0j\",\n    \"/wiki/links/0\", \"/wiki/links/1\" , \"/wiki/links/2\" ,\n    \"/wiki/name\"   , \"/no/such/thing\", \"bad/pointer\"     -> $input {\n   say \"{$input.fmt: '%13s'} => \", ( $input eq \"/\" and $json{\"\"}.defined )\n      ?? $json{\"\"} # :-P \n      !! JSON::Pointer.parse($input).resolve($json);\n   CATCH { default { say \"Error: $_\" } }\n}\n\n```\n\nOutput:\n\n```\n              => { => Rosetta,   => Code, abc => [is a], def => { => programming}, g/h => chrestomathy, i~j => site, wiki => {links => [https://rosettacode.org/wiki/Rosetta_Code https://discord.com/channels/1011262808001880065]}}\n            / => Rosetta\n           /  => Code\n         /abc => [is a]\n         /def => { => programming}\n        /g~1h => chrestomathy\n        /i~0j => site\n/wiki/links/0 => https://rosettacode.org/wiki/Rosetta_Code\n/wiki/links/1 => https://discord.com/channels/1011262808001880065\nError: Element does not exist at 2\nError: Element does not exist at name\nError: Element does not exist at no\nError: Invalid syntax at 0 when trying to resolve 「bad/pointer」\n\n```"}]}
{"messages": [{"role": "user", "content": "Background of the   **juggler sequence**:\n\nJuggler sequences were publicized by an American mathematician and author   Clifford A. Pickover.   The name of the sequence gets it's name from the similarity of the rising and falling nature of the numbers in the sequences,   much like balls in the hands of a juggler.\n\nDescription\n\nA juggler sequence is an integer sequence that starts with a positive integer a[0], with each subsequent term in the sequence being defined by the recurrence relation:\n\n```\n            a[k + 1]  =  floor(a[k] ^ 0.5)    if a[k] is even    or       \n            a[k + 1]  =  floor(a[k] ^ 1.5)    if a[k] is odd                                   \n\n```\n\nIf a juggler sequence reaches 1, then all subsequent terms are equal to 1. This is known to be the case for initial terms up to 1,000,000 but it is not known whether all juggler sequences after that will eventually reach 1.\n\nTask\n\nCompute and show here the following statistics for juggler sequences with an initial term of a[n] where n is between **20** and **39** inclusive:\n\n* l[n] - the number of terms needed to reach 1.\n* h[n] - the maximum value reached in that sequence.\n* i[n] - the index of the term (starting from 0) at which the maximum is (first) reached.\n\nIf your language supports *big integers* with an integer square root function, also compute and show here the same statistics for as many as you reasonably can of the following values for n:\n\n113, 173, 193, 2183, 11229, 15065, 15845, 30817, 48443, 275485, 1267909, 2264915, 5812827\n\nThose with fast languages and fast machines may also like to try their luck at n = 7110201.\n\nHowever, as h[n] for most of these numbers is thousands or millions of digits long, show instead of h[n]:\n\n* d[n] - the number of digits in h[n]\n\nThe results can be (partially) verified against the table here.\n\nRelated tasks\n\n* Hailstone sequence\n* Yellowstone sequence\n* Isqrt\\_(integer\\_square\\_root)\\_of\\_X\n\nSee also\n\n* oeis:A007320 Number of steps needed for Juggler sequence started at n to reach 1\n* oeis:A094716 Largest value in the Juggler sequence started at n"}, {"role": "assistant", "content": "Reaches 30817 fairly quickly but later values suck up enough memory that it starts thrashing the disk cache and performance drops off a cliff (on my system). Killed it after 10 minutes and capped list at 30817. Could rewrite to not try to hold entire sequence in memory at once, but probably not worth it. If you want sheer numeric calculation performance, Raku is probably not where it's at.\n\n```\nuse Lingua::EN::Numbers;\nsub juggler (Int $n where * > 0) { $n, { $_ +& 1 ?? .³.&isqrt !! .&isqrt } … 1 }\n\nsub isqrt ( \\x ) { my ( $X, $q, $r, $t ) =  x, 1, 0 ;\n    $q +<= 2 while $q ≤ $X ;\n    while $q > 1 {\n        $q +>= 2; $t = $X - $r - $q; $r +>= 1;\n        if $t ≥ 0 { $X = $t; $r += $q }\n    }\n    $r\n}\n\nsay \" n  l[n]  i[n]   h[n]\";\nfor 20..39 {\n    my @j = .&juggler;\n    my $max = @j.max;\n    printf \"%2s %4d  %4d    %s\\n\", .&comma, +@j-1, @j.first(* == $max, :k), comma $max;\n}\n\nsay \"\\n      n     l[n]   i[n]    d[n]\";\n( 113, 173, 193, 2183, 11229, 15065, 15845, 30817 ).hyper(:1batch).map: {\n    my $start = now;\n    my @j = .&juggler;\n    my $max = @j.max;\n    printf \"%10s %4d   %4d %10s   %6.2f seconds\\n\", .&comma, +@j-1, @j.first(* == $max, :k),\n      $max.chars.&comma, (now - $start);\n}\n\n```\n\nOutput:\n\n```\n n  l[n]  i[n]   h[n]\n20    3     0    20\n21    9     4    140\n22    3     0    22\n23    9     1    110\n24    3     0    24\n25   11     3    52,214\n26    6     3    36\n27    6     1    140\n28    6     3    36\n29    9     1    156\n30    6     3    36\n31    6     1    172\n32    6     3    36\n33    8     2    2,598\n34    6     3    36\n35    8     2    2,978\n36    3     0    36\n37   17     8    24,906,114,455,136\n38    3     0    38\n39   14     3    233,046\n\n      n     l[n]   i[n]    d[n]\n       113   16      9         27     0.01 seconds\n       173   32     17         82     0.01 seconds\n       193   73     47        271     0.09 seconds\n     2,183   72     32      5,929     1.05 seconds\n    11,229  101     54      8,201     1.98 seconds\n    15,065   66     25     11,723     2.05 seconds\n    15,845  139     43     23,889    10.75 seconds\n    30,817   93     39     45,391    19.60 seconds\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGenerate and draw a Julia set.\n\nRelated tasks\n\n* Mandelbrot Set"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\nwith the pallette swapped, just because.\n\n**Works with**: Rakudo version 2016.03\n\n```\nuse Image::PNG::Portable;\n\nmy ($w, $h) = 800, 600;\nmy $out = Image::PNG::Portable.new: :width($w), :height($h);\n\nmy $maxIter = 255;\nmy $c = -0.7 + 0.27015i;\n\njulia($out);\n\n$out.write: 'Julia-set-perl6.png';\n\nsub julia ( $png ) {\n    ^$w .race.map: -> $x {\n        for ^$h -> $y {\n            my $z = Complex.new(($x - $w / 2) / $w * 3, ($y - $h / 2) / $h * 2);\n            my $i = $maxIter;\n            while (abs($z) < 2 and --$i) {\n                $z = $z*$z + $c;\n            }\n            $png.set: $x, $y, |hsv2rgb($i / $maxIter, 1, ?$i).reverse;\n        }\n    }\n}\n\nsub hsv2rgb ( $h, $s, $v ){\n    my $c = $v * $s;\n    my $x = $c * (1 - abs( (($h*6) % 2) - 1 ) );\n    my $m = $v - $c;\n    [(do given $h {\n        when   0..^1/6 { $c, $x, 0 }\n        when 1/6..^1/3 { $x, $c, 0 }\n        when 1/3..^1/2 { 0, $c, $x }\n        when 1/2..^2/3 { 0, $x, $c }\n        when 2/3..^5/6 { $x, 0, $c }\n        when 5/6..1    { $c, 0, $x }\n    } ).map: ((*+$m) * 255).Int]\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Imperative programs like to jump around, but some languages restrict these jumps. Many structured languages restrict their conditional structures and loops to *local jumps* within a function. Some assembly languages limit certain jumps or branches to a small range.\n\nThis task is to demonstrate a local jump and a global jump and the various other types of jumps that the language supports.\nFor the purpose of this task, the jumps need not be used for a single purpose and you have the freedom to use these jumps for different purposes.\nYou may also defer to more specific tasks, like Exceptions or Generator.\nThis task provides a \"grab bag\" for several types of jumps. There are *non-local jumps* across function calls, or *long jumps* to anywhere within a program. Anywhere means not only to the tops of functions!\n\n* Some languages can *go to* any global label in a program.\n* Some languages can break multiple function calls, also known as *unwinding the call stack*.\n* Some languages can save a *continuation*. The program can later continue from the same place. So you can jump anywhere, but only if you have a previous visit there (to save the continuation).\n\nThese jumps are not all alike.\nA simple *goto* never touches the call stack.\nA continuation saves the call stack, so you can continue a function call after it ends.\n\nTask\n\nUse your language to demonstrate the various types of jumps that it supports.\n\nBecause the possibilities vary by language, this task is not specific.\nYou have the freedom to use these jumps for different purposes.\nYou may also defer to more specific tasks, like Exceptions or Generator."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Label-based jumps\n\n```\n    outer-loop: loop {\n        inner-loop: loop {\n            # NYI # goto inner-loop if rand > 0.5; # Hard goto\n            next inner-loop if rand > 0.5; # Next loop iteration\n            redo inner-loop if rand > 0.5; # Re-execute block\n            last outer-loop if rand > 0.5; # Exit the loop\n            ENTER { say \"Entered inner loop block\" }\n            LEAVE { say \"Leaving inner loop block\" }\n        }\n        ENTER { say \"Entered outer loop block\" }\n        LEAVE { say \"Leaving outer loop block\" }\n        LAST  { say \"Ending outer loop\" }\n    }\n\n```\n\nProduces random output, but here's a representative run:\n\n```\n Entered outer loop block\n Entered inner loop block\n Leaving inner loop block\n Entered inner loop block\n Leaving inner loop block\n Entered inner loop block\n Leaving inner loop block\n Leaving outer loop block\n Ending outer loop\n\n```\n\n### Continuation-based execution\n\nContinuations in Raku are currently limited to use in generators via the gather/take model:\n\n```\n    my @list = lazy gather for ^100 -> $i {\n        if $i.is-prime {\n            say \"Taking prime $i\";\n            take $i;\n        }\n    }\n    \n    say @list[5];\n\n```\n\nThis outputs:\n\n```\n Taking prime 2\n Taking prime 3\n Taking prime 5\n Taking prime 7\n Taking prime 11\n Taking prime 13\n 13\n\n```\n\nNotice that no further execution of the loop occurs. If we then asked for the element at index 20, we would expect to see 15 more lines of \"Taking prime...\" followed by the result: 73.\n\n### Failures and exceptions\n\nExceptions are fairly typical in Raku:\n\n```\n    die \"This is a generic, untyped exception\";\n\n```\n\nWill walk up the stack until either some `CATCH` block intercepts the specific exception type or we exit the program.\n\nBut if a failure should be recoverable (e.g. execution might reasonably continue along another path) a failure is often the right choice. The fail operator is like \"return\", but the returned value will only be valid in boolean context or for testing definedness. Any other operation will produce the original exception with the original exception's execution context (e.g. traceback) along with the current context.\n\n```\n    sub foo() { fail \"oops\" }\n    my $failure = foo;\n    say \"Called foo\";\n    say \"foo not true\" unless $failure;\n    say \"foo not defined\" unless $failure.defined;\n    say \"incremented foo\" if $failure++; # exception\n\n```\n\nProduces:\n\n```\n Called foo\n foo not true\n foo not defined\n oops\n   in sub foo at fail.p6 line 1\n   in block <unit> at fail.p6 line 2\n Actually thrown at:\n   in any  at gen/moar/m-Metamodel.nqp line 3090\n   in block <unit> at fail.p6 line 6\n\n```\n\nHowever, an exception can `.resume` in order to jump back to the failure point (this is why the stack is not unwound until after exception handling).\n\n```\n  sub foo($i) {\n      if $i == 0 {\n          die \"Are you sure you want /0?\";\n      }\n      say \"Dividing by $i\";\n      1/$i.Num + 0; # Fighting hard to make this fail\n  }\n  \n  for ^10 -> $n {\n      say \"1/$n  = \" ~ foo($n);\n  }\n  \n  CATCH {\n      when ~$_ ~~ m:s/Are you sure/ { .resume; #`(yes, I'm sure) }\n  }\n\n```\n\nThis code raises an exception on a zero input, but then resumes execution, divides be zero and then raises a divide by zero exception which is not caught:\n\n```\n Dividing by 0\n Attempt to divide 1 by zero using /\n   in sub foo at fail.p6 line 6\n   in block <unit> at fail.p6 line 10\n \n Actually thrown at:\n   in sub foo at fail.p6 line 6\n   in block <unit> at fail.p6 line 10\n\n```"}]}
{"messages": [{"role": "user", "content": "Given a stream of characters containing the separator characters \"formfeed\", \"linefeed\", \"tab\" and \"space\", print out the ith character of the ith tab-field of the ith line of the ith page to reveal a secret password.\n\nStop processing immediately upon encountering a \"!\" found uniquely in this *i,i,i,i* position (lest the system self-destruct). The \"!\" may be found elsewhere however, in which case it should be ignored.\n\nIdeally this can be generalised as follows:\n\n* The separator characters are defined by a user-supplied array that can include additional or alternative separators, e.g. (formfeed, linefeed, \".\", \",\" ,\" \",...).\n* The selection criterion is generalised ith,ith,ith,ith to a boolean function of *f(page,line,field,word,...) **or** f(ith,jth,kth,lth,mth,etc...)*\n\nProvide a reasonably interesting message to be decoded, e.g. \"Silence-Dogood\". Your choice.\n\nThis task was inspired by the movie \"National Treasure\", which refers to a \"book cipher\"."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\nThis is a something of a toy encoder / decoder and probably shouldn't be used for anything serious.\n\nDefault encode/decode key is 'Raku' Feed it a pass phrase at the command line to use that instead.\n\nWill handle any visible character in the ASCII range as well as space and new-line.\n\n```\n#`[\nSet srand to set the encode / decode \"key\".\nNeed to use the same \"key\" and same implementation\nof Raku to encode / decode. Gain \"security\" by\nexchanging \"keys\" by a second channel. Default\n\"key\" is \"Raku\"\n]\n\nunit sub MAIN ($key = 'Raku');\n\nsrand $key.comb(/<.alnum>/).join.parse-base(36) % 2**63;\n\nmy @stream = (flat \"\\n\", ' ' .. '~').roll(*);\n\nsub jit-encode (Str $str) {\n    my $i = 0;\n    my $last = 0;\n    my $enc = '';\n    for $str.comb -> $c {\n        my $h;\n        my $l = '';\n        ++$i until $i > 1 && $c eq @stream[$i];\n        my $o = $i - $last;\n        $l    = $o % 26;\n        $h    = $o - $l if $o >= 26;\n        $l   += 10;\n        $enc ~= ($h ?? $h.base(36).uc !! '') ~ ($l.base(36).lc);\n        $last = $i;\n    }\n    my $block = 60;\n    $enc.comb($block).join: \"\\n\"\n}\n\nsub jit-decode (Str $str is copy) {\n    $str.=subst(\"\\n\", '', :g);\n    $str ~~ m:g/((.*?) (<:Ll>))/;\n    my $dec = '';\n    my $i = 0;\n    for $/.List -> $l {\n        my $o = ($l[0][1].Str.parse-base(36) - 10 // 0) +\n                ($l[0][0].Str.parse-base(36) // 0);\n        $i += $o;\n        $dec ~= @stream[$i];\n    }\n    $dec\n}\n\nmy $secret = q:to/END/;\nIn my opinion, this task is pretty silly.\n\n'Twas brillig, and the slithy toves\n    Did gyre and gimble in the wabe.\n\n!@#$%^&*()_+}{[].,><\\|/?'\";:1234567890\nEND\n\nsay \"== Secret: ==\\n$secret\";\n\nsay \"\\n== Encoded: ==\";\nsay my $enc = jit-encode($secret);\n\nsay \"\\n== Decoded: ==\";\nsay jit-decode($enc);\n\n```\n\n```\n== Secret: ==\nIn my opinion, this task is pretty silly.\n\n'Twas brillig, and the slithy toves\n    Did gyre and gimble in the wabe.\n\n!@#$%^&*()_+}{[].,><\\|/?'\";:1234567890\n\n\n== Encoded: ==\nQv26e26q1Gi2Ww5SiQr26h3Mk1GbQy52e1Gg6Ib52kQfQk26n26l26cQm26q\n2Wk26vwme52qy6Ia1GuQfa3MbQxtd26aa3MvQu2Wuat26p2Wbe2Wc1Ga26g2\n6h26pQha26h4Cf26jrz7Yz3MaA4h2WxFWf52zyg2WrQn2Wj26pQyQy78x1Gd\ndk4Cu26k26qaaap26j26xqQf7Yr8Op3Me3Me5Sv1Ge1Gt2WxlQz5Si1GeQg4\nCjQc5Sb2WbQo1GycQr1Gm1Gy1GsQei3MrQsai1Gq2WnQdt2Wj1Gff1Gg26le\n2Wd1Go9Ek1Gm9Eh2Wb1Gd52h2WdQae4Chu3MeQd1Gg1Gw4CqbEGh52u2Wr1G\nt52xhvQmx\n\n== Decoded: ==\nIn my opinion, this task is pretty silly.\n\n'Twas brillig, and the slithy toves\n    Did gyre and gimble in the wabe.\n\n!@#$%^&*()_+}{[].,><\\|/?'\";:1234567890\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at K-d tree. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nA k-d tree (short for *k*-dimensional tree) is a space-partitioning data structure for organizing points in a k-dimensional space. k-d trees are a useful data structure for several applications, such as searches involving a multidimensional search key (e.g. range searches and nearest neighbor searches).\nk-d trees are a special case of binary space partitioning trees.\n\nk-d trees are not suitable, however, for efficiently finding the nearest neighbor in high dimensional spaces. As a general rule, if the dimensionality is *k*, the number of points in the data, *N*, should be *N* ≫ 2*k*.\nOtherwise, when k-d trees are used with high-dimensional data, most of the points in the tree will be evaluated and the efficiency is no better than exhaustive search, and other methods such as approximate nearest-neighbor are used instead.\n\n**Task:** Construct a k-d tree and perform a nearest neighbor search for two example data sets:\n\n1. The Wikipedia example data of [(2,3), (5,4), (9,6), (4,7), (8,1), (7,2)].\n2. 1000 3-d points uniformly distributed in a 3-d cube.\n\nFor the Wikipedia example, find the nearest neighbor to point (9, 2)\nFor the random data, pick a random location and find the nearest neighbor.\n\nIn addition, instrument your code to count the number of nodes visited in the nearest neighbor search. Count a node as visited if any field of it is accessed.\n\nOutput should show the point searched for, the point found,\nthe distance to the point, and the number of nodes visited.\n\nThere are variant algorithms for constructing the tree.\nYou can use a simple median strategy or implement something more efficient.\nVariants of the nearest neighbor search include nearest N neighbors, approximate nearest neighbor, and range searches.\nYou do not have to implement these.\nThe requirement for this task is specifically the nearest single neighbor.\nAlso there are algorithms for inserting, deleting, and balancing k-d trees.\nThese are also not required for the task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n```\nclass Kd_node {\n    has $.d;\n    has $.split;\n    has $.left;\n    has $.right;\n}\n\nclass Orthotope {\n    has $.min;\n    has $.max;\n}\n\nclass Kd_tree {\n    has $.n;\n    has $.bounds;\n    method new($pts, $bounds) { self.bless(n => nk2(0,$pts), bounds => $bounds) }\n\n    sub nk2($split, @e) {\n        return () unless @e;\n        my @exset = @e.sort(*.[$split]);\n        my $m = +@exset div 2;\n        my @d = @exset[$m][];\n        while $m+1 < @exset and @exset[$m+1][$split] eqv @d[$split] {\n            ++$m;\n        }\n\n        my $s2 = ($split + 1) % @d; # cycle coordinates\n        Kd_node.new: :@d, :$split,\n                left  => nk2($s2, @exset[0 ..^ $m]),\n                right => nk2($s2, @exset[$m ^.. *]);\n    }\n}\n\nclass T3 {\n    has $.nearest;\n    has $.dist_sqd = Inf;\n    has $.nodes_visited = 0;\n}\n\nsub find_nearest($k, $t, @p) {\n    return nn($t.n, @p, $t.bounds, Inf);\n\n    sub nn($kd, @target, $hr, $max_dist_sqd is copy) {\n        return T3.new(:nearest([0.0 xx $k])) unless $kd;\n\n        my $nodes_visited = 1;\n        my $s = $kd.split;\n        my $pivot = $kd.d;\n        my $left_hr = $hr.clone;\n        my $right_hr = $hr.clone;\n        $left_hr.max[$s] = $pivot[$s];\n        $right_hr.min[$s] = $pivot[$s];\n\n        my $nearer_kd;\n        my $further_kd;\n        my $nearer_hr;\n        my $further_hr;\n        if @target[$s] <= $pivot[$s] {\n            ($nearer_kd, $nearer_hr) = $kd.left, $left_hr;\n            ($further_kd, $further_hr) = $kd.right, $right_hr;\n        }\n        else {\n            ($nearer_kd, $nearer_hr) = $kd.right, $right_hr;\n            ($further_kd, $further_hr) = $kd.left, $left_hr;\n        }\n \n        my $n1 = nn($nearer_kd, @target, $nearer_hr, $max_dist_sqd);\n        my $nearest = $n1.nearest;\n        my $dist_sqd = $n1.dist_sqd;\n        $nodes_visited += $n1.nodes_visited;\n\n        if $dist_sqd < $max_dist_sqd {\n            $max_dist_sqd = $dist_sqd;\n        }\n        my $d = ($pivot[$s] - @target[$s]) ** 2;\n        if $d > $max_dist_sqd {\n            return T3.new(:$nearest, :$dist_sqd, :$nodes_visited);\n        }\n        $d = [+] (@$pivot Z- @target) X** 2;\n        if $d < $dist_sqd {\n            $nearest = $pivot;\n            $dist_sqd = $d;\n            $max_dist_sqd = $dist_sqd;\n        }\n\n        my $n2 = nn($further_kd, @target, $further_hr, $max_dist_sqd);\n        $nodes_visited += $n2.nodes_visited;\n        if $n2.dist_sqd < $dist_sqd {\n            $nearest = $n2.nearest;\n            $dist_sqd = $n2.dist_sqd;\n        }\n\n        T3.new(:$nearest, :$dist_sqd, :$nodes_visited);\n    }\n}\n\nsub show_nearest($k, $heading, $kd, @p) {\n    print qq:to/END/;\n        $heading:\n        Point:            [@p.join(',')]\n        END\n    my $n = find_nearest($k, $kd, @p);\n    print qq:to/END/;\n        Nearest neighbor: [$n.nearest.join(',')]\n        Distance:         &sqrt($n.dist_sqd)\n        Nodes visited:    $n.nodes_visited()\n        \n        END\n}\n\nsub random_point($k) { [rand xx $k] }\nsub random_points($k, $n) { [random_point($k) xx $n] }\n\nsub MAIN {\n    my $kd1 = Kd_tree.new([[2, 3],[5, 4],[9, 6],[4, 7],[8, 1],[7, 2]],\n                  Orthotope.new(:min([0, 0]), :max([10, 10])));\n    show_nearest(2, \"Wikipedia example data\", $kd1, [9, 2]);\n\n    my $N = 1000;\n    my $t0 = now;\n    my $kd2 = Kd_tree.new(random_points(3, $N), Orthotope.new(:min([0,0,0]), :max([1,1,1])));\n    my $t1 = now;\n    show_nearest(2,\n        \"k-d tree with $N random 3D points (generation time: {$t1 - $t0}s)\",\n         $kd2, random_point(3));\n}\n\n```\n\nOutput:\n\n```\nWikipedia example data:\nPoint:            [9,2]\nNearest neighbor: [8,1]\nDistance:         1.4142135623731\nNodes visited:    3\n\nk-d tree with 1000 random 3D points (generation time: 67.0934954s):\nPoint:            [0.765565651400664,0.223251226280109,0.00536717765240979]\nNearest neighbor: [0.758919336088656,0.228895111242011,0.0383284709862686]\nDistance:         0.0340950700678338\nNodes visited:    23\n```"}]}
{"messages": [{"role": "user", "content": "K-means++ clustering a classification of data, so that points assigned to the same cluster are similar (in some sense). It is identical to the K-means algorithm, except for the selection of initial conditions.\n\nThis data was partitioned into 7 clusters using the K-means algorithm.\n\nThe task is to ***implement the K-means++ algorithm***. Produce a function which takes two arguments: the number of clusters K, and the dataset to classify. K is a positive integer and the dataset is a list of points in the Cartesian plane. The output is a list of clusters (related sets of points, according to the algorithm).\n\nFor ***extra credit*** (in order):\n\n1. Provide a function to exercise your code, which generates a list of random points.\n2. Provide a visualization of your results, including centroids (see example image).\n3. Generalize the function to polar coordinates (in radians).\n4. Generalize the function to points in an arbitrary N space (i.e. instead of x,y pairs, points are an N-tuples representing coordinates in ℝN).   \n   *If this is different or more difficult than the [naive] solution for ℝ2, discuss what had to change to support N dimensions.*\n\nExtra credit is only awarded if the examples given demonstrate the feature in question. To earn credit for 1. and 2., visualize 6 clusters of 30,000 points in ℝ2. It is not necessary to provide visualization for spaces higher than ℝ2 but the examples should demonstrate features 3. and 4. if the solution has them."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-16\n\nWe use Complex numbers to represent points in the plane. We feed the algorithm with three artificially made clouds of points so we can easily see if the output makes sense.\n\n```\nsub postfix:«-means++»(Int $K) {\n    return sub (@data) {\n        my @means = @data.pick;\n        until @means == $K {\n            my @cumulD2 = [\\+] @data.map: -> $x {\n                min @means.map: { abs($x - $_)**2 }\n            }\n            my $rand = rand * @cumulD2[*-1];\n            @means.push: @data[\n                (^@data).first: { @cumulD2[$_] > $rand }\n            ];\n        }\n        sub cluster { @data.classify: -> $x { @means.min: { abs($_ - $x) } } }\n        loop (\n            my %cluster;\n            $*TOLERANCE < [+] (@means Z- keys (%cluster = cluster))».abs X** 2;\n            @means = %cluster.values.map( { .elems R/ [+] @$_ } )\n        ) { ; }\n        return @means;\n    }\n}\n \nmy @centers = 0, 5, 3 + 2i;\nmy @data = flat @centers.map: { ($_ + .5 - rand + (.5 - rand) * i) xx 100 }\n@data.=pick(*);\n.say for 3-means++(@data);\n\n```\n\nOutput:\n\n```\n5.04622376429502+0.0145269848483031i\n0.0185674577571743+0.0298199687431731i\n2.954898072093+2.14922298688815i\n```"}]}
{"messages": [{"role": "user", "content": ":   Note to language implementers\n:   This task touches on the details of number representation that is often hidden for convenience in many programming languages. You may need to understand the difference between precision in calculations and precision in presenting answers for example; or understand decimal arithmetic as distinct from the usual binary based floating point schemes used in many languages.\n\nThe Kahan summation algorithm is a method of summing a series of numbers represented in a limited precision in a way that minimises the loss of precision in the result.\n\n(The   **Kahan summation algorithm**   is also known as the   **summation with carry algorithm**.)\n\n**The task** is to follow the previously linked Wikipedia articles algorithm and its worked example by:\n\n1. Do all arithmetic in decimal to a precision of six digits.\n2. Write a function/method/procedure/subroutine/... to perform Kahan summation on an ordered collection of numbers, (such as a list of numbers).\n3. Create the three numbers `a, b, c` equal to `10000.0, 3.14159, 2.71828` respectively.\n4. Show that the simple left-to-right summation, equivalent to `(a + b) + c` gives an answer of 10005.8\n5. Show that the Kahan function applied to the sequence of values `a, b, c` results in the more precise answer of 10005.9\n\n**If your language does not have six digit decimal point**, but does have some fixed precision floating point number system then **state this** and try this alternative task using floating point numbers:\n\n* Follow the same steps as for the main task description above but for the numbers `a, b, c` use the floating-point values `1.0, epsilon, -epsilon` respectively where epsilon is determined by its final value after the following:\n\n```\nepsilon = 1.0\nwhile 1.0 + epsilon != 1.0:\n    epsilon = epsilon / 2.0\n\n```\n\nThe above should ensure that `(a + b) + c != 1.0` whilst their Kahan sum does equal 1.0 . *Only* if this is not the case are you then free to find three values with this property of your own.\n\n**If your language has decimals, but not six digits of precision** then you may follow the outline given in Kahan\\_summation#Python:\\_Arbitrary\\_precision\\_Decimal which uses ideas from the floating point case above.\n\nIn general\n\n* Show all output on this page.\n* If the floating point calculations are used then answers may depend on the hardware platform or compiler/interpreter tool-chain used for a language.\n* *Slight* deviations from the task description should be explained and the the subsequent difference in output explained.\n* All examples should have constants chosen to clearly show the benefit of Kahan summing!"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\nRaku does not offer a fixed precision decimal. It *does* have IEEE 754 floating point numbers so let's try implementing the floating point option as shown in Python. Need to explicitly specify scientific notation numbers to force floating point Nums.\n\n```\nconstant ε = (1e0, */2e0 … *+1e0==1e0)[*-1];\n\nsub kahan (*@nums) {\n    my $summ = my $c = 0e0;\n    for @nums -> $num {\n        my $y = $num - $c;\n        my $t = $summ + $y;\n        $c = ($t - $summ) - $y;\n        $summ = $t;\n    }\n    $summ\n}\n\nsay 'Epsilon:    ', ε;\n\nsay 'Simple sum: ', ((1e0 + ε) - ε).fmt: \"%.16f\";\n\nsay 'Kahan sum:  ', kahan(1e0, ε, -ε).fmt: \"%.16f\";\n\n```\n\nOutput:\n\n```\nEpsilon:    1.1102230246251565e-16\nSimple sum: 0.9999999999999999\nKahan sum:  1.0000000000000000\n\n```"}]}
{"messages": [{"role": "user", "content": "A positive integer is a Kaprekar number if:\n\n* It is   **1**     (unity)\n* The decimal representation of its square may be split once into two parts consisting of positive integers which sum to the original number.\n\nNote that a split resulting in a part consisting purely of 0s is not valid,\nas 0 is not considered positive.\n\nExample Kaprekar numbers\n\n* 2223\n  {\\displaystyle {\\displaystyle 2223}}\n   is a Kaprekar number, as \n\n  2223\n  ∗\n  2223\n  =\n  4941729\n  {\\displaystyle {\\displaystyle 2223\\*2223=4941729}}\n  , \n\n  4941729\n  {\\displaystyle {\\displaystyle 4941729}}\n   may be split to \n\n  494\n  {\\displaystyle {\\displaystyle 494}}\n   and \n\n  1729\n  {\\displaystyle {\\displaystyle 1729}}\n  , and \n\n  494\n  +\n  1729\n  =\n  2223\n  {\\displaystyle {\\displaystyle 494+1729=2223}}\n  .\n* The series of Kaprekar numbers is known as A006886, and begins as \n\n  1\n  ,\n  9\n  ,\n  45\n  ,\n  55\n  ,\n  .\n  .\n  .\n  {\\displaystyle {\\displaystyle 1,9,45,55,...}}\n  .\n\nExample process\n\n10000 (1002) splitting from left to right:\n\n* The first split is [1, 0000], and is invalid; the 0000 element consists entirely of 0s, and 0 is not considered positive.\n* Slight optimization opportunity: When splitting from left to right, once the right part consists entirely of 0s, no further testing is needed; all further splits would also be invalid.\n\nTask\n\nGenerate and show all Kaprekar numbers less than 10,000.\n\nExtra credit\n\nOptionally, count (and report the count of) how many Kaprekar numbers are less than 1,000,000.\n\nExtra extra credit\n\nThe concept of Kaprekar numbers is not limited to base 10 (i.e. decimal numbers);\nif you can, show that Kaprekar numbers exist in other bases too.\n\nFor this purpose, do the following:\n\n* Find all Kaprekar numbers for base 17 between 1 and 1,000,000 (one million);\n* Display each of them in base 10 representation;\n* Optionally, using base 17 representation (use letters 'a' to 'g' for digits 10(10) to 16(10)), display each of the numbers, its square, and where to split the square.\n\nFor example, 225(10) is \"d4\" in base 17, its square \"a52g\", and a5(17) + 2g(17) = d4(17), so the display would be something like:\n\n```\n225   d4  a52g  a5 + 2g\n```\n\nReference\n\n* The Kaprekar Numbers by Douglas E. Iannucci (2000). PDF version\n\nRelated task\n\n* Casting out nines"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### String version (slow)\n\n```\nsub kaprekar( Int $n ) {\n    my $sq = $n ** 2;\n    for 0 ^..^ $sq.chars -> $i {\n        my $x = +$sq.substr(0, $i);\n        my $y = +$sq.substr($i) || return;\n        return True if $x + $y == $n;\n    }\n    False;\n}\n\nprint 1;\nprint \" $_\" if .&kaprekar for ^10000;\nprint \"\\n\";\n\n```\n\nOutput:\n\n```\n1 9 45 55 99 297 703 999 2223 2728 4879 4950 5050 5292 7272 7777 9999\n```\n\n### Numeric version (medium)\n\nThe addition of **race**, in two places, allows for concurrent computation, and brings a significant speed-up in running time.\n\n```\nsub kaprekar( Int $n, Int :$base = 10 ) {\n    my $hi = $n ** 2;\n    my $lo = 0;\n    loop (my $s = 1; $hi; $s *= $base) {\n        $lo += ($hi % $base) * $s;\n        $hi div= $base;\n        return $hi,$lo if $lo + $hi == $n and $lo;\n    }\n    ();\n}\n\nprint \" $_\" if .&kaprekar for ^10_000;\n\nmy atomicint $n;\n(^1_000_000).race.map: { $n++ if kaprekar $_ }\nsay \"\\n\\nBase 10 Kaprekar numbers < :10<1_000_000> = $n\";\n\nsay \"\\nBase 17 Kaprekar numbers < :17<1_000_000>\";\n\nmy &k17 = &kaprekar.assuming(:base(17));\n\nmy @results;\n(^:17<1_000_000>).race.map: -> $n {\n    my ($h,$l) = k17 $n;\n    next unless $l;\n    my $n17 = $n.base(17);\n    my $s17 = ($n * $n).base(17);\n    my $h17 = $h.base(17);\n    @results.push: \"$n $n17 $s17 ($h17 + $s17.substr(* - max(1,($s17.chars - $h17.chars))))\";\n}\n\n.say for @results.sort: *.chars;\n\n```\n\nOutput:\n\n```\n1 9 45 55 99 297 703 999 2223 2728 4879 4950 5050 5292 7272 7777 9999\n\nBase 10 Kaprekar numbers < :10<1_000_000> = 54\n\nBase 17 Kaprekar numbers < :17<1_000_000>\n1 1 1 (0 + 1)\n16 G F1 (F + 1)\n64 3D E2G (E + 2G)\n225 D4 A52G (A5 + 2G)\n288 GG GF01 (GF + 01)\n1536 556 1B43B2 (1B4 + 3B2)\n3377 BBB 8093B2 (809 + 3B2)\n4912 GGG GGF001 (GGF + 001)\n7425 18BD 24E166G (24E + 166G)\n9280 1F1F 39B1B94 (39B + 1B94)\n16705 36DB B992C42 (B99 + 2C42)\n20736 43CD 10DE32FG (10DE + 32FG)\n30016 61EB 23593F92 (2359 + 3F92)\n36801 785D 351E433G (351E + 433G)\n37440 7A96 37144382 (3714 + 4382)\n46081 967B 52G94382 (52G9 + 4382)\n46720 98B4 5575433G (5575 + 433G)\n53505 AF26 6GA43F92 (6GA4 + 3F92)\n62785 CD44 9A5532FG (9A55 + 32FG)\n66816 DA36 AEG42C42 (AEG4 + 2C42)\n74241 F1F2 D75F1B94 (D75F + 1B94)\n76096 F854 E1F5166G (E1F5 + 166G)\n83520 GGGG GGGF0001 (GGGF + 0001)\n266224 33334 A2C52A07G (A2C5 + 2A07G)\n1153633 DDDDD B3D5E2A07G (B3D5E + 2A07G)\n1334529 FGACC F0540F1A78 (F054 + 0F1A78)\n1419856 GGGGG GGGGF00001 (GGGGF + 00001)\n1787968 146FCA 19G4C12DG7F (19G4C + 12DG7F)\n3122497 236985 4E3BE1F95D8 (4E3BE + 1F95D8)\n3773952 2B32B3 711CB2420F9 (711CB + 2420F9)\n4243968 2GDE03 8FEGB27EG09 (8FEGB + 27EG09)\n5108481 3A2D6F CG10B2E3C64 (CG10B + 2E3C64)\n5561920 3FA16D F5EAE3043CG (F5EAE + 3043CG)\n6031936 443CCD 110DDE332FFG (110DDE + 332FFG)\n6896449 4E9C28 16A10C37GB1D (16A10C + 37GB1D)\n7435233 54067B 1A72G93AA382 (1A72G9 + 3AA382)\n8017920 5AGGB6 1EF1D43D1EF2 (1EF1D4 + 3D1EF2)\n9223201 687534 2835C5403G7G (2835C5 + 403G7G)\n9805888 6F6F6G 2DBE3F41C131 (2DBE3F + 41C131)\n11140416 7E692A 3A997C43DGBF (3A997C + 43DGBF)\n11209185 7F391E 3B58D543F059 (3B58D5 + 43F059)\n12928384 91D7F3 4EF79B43F059 (4EF79B + 43F059)\n12997153 92A7E7 4FD82943DGBF (4FD829 + 43DGBF)\n14331681 A1A1A1 5GF07041C131 (5GF070 + 41C131)\n14914368 A89BDD 685C5E403G7G (685C5E + 403G7G)\n16119649 B6005B 79F2793D1EF2 (79F279 + 3D1EF2)\n16702336 BCGA96 8267143AA382 (826714 + 3AA382)\n17241120 C274E9 8B7ACD37GB1D (8B7ACD + 37GB1D)\n18105633 CCD444 99A555332FFG (99A555 + 332FFG)\n18575649 D16FA4 A12BE53043CG (A12BE5 + 3043CG)\n19029088 D6E3A2 A9A83F2E3C64 (A9A83F + 2E3C64)\n19893601 E032GE B953G527EG09 (B953G5 + 27EG09)\n20363617 E5DE5E C1BD752420F9 (C1BD75 + 2420F9)\n21015072 EDA78C CF11C41F95D8 (CF11C4 + 1F95D8)\n22349601 FCA147 E9D1D912DG7F (E9D1D9 + 12DG7F)\n22803040 G10645 F2FCDE0F1A78 (F2FCDE + 0F1A78)\n24137568 GGGGGG GGGGGF000001 (GGGGGF + 000001)\n```\n\nNote that this algorithm allows the null string on the left, taken as zero, which automatically includes 1 as the first element of the sequence.\n\n### Casting out nines (fast)\n\n```\nsub kaprekar-generator( :$base = 10 ) {\n    my $base-m1 = $base - 1;\n    gather loop (my $place = 1; ; ++$place) {\n        my $nend = $base ** $place;\n        loop (my $n = $base ** ($place - 1); $n < $nend; ++$n) {\n            if $n * ($n - 1) %% $base-m1 {\n                my $pend = $place * 2;\n                loop (my $p = $place; $p < $pend; ++$p) {\n                    my $B = $base ** $p;\n                    my $lo = $n * ($B - $n) div ($B - 1);\n                    my $hi = floor $n - $lo;\n                    if $n * $n == $hi * $B + $lo and $lo {\n                        take [$n, $hi, $lo];\n                        last;\n                    }\n                }\n            }\n        }\n    }\n}\n\nprint \" $_[0]\" for kaprekar-generator() ...^ *.[0] >= 10_000;\nsay \"\\n\";\n\nsay \"Base 10 Kaprekar numbers < :10<1_000_000> = \", +(kaprekar-generator() ...^ *.[0] >= 1000000);\nsay '';\n\nsay \"Base 17 Kaprekar numbers < :17<1_000_000>\";\n\nmy &k17-gen = &kaprekar-generator.assuming(:base(17));\n\nfor k17-gen() ...^ *.[0] >= :17<1000000> -> @r {\n    my ($n,$h,$l) = @r;\n    my $n17 = $n.base(17);\n    my $s = $n * $n;\n    my $s17 = $s.base(17);\n    my $h17 = $h.base(17);\n    my $l17 = $l.base(17);\n    $l17 = '0' x ($s17.chars - $h17.chars - $l17.chars) ~ $l17;\n    say \"$n $n17 $s17 ($h17 + $l17)\";\n}\n\n```\n\n(Same output.)"}]}
{"messages": [{"role": "user", "content": "Brian Kernighan, in a lecture at the University of Nottingham, described a problem on which this task is based.\n\nProblem\n\nYou are given a a data file of thousands of lines; each of three `whitespace` separated fields: a date, a one word name and the magnitude of the event.\n\nExample lines from the file would be lines like:\n\n```\n8/27/1883    Krakatoa            8.8\n5/18/1980    MountStHelens       7.6\n3/13/2009    CostaRica           5.1\n```\n\nTask\n\n* Create a program or script invocation to find all the events with magnitude greater than 6\n* Assuming an appropriate name e.g. \"data.txt\" for the file:\n\n:   1. Either: Show how your program is invoked to process a data file of that name.\n    2. Or: Incorporate the file name into the program, (as it is assumed that the program is single use)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nPass in a file name, or use default for demonstration purposes.\n\n```\n$_ = @*ARGS[0] ?? @*ARGS[0].IO !! q:to/END/;\n    8/27/1883    Krakatoa            8.8\n    5/18/1980    MountStHelens       7.6\n    3/13/2009    CostaRica           5.1\n    END\n\nmap { .say if .words[2] > 6 }, .lines;\n\n```"}]}
{"messages": [{"role": "user", "content": "Flush the   keyboard   buffer.\n\nThis reads characters from the keyboard input and\ndiscards them until there are no more currently buffered,  \nand then allows the program to continue.\n\n*The program must not wait for users to type anything.*"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nUsing termios to set some input attributes, flush the buffer & do unbuffered reads. Longer than strictly necessary to demonstrate concepts and make it easy to verify that it actually works as advertised.\n\n```\nuse Term::termios;\n\nconstant $saved   = Term::termios.new( :fd($*IN.native-descriptor) ).getattr;\nconstant $termios = Term::termios.new( :fd($*IN.native-descriptor) ).getattr;\n\n# set some modified input flags\n$termios.unset_iflags(<BRKINT ICRNL ISTRIP IXON>);\n$termios.unset_lflags(< ECHO ICANON IEXTEN>);\n$termios.setattr(:DRAIN);\n\n# reset terminal to original settings on exit\nEND { $saved.setattr(:NOW) }\n\n\n# Sleep for a few seconds to give you time to fill the input buffer,\n# type a bunch of random characters.\nsleep 2;\n\n# ------- The actual task --------\n# Flush the input buffer\n\n$termios.setattr(:FLUSH);\n\n# --------------------------------\n\n# Ctrl-C to exit\nloop {\n    # Read up to 5 bytes from STDIN\n    # F5 through F12 are 5 bytes each\n    my $keypress = $*IN.read: 5;\n    # print the ordinals of the keypress character\n    print $keypress.decode.ords;\n    print \"|\";\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Determine if a key has been pressed and store this in a variable.\n\nIf no key has been pressed, the program should continue without waiting."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.10\n\n```\nuse Term::ReadKey;\n\nreact {\n    whenever key-pressed(:!echo) {\n        given .fc {\n            when 'q' { done }\n            default { .uniname.say }\n        }\n    }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nObtain a valid   **Y**   or   **N**   response from the keyboard.\n\nThe keyboard should be flushed, so that any outstanding key-presses are removed, preventing any existing   **Y**   or   **N**   key-press from being evaluated.\n\nThe response should be obtained as soon as   **Y**   or   **N**   are pressed, and there should be no need to press an   enter   key."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $TTY = open(\"/dev/tty\");\n\nsub prompt-char($prompt) {\n    ENTER shell \"stty raw -echo min 1 time 1\";\n    LEAVE shell \"stty sane\";\n\n    print $prompt;\n    $TTY.read(1).decode('latin1');\n}\n\nsay so prompt-char(\"Y or N? \") ~~ /:i y/;\n\n```"}]}
{"messages": [{"role": "user", "content": "Show how to link user defined methods to user defined keys.\n\nAn example of this is the facility provided by emacs for key bindings.\n\nThese key bindings may be application-specific or system-wide; state which you have done."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $TTY = open(\"/dev/tty\");\nmy @INPUT;\n\nsub log($mess) { print \"$mess\\r\\n\" }\n\nINIT { shell \"stty raw -echo min 1 time 1\"; log \"(raw mode)\"; }\nEND { shell \"stty sane\"; log \"(sane mode)\"; }\n\nloop {\n    push @INPUT, $TTY.getc unless @INPUT;\n    given @INPUT.shift {\n        when \"q\" | \"\\c4\" { log \"QUIT\"; last; }\n\n        when \"\\r\" { log \"CR\" }\n\n        when \"j\" { log \"down\" }\n        when \"k\" { log \"up\" }\n        when \"h\" { log \"left\" }\n        when \"l\" { log \"right\" }\n\n        when \"J\" { log \"DOWN\" }\n        when \"K\" { log \"UP\" }\n        when \"H\" { log \"LEFT\" }\n        when \"L\" { log \"RIGHT\" }\n\n        when \"\\e\" {\n            my $esc = '';\n            repeat until my $x ~~ /^<alpha>$/ {\n                push @INPUT, $TTY.getc unless @INPUT;\n                $x = @INPUT.shift;\n                $esc ~= $x;\n            }\n            given $esc {\n                when \"[A\" { log \"up\" }\n                when \"[B\" { log \"down\" }\n                when \"[C\" { log \"right\" }\n                when \"[D\" { log \"left\" }\n                when \"[1;2A\" { log \"UP\" }\n                when \"[1;2B\" { log \"DOWN\" }\n                when \"[1;2C\" { log \"RIGHT\" }\n                when \"[1;2D\" { log \"LEFT\" }\n                default { log \"Unrecognized escape: $esc\"; }\n            }\n        }\n        default { log \"Unrecognized key: $_\"; }\n    }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Klarner-Rado sequences are a class of similar sequences that were studied by the mathematicians David Klarner and Richard Rado.\n\nThe most well known is defined as the thinnest strictly ascending sequence ***K*** which starts **1**, then, for each element ***n***, it will also contain somewhere in the sequence, ***2 × n + 1*** and ***3 × n + 1***.\n\nSo, the sequence ***K*** starts with **1**.\n\nSet ***n*** equal to the first element **1**; the sequence will also contain ***2 × n + 1*** and ***3 × n + 1***, or **3** and **4**.\n\nSet ***n*** equal to the next element: **3**, somewhere in the sequence it will contain ***2 × n + 1*** and ***3 × n + 1***, or **7** and **10**.\n\nContinue setting ***n*** equal to each element in turn to add to the sequence.\n\nTask\n\n* Find and display the first one hundred elements of the sequence.\n* Find and display the one thousandth and ten thousandth elements of the sequence.\n\n*Preferably without needing to find an over abundance and sorting.*\n\nStretch\n\n* Find and display the one hundred thousandth and one millionth elements of the sequence.\n\nSee also\n\n* OEIS:A002977 - Klarner-Rado sequence: a(1) = 1; subsequent terms are defined by the rule that if m is present so are 2m+1 and 3m+1"}, {"role": "assistant", "content": "```\nsub Klarner-Rado ($n) {\n    my @klarner-rado = 1;\n    my @next = x2, x3;\n\n    loop {\n        @klarner-rado.push: my $min = @next.min;\n        @next[0] = x2 if @next[0] == $min;\n        @next[1] = x3 if @next[1] == $min;\n        last if +@klarner-rado > $n.max;\n    }\n\n    sub x2 { state $i = 0; @klarner-rado[$i++] × 2 + 1 }\n    sub x3 { state $i = 0; @klarner-rado[$i++] × 3 + 1 }\n\n    @klarner-rado[|$n]\n}\n\nuse Lingua::EN::Numbers;\n\nput \"First 100 elements of Klarner-Rado sequence:\";\nput Klarner-Rado(^100).batch(10)».fmt(\"%3g\").join: \"\\n\";\nput '';\nput (($_».Int».&ordinal».tc »~» ' element: ').List Z~ |(List.new: (Klarner-Rado ($_ »-» 1))».&comma)\n    given $(1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6)).join: \"\\n\";\n\n```\n\nOutput:\n\n```\nFirst 100 elements of Klarner-Rado sequence:\n  1   3   4   7   9  10  13  15  19  21\n 22  27  28  31  39  40  43  45  46  55\n 57  58  63  64  67  79  81  82  85  87\n 91  93  94 111 115 117 118 121 127 129\n130 135 136 139 159 163 165 166 171 172\n175 183 187 189 190 193 202 223 231 235\n237 238 243 244 247 255 256 259 261 262\n271 273 274 279 280 283 319 327 331 333\n334 343 345 346 351 352 355 364 367 375\n379 381 382 387 388 391 405 406 409 418\n\nFirst element: 1\nTenth element: 21\nOne hundredth element: 418\nOne thousandth element: 8,487\nTen thousandth element: 157,653\nOne hundred thousandth element: 2,911,581\nOne millionth element: 54,381,285\n```"}]}
{"messages": [{"role": "user", "content": "A tourist wants to make a good trip at the weekend with his friends.\n\nThey will go to the mountains to see the wonders of nature, so he needs to pack well for the trip.\n\nHe has a good knapsack for carrying things, but knows that he can carry a maximum of only 4kg in it,   and it will have to last the whole day.\n\nHe creates a list of what he wants to bring for the trip but the total weight of all items is too much.\n\nHe then decides to add columns to his initial list detailing their weights and a numerical value representing how important the item is for the trip.\n\nHere is the list:\n\n:   :   :   :   :   :   :   Table of potential knapsack items\n\n                            | item | weight (dag) | value |\n                            | --- | --- | --- |\n                            | map | 9 | 150 |\n                            | compass | 13 | 35 |\n                            | water | 153 | 200 |\n                            | sandwich | 50 | 160 |\n                            | glucose | 15 | 60 |\n                            | tin | 68 | 45 |\n                            | banana | 27 | 60 |\n                            | apple | 39 | 40 |\n                            | cheese | 23 | 30 |\n                            | beer | 52 | 10 |\n                            | suntan cream | 11 | 70 |\n                            | camera | 32 | 30 |\n                            | T-shirt | 24 | 15 |\n                            | trousers | 48 | 10 |\n                            | umbrella | 73 | 40 |\n                            | waterproof trousers | 42 | 70 |\n                            | waterproof overclothes | 43 | 75 |\n                            | note-case | 22 | 80 |\n                            | sunglasses | 7 | 20 |\n                            | towel | 18 | 12 |\n                            | socks | 4 | 50 |\n                            | book | 30 | 10 |\n                            | knapsack | ≤400 dag | ? |\n\nThe tourist can choose to take any combination of items from the list,\nbut only one of each item is available.\n\nHe may not cut or diminish the items, so he can only take whole units of any item.\n\nTask\n\nShow which items the tourist can carry in his knapsack so that their total weight does not\nexceed 400 dag [4 kg],   and their total value is maximized.\n\n[dag = decagram = 10 grams]\n\nRelated tasks\n\n* Knapsack problem/Bounded\n* Knapsack problem/Unbounded\n* Knapsack problem/Continuous\n* A\\* search algorithm"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n#### Brute force\n\n**Works with**: Rakudo version 2017.01\n\n```\nmy class KnapsackItem { has $.name; has $.weight; has $.unit; }\n\nmulti sub pokem ([],           $,  $v = 0) { $v }\nmulti sub pokem ([$,  *@],     0,  $v = 0) { $v }\nmulti sub pokem ([$i, *@rest], $w, $v = 0) {\n  my $key = \"{+@rest} $w $v\";\n  (state %cache){$key} or do {\n    my @skip = pokem @rest, $w, $v;\n    if $w >= $i.weight { # next one fits\n      my @put = pokem @rest, $w - $i.weight, $v + $i.unit;\n      return (%cache{$key} = |@put, $i.name).list if @put[0] > @skip[0];\n    }\n    return (%cache{$key} = |@skip).list;\n  }\n}\n\nmy $MAX_WEIGHT = 400;\nmy @table = flat map -> $name,  $weight,  $unit {\n     KnapsackItem.new: :$name, :$weight, :$unit;\n},\n    'map',                      9, 150,\n    'compass',                 13,  35,\n    'water',                  153, 200,\n    'sandwich',                50, 160,\n    'glucose',                 15,  60,\n    'tin',                     68,  45,\n    'banana',                  27,  60,\n    'apple',                   39,  40,\n    'cheese',                  23,  30,\n    'beer',                    52,  10,\n    'suntan cream',            11,  70,\n    'camera',                  32,  30,\n    'T-shirt',                 24,  15,\n    'trousers',                48,  10,\n    'umbrella',                73,  40,\n    'waterproof trousers',     42,  70,\n    'waterproof overclothes',  43,  75,\n    'note-case',               22,  80,\n    'sunglasses',               7,  20,\n    'towel',                   18,  12,\n    'socks',                    4,  50,\n    'book',                    30,  10;\n\nmy ($value, @result) = pokem @table, $MAX_WEIGHT;\nsay \"Value = $value\\nTourist put in the bag:\\n  \" ~ @result;\n\n```\n\nOutput:\n\n```\nValue = 1030\nTourist put in the bag:\n  socks sunglasses note-case waterproof overclothes waterproof trousers suntan cream banana glucose sandwich water compass map\n```\n\n#### Dynamic programming\n\nMuch faster than the previous example.\n\n**Translation of**: Perl\n\n```\nmy $raw = q:to/TABLE/;\n    map                      9  150\n    compass                 13   35\n    water                  153  200\n    sandwich                50  160\n    glucose                 15   60\n    tin                     68   45\n    banana                  27   60\n    apple                   39   40\n    cheese                  23   30\n    beer                    52   10\n    suntancream             11   70\n    camera                  32   30\n    T-shirt                 24   15\n    trousers                48   10\n    umbrella                73   40\n    waterproof trousers     42   70\n    waterproof overclothes  43   75\n    note-case               22   80\n    sunglasses               7   20\n    towel                   18   12\n    socks                    4   50\n    book                    30   10\nTABLE\n\nmy (@name, @weight, @value);\n\nfor $raw.lines.sort({-($_ ~~ m/\\d+/)}).comb(/\\S+[\\s\\S+]*/) -> $n, $w, $v {\n    @name.push:   $n;\n    @weight.push: $w;\n    @value.push:  $v;\n}\n\nmy $sum = 400;\n\nmy @subset;\n\nsub optimal ($item, $sub-sum) {\n    return 0, [] if $item < 0;\n    return |@subset[$item][$sub-sum] if @subset[$item][$sub-sum];\n\n    my @next = optimal($item-1, $sub-sum);\n\n    if @weight[$item] > $sub-sum {\n        @subset[$item][$sub-sum] = @next\n    } else {\n        my @skip = optimal($item-1, $sub-sum - @weight[$item]);\n\n        if (@next[0] > @skip[0] + @value[$item] ) {\n            @subset[$item][$sub-sum] = @next;\n        } else {\n            @subset[$item][$sub-sum] = @skip[0] + @value[$item], [|@skip[1], @name[$item]];\n        }\n    }\n\n    |@subset[$item][$sub-sum]\n}\n\nmy @solution = optimal(@name.end, $sum);\nput \"@solution[0]: \", @solution[1].sort.join(', ');\n\n```\n\nOutput:\n\n```\n1030: banana, compass, glucose, map, note-case, sandwich, socks, sunglasses, suntancream, water, waterproof overclothes, waterproof trousers\n\n```"}]}
{"messages": [{"role": "user", "content": "A tourist wants to make a good trip at the weekend with his friends.\n\nThey will go to the mountains to see the wonders of nature.   So he needs some items during the trip.   Food, clothing, etc.   He has a good knapsack for carrying the things, but he knows that he can carry only 4 kg weight in his knapsack, because they will make the trip from morning to evening.\n\nHe creates a list of what he wants to bring for the trip, but the total weight of all items is too much.   He adds a value to each item.   The value represents how important the thing for the tourist.\n\nThe list contains which items are the wanted things for the trip, what is the weight and value of an item, and how many units does he have from each items.\n\nThis is the list:\n\n:   :   :   :   :   Table of potential knapsack items\n\n                    | item | weight (dag) (each) | value (each) | piece(s) |\n                    | --- | --- | --- | --- |\n                    | map | 9 | 150 | 1 |\n                    | compass | 13 | 35 | 1 |\n                    | water | 153 | 200 | 2 |\n                    | sandwich | 50 | 60 | 2 |\n                    | glucose | 15 | 60 | 2 |\n                    | tin | 68 | 45 | 3 |\n                    | banana | 27 | 60 | 3 |\n                    | apple | 39 | 40 | 3 |\n                    | cheese | 23 | 30 | 1 |\n                    | beer | 52 | 10 | 3 |\n                    | suntan cream | 11 | 70 | 1 |\n                    | camera | 32 | 30 | 1 |\n                    | T-shirt | 24 | 15 | 2 |\n                    | trousers | 48 | 10 | 2 |\n                    | umbrella | 73 | 40 | 1 |\n                    | waterproof trousers | 42 | 70 | 1 |\n                    | waterproof overclothes | 43 | 75 | 1 |\n                    | note-case | 22 | 80 | 1 |\n                    | sunglasses | 7 | 20 | 1 |\n                    | towel | 18 | 12 | 2 |\n                    | socks | 4 | 50 | 1 |\n                    | book | 30 | 10 | 2 |\n                    | knapsack | ≤400 dag | ? | ? |\n\nThe tourist can choose to take any combination of items from the list, and some number of each item is available   (see the column   **piece(s)**   in the list above).\n\nHe may not cut the items, so he can only take whole units of any item.\n\nTask\n\nShow which items does the tourist carry in his knapsack so that their total weight does not exceed 4 kg, and their total value is maximized.\n\nRelated tasks\n\n* Knapsack problem/Unbounded\n* Knapsack problem/Continuous\n* Knapsack problem/0-1"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n#### Original\n\nRecursive algorithm, with cache. Idiomatic code style, using multi-subs and a class.\n\n**Works with**: Rakudo version 2017.01\n\n```\nmy class KnapsackItem { has $.name; has $.weight; has $.unit; }\n\nmulti sub pokem ([],           $,  $v = 0) { $v }\nmulti sub pokem ([$,  *@],     0,  $v = 0) { $v }\nmulti sub pokem ([$i, *@rest], $w, $v = 0) {\n  my $key = \"{+@rest} $w $v\";\n  (state %cache){$key} or do {\n    my @skip = pokem @rest, $w, $v;\n    if $w >= $i.weight { # next one fits\n      my @put = pokem @rest, $w - $i.weight, $v + $i.unit;\n      return (%cache{$key} = |@put, $i.name).list if @put[0] > @skip[0];\n    }\n    return (%cache{$key} = |@skip).list;\n  }\n}\n\nmy $MAX_WEIGHT = 400;\nmy @table = flat map -> $name,  $weight,  $unit,     $count {\n     KnapsackItem.new( :$name, :$weight, :$unit ) xx $count;\n},\n        'map',                         9,      150,    1,\n        'compass',                     13,     35,     1,\n        'water',                       153,    200,    2,\n        'sandwich',                    50,     60,     2,\n        'glucose',                     15,     60,     2,\n        'tin',                         68,     45,     3,\n        'banana',                      27,     60,     3,\n        'apple',                       39,     40,     3,\n        'cheese',                      23,     30,     1,\n        'beer',                        52,     10,     3,\n        'suntan cream',                11,     70,     1,\n        'camera',                      32,     30,     1,\n        'T-shirt',                     24,     15,     2,\n        'trousers',                    48,     10,     2,\n        'umbrella',                    73,     40,     1,\n        'waterproof trousers',         42,     70,     1,\n        'waterproof overclothes',      43,     75,     1,\n        'note-case',                   22,     80,     1,\n        'sunglasses',                  7,      20,     1,\n        'towel',                       18,     12,     2,\n        'socks',                       4,      50,     1,\n        'book',                        30,     10,     2\n        ;\n\nmy ($value, @result) = pokem @table, $MAX_WEIGHT;\n\n(my %hash){$_}++ for @result;\n\nsay \"Value = $value\";\nsay \"Tourist put in the bag:\";\nsay \"  # ITEM\";\nfor %hash.sort -> $item {\n  say \"  {$item.value} {$item.key}\";\n}\n\n```\n\nOutput:\n\n```\nValue = 1010\nTourist put in the bag:\n  # ITEM\n  3 banana\n  1 cheese\n  1 compass\n  2 glucose\n  1 map\n  1 note-case\n  1 socks\n  1 sunglasses\n  1 suntan cream\n  1 water\n  1 waterproof overclothes\n```\n\n#### Faster alternative\n\nAlso recursive, with cache, but substantially faster. Code more generic (ported from Perl solution).\n\n```\nmy $raw = qq:to/TABLE/;\nmap             9       150     1\ncompass         13      35      1\nwater           153     200     2\nsandwich        50      60      2\nglucose         15      60      2\ntin             68      45      3\nbanana          27      60      3\napple           39      40      3\ncheese          23      30      1\nbeer            52      10      1\nsuntancream     11      70      1\ncamera          32      30      1\nT-shirt         24      15      2\ntrousers        48      10      2\numbrella        73      40      1\nw_trousers      42      70      1\nw_overcoat      43      75      1\nnote-case       22      80      1\nsunglasses       7      20      1\ntowel           18      12      2\nsocks            4      50      1\nbook            30      10      2\nTABLE\n\nmy @items;\nfor split([\"\\n\", /\\s+/], $raw, :skip-empty) -> $n,$w,$v,$q {\n    @items.push: %{ name => $n, weight => $w, value => $v, quant => $q}\n}\n\nmy $max_weight = 400;\n\nsub pick ($weight, $pos) {\n    state %cache;\n    return 0, 0 if $pos < 0 or $weight <= 0;\n\n    my $key = $weight ~ $pos;\n    %cache{$key} or do {\n        my %item = @items[$pos];\n        my ($bv, $bi, $bw, @bp) = (0, 0, 0);\n\n        for 0 .. %item{'quant'} -> $i {\n            last if $i * %item{'weight'} > $weight;\n            my ($v, $w, @p) = pick($weight - $i * %item{'weight'}, $pos - 1);\n            next if ($v += $i * %item{'value'}) <= $bv;\n\n            ($bv, $bi, $bw, @bp) = ($v, $i, $w, |@p);\n        }\n        %cache{$key} = $bv, $bw + $bi * %item{'weight'}, |@bp, $bi;\n    }\n}\n\nmy ($v, $w, @p) = pick($max_weight, @items.end);\n{ say \"{@p[$_]} of @items[$_]{'name'}\" if @p[$_] } for 0 .. @p.end;\nsay \"Value: $v Weight: $w\";\n\n```\n\nOutput:\n\n```\n1 of map\n1 of compass\n1 of water\n2 of glucose\n3 of banana\n1 of cheese\n1 of suntancream\n1 of w_overcoat\n1 of note-case\n1 of sunglasses\n1 of socks\nValue: 1010 Weight: 396\n```"}]}
{"messages": [{"role": "user", "content": "A thief burgles a butcher's shop, where he can select from some items.\n\nThe thief knows the weights and prices of each items.   Because he has a knapsack with 15 kg maximal capacity, he wants to select the items such that he would have his profit maximized.   He may cut the items;   the item has a reduced price after cutting that is proportional to the original price by the ratio of masses.   That means:   half of an item has half the price of the original.\n\nThis is the item list in the butcher's shop:\n\n:   :   :   :   :   :   Table of potential knapsack items\n\n                        | Item | Weight (kg) | Price (Value) |\n                        | --- | --- | --- |\n                        | beef | 3.8 | 36 |\n                        | pork | 5.4 | 43 |\n                        | ham | 3.6 | 90 |\n                        | greaves | 2.4 | 45 |\n                        | flitch | 4.0 | 30 |\n                        | brawn | 2.5 | 56 |\n                        | welt | 3.7 | 67 |\n                        | salami | 3.0 | 95 |\n                        | sausage | 5.9 | 98 |\n                        | Knapsack | <=15 kg | ? |\n\nTask\n\nShow which items the thief carries in his knapsack so that their total weight does not exceed 15 kg, and their total value is maximized.\n\nRelated tasks\n\n* Knapsack problem/Bounded\n* Knapsack problem/Unbounded\n* Knapsack problem/0-1\n\nSee also\n\n* Wikipedia article:   continuous knapsack."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-16\n\nThis Solutions sorts the item by WEIGHT/VALUE\n\n```\nclass KnapsackItem {\n  has $.name;\n  has $.weight is rw;\n  has $.price is rw;\n  has $.ppw;\n\n  method new (Str $n, Rat $w, Int $p) {\n    self.bless(:name($n), :weight($w), :price($p), :ppw($w/$p))\n  }\n\n  method cut-maybe ($max-weight) {\n    return False if $max-weight > $.weight;\n    $.price = $max-weight / $.ppw;\n    $.weight = $.ppw * $.price;\n    return True;\n  }\n\n  method gist () { sprintf \"%8s %1.2f   %3.2f\",\n                            $.name,\n                                $.weight,\n                                        $.price }\n}\n\nmy $max-w = 15;\nsay    \"Item    Portion Value\";\n\n.say for gather\n    for < beef    3.8 36\n          pork    5.4 43\n          ham     3.6 90\n          greaves 2.4 45\n          flitch  4.0 30\n          brawn   2.5 56\n          welt    3.7 67\n          salami  3.0 95\n          sausage 5.9 98 >\n        ==> map({ KnapsackItem.new($^a, $^b, $^c) })\n        ==> sort *.ppw\n    {\n        my $last-one = .cut-maybe($max-w);\n        take $_;\n        $max-w -= .weight;\n        last if $last-one;\n    }\n\n```\n\n**Output:**\n\n```\nItem    Portion Value\n  salami 3.00   95.00\n     ham 3.60   90.00\n   brawn 2.50   56.00\n greaves 2.40   45.00\n    welt 3.50   63.38\n```"}]}
{"messages": [{"role": "user", "content": "A traveler gets diverted and has to make an unscheduled stop in what turns out to be Shangri La.   Opting to leave, he is allowed to take as much as he likes of the following items, so long as it will fit in his knapsack, and he can carry it.\n\nHe knows that he can carry no more than   25   'weights' in total;   and that the capacity of his knapsack is   0.25   'cubic lengths'.\n\nLooking just above the bar codes on the items he finds their weights and volumes.   He digs out his recent copy of a financial paper and gets the value of each item.\n\n|  |  |  |  |  |\n| --- | --- | --- | --- | --- |\n| Item | Explanation | Value (each) | weight | Volume (each) |\n| panacea (vials of) | Incredible healing properties | 3000 | 0.3 | 0.025 |\n| ichor (ampules of) | Vampires blood | 1800 | 0.2 | 0.015 |\n| gold (bars) | Shiney shiney | 2500 | 2.0 | 0.002 |\n| Knapsack | For the carrying of | - | <=25 | <=0.25 |\n\nHe can only take whole units of any item, but there is much more of any item than he could ever carry\n\nTask\n\nShow how many of each item does he take to maximize the value of items he is carrying away with him.\n\nNote\n\n* There are four solutions that maximize the value taken.   Only one *need* be given.\n\nRelated tasks\n\n* Knapsack problem/Bounded\n* Knapsack problem/Continuous\n* Knapsack problem/0-1"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2019.03.1\n\nBrute force, looked a lot at the Ruby solution.\n\n```\nclass KnapsackItem {\n  has $.volume;\n  has $.weight;\n  has $.value;\n  has $.name;\n\n  method new($volume,$weight,$value,$name) {\n    self.bless(:$volume, :$weight, :$value, :$name)\n  }\n};\n\nmy KnapsackItem $panacea .= new: 0.025, 0.3, 3000, \"panacea\";\nmy KnapsackItem $ichor   .= new: 0.015, 0.2, 1800, \"ichor\";\nmy KnapsackItem $gold    .= new: 0.002, 2.0, 2500, \"gold\";\nmy KnapsackItem $maximum .= new: 0.25,  25,  0   , \"max\";\n\nmy $max_val = 0;\nmy @solutions;\nmy %max_items;\n\nfor $panacea, $ichor, $gold -> $item {\n    %max_items{$item.name} = floor min\n                            $maximum.volume / $item.volume,\n\t\t\t    $maximum.weight / $item.weight;\n}\n\nfor 0..%max_items<panacea>\n       X 0..%max_items<ichor>\n           X 0..%max_items<gold>\n -> ($p, $i, $g)\n{\n  next if $panacea.volume * $p + $ichor.volume * $i + $gold.volume * $g > $maximum.volume;\n  next if $panacea.weight * $p + $ichor.weight * $i + $gold.weight * $g > $maximum.weight;\n  given $panacea.value * $p + $ichor.value * $i + $gold.value * $g {\n    if $_ > $max_val { $max_val = $_; @solutions = (); }\n    when $max_val    { @solutions.push: $[$p,$i,$g] }\n  }\n}\n\nsay \"maximum value is $max_val\\npossible solutions:\";\nsay \"panacea\\tichor\\tgold\";\n.join(\"\\t\").say for @solutions;\n\n```\n\n**Output:**\n\n```\nmaximum value is 54500\npossible solutions:\npanacea\tichor\tgold\n0\t15\t11\n3\t10\t11\n6\t5\t11\n9\t0\t11\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nProblem: you have a standard 8x8 chessboard, empty but for a single knight on some square. Your task is to emit a series of legal knight moves that result in the knight visiting every square on the chessboard exactly once. Note that it is *not* a requirement that the tour be \"closed\"; that is, the knight need not end within a single move of its start position.\n\nInput and output may be textual or graphical, according to the conventions of the programming environment. If textual, squares should be indicated in algebraic notation. The output should indicate the order in which the knight visits the squares, starting with the initial position. The form of the output may be a diagram of the board with the squares numbered according to visitation sequence, or a textual list of algebraic coordinates in order, or even an actual animation of the knight moving around the chessboard.\n\nInput: starting square\n\nOutput: move sequence\n\nRelated tasks\n\n* A\\* search algorithm\n* N-queens problem\n* Solve a Hidato puzzle\n* Solve a Holy Knight's tour\n* Solve a Hopido puzzle\n* Solve a Numbrix puzzle\n* Solve the no connection puzzle"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nmy @board;\n\nmy $I = 8;\nmy $J = 8;\nmy $F = $I*$J > 99 ?? \"%3d\" !! \"%2d\";\n \n# Choose starting position - may be passed in on command line; if\n# not, choose random square.\nmy ($i, $j);\n\nif my $sq = shift @*ARGS {\n  die \"$*PROGRAM_NAME: illegal start square '$sq'\\n\" unless ($i, $j) = from_algebraic($sq);\n}\nelse {\n  ($i, $j) = (^$I).pick, (^$J).pick;\n}\n \n# Move sequence\nmy @moves = ();\n \nfor 1 .. $I * $J -> $move {\n  # Record current move\n  push @moves, to_algebraic($i,$j);\n  @board[$i][$j] = $move;\n \n  # Find move with the smallest degree\n  my @min = (9);\n  for possible_moves($i,$j) -> @target {\n      my ($ni, $nj) = @target;\n      my $next = possible_moves($ni,$nj);\n      @min = $next, $ni, $nj if $next < @min[0];\n  }\n \n  # And make it\n  ($i, $j) = @min[1,2];\n}\n \n# Print the move list\nfor @moves.kv -> $i, $m {\n    print ',', $i %% 16 ?? \"\\n\" !! \" \" if $i;\n    print $m;\n}\nsay \"\\n\";\n \n# And the board, with move numbers\nfor ^$I -> $i {\n  for ^$J -> $j {\n    # Assumes (1) ANSI sequences work, and (2) output \n    # is light text on a dark background.\n    print \"\\e[7m\" if $i % 2 == $j % 2; \n    printf $F, @board[$i][$j];\n    print \"\\e[0m\";\n  }\n  print \"\\n\";\n}\n \n# Find the list of positions the knight can move to from the given square\nsub possible_moves($i,$j) {\n  grep -> [$ni, $nj] { $ni ~~ ^$I and $nj ~~ ^$J and !@board[$ni][$nj] }, \n    [$i-2,$j-1], [$i-2,$j+1], [$i-1,$j-2], [$i-1,$j+2],\n    [$i+1,$j-2], [$i+1,$j+2], [$i+2,$j-1], [$i+2,$j+1];\n}\n \n# Return the algebraic name of the square identified by the coordinates\n# i=rank, 0=black's home row; j=file, 0=white's queen's rook\nsub to_algebraic($i,$j) {\n    chr(ord('a') + $j) ~ ($I - $i);\n}\n \n# Return the coordinates matching the given algebraic name\nsub from_algebraic($square where /^ (<[a..z]>) (\\d+) $/) {\n   $I - $1, ord(~$0) - ord('a');\n}\n\n```\n\n(Output identical to Perl's above.)"}]}
{"messages": [{"role": "user", "content": "The   Knuth shuffle   (a.k.a. the Fisher-Yates shuffle)   is an algorithm for randomly shuffling the elements of an array.\n\nTask\n\nImplement the Knuth shuffle for an integer array (or, if possible, an array of any type).\n\nSpecification\n\nGiven an array ***items*** with indices ranging from *0* to ***last***, the algorithm can be defined as follows (pseudo-code):\n\n```\n       for i from last downto 1 do:\n           let j = random integer in range 0 \n  \n    \n      \n        \n          \n            ≤\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\leq }}\n  \n j \n  \n    \n      \n        \n          \n            ≤\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\leq }}\n  \n i\n           swap items[i] with items[j]\n\n```\n\nNotes\n\n* It modifies the input array in-place.\n* If that is unreasonable in your programming language, you may amend the algorithm to return the shuffled items as a new array instead.\n* The algorithm can also be amended to iterate from left to right, if that is more convenient.\n\nTest cases\n\n:   :   :   :   :   :   | Input array | Possible output arrays |\n                        | --- | --- |\n                        | [] | [] |\n                        | [10] | [10] |\n                        | [10, 20] | [10, 20] [20, 10] |\n                        | [10, 20, 30] | [10, 20, 30] [10, 30, 20] [20, 10, 30] [20, 30, 10] [30, 10, 20] [30, 20, 10] |\n\n(These are listed here just for your convenience; no need to demonstrate them on the page.)\n\nRelated task\n\n* Sattolo cycle\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #21 \"Seattle\"\n\n```\nsub shuffle (@a is copy) {\n    for 1 ..^ @a -> $n {\n        my $k = (0 .. $n).pick;\n        $k == $n or @a[$k, $n] = @a[$n, $k];\n    }\n    return @a;\n}\n```\n\nThe shuffle is also built into the pick method on lists when you pass it a \"whatever\" for the number to pick:\n\n```\nmy @deck = @cards.pick(*);\n```"}]}
{"messages": [{"role": "user", "content": "This is a method of randomly sampling n items from a set of M items, with equal probability; where M >= n and M, the number of items is unknown until the end.\nThis means that the equal probability sampling should be maintained for all successive items > n as they become available (although the content of successive samples can change).\n\nThe algorithm\n:   * Select the first n items as the sample as they become available;\n    * For the i-th item where i > n, have a random chance of n/i of keeping it. If failing this chance, the sample remains the same. If not, have it randomly (1/n) replace one of the previously selected n items of the sample.\n    * Repeat   2nd step   for any subsequent items.\n\nThe Task\n:   * Create a function `s_of_n_creator` that given \n\n      n\n      {\\displaystyle {\\displaystyle n}}\n       the maximum sample size, returns a function `s_of_n` that takes one parameter, `item`.\n    * Function `s_of_n` when called with successive items returns an equi-weighted random sample of up to n of its items so far, each time it is called, calculated using Knuths Algorithm S.\n    * Test your functions by printing and showing the frequency of occurrences of the selected digits from 100,000 repetitions of:\n\n    :   :   1. Use the s\\_of\\_n\\_creator with n == 3 to generate an s\\_of\\_n.\n            2. call s\\_of\\_n with each of the digits 0 to 9 in order, keeping the returned three digits of its random sampling from its last call with argument item=9.\n\nNote: A class taking n and generating a callable instance/function might also be used.\n\nReference\n\n* The Art of Computer Programming, Vol 2, 3.4.2 p.142\n\nRelated tasks\n\n* One of n lines in a file\n* Accumulator factory"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub s_of_n_creator($n) {\n    my (@sample, $i);\n    -> $item {\n        if    ++$i    <= $n { @sample.push:      $item }\n        elsif $i.rand <  $n { @sample[$n.rand] = $item }\n        @sample\n    }\n}\n\nmy @bin;\nfor ^100000 {\n    my &s_of_n = s_of_n_creator 3;\n    sink .&s_of_n for ^9;\n    @bin[$_]++ for s_of_n 9;\n}\n\nsay @bin;\n\n```\n\nOutput:\n\n```\n29975 30028 30246 30056 30004 29983 29836 29967 29924 29981\n```"}]}
{"messages": [{"role": "user", "content": "(Knuth's power tree is used for computing   xn   efficiently.)\n\nTask\n\nCompute and show the list of Knuth's power tree integers necessary for the computation of:\n\n:   :   * xn   for any real   x   and any non-negative integer   n.\n\nThen, using those integers, calculate and show the exact values of (at least) the integer powers below:\n\n:   :   * 2n     where   n   ranges from   0 ──► 17   (inclusive)\n        * 3191\n        * 1.181\n\nA  *zero*  power is often handled separately as a special case.\n\nOptionally, support negative integer powers.\n\nExample\n\nAn example of a small power tree for some low integers:\n\n```\n                                                                    1\n                                                                     \\\n                                                                      2\n                          ___________________________________________/ \\\n                         /                                              \\\n                        3                                                4\n                       / \\____________________________________            \\\n                      /                                       \\            \\\n                     5                                         6            8\n                    / \\____________                           / \\            \\\n                   /               \\                         /   \\            \\\n                  7                 10                      9     12           16\n                 /                 //\\\\                     │      │           /\\\n                /            _____//  \\\\________            │      │          /  \\\n              14            /     /    \\        \\           │      │         /    \\\n             /│ \\         11    13      15       20        18     24        17    32\n            / │  \\         │    /\\      /\\        │        /\\      │        /\\     │\n           /  │   \\        │   /  \\    /  \\       │       /  \\     │       /  \\    │\n         19  21    28     22 23   26  25   30    40     27   36    48     33 34   64\n         │   /\\    /│\\     │  │   /\\   │   /\\    /│\\     │   /\\    /│\\     │  │   /\\\n         │  /  \\  / │ \\    │  │  /  \\  │  /  \\  / │ \\    │  /  \\  / │ \\    │  │  /  \\\n        38 35 42 29 31 56 44 46 39 52 50 45 60 41 43 80 54 37 72 49 51 96 66 68 65 128\n\n```\n\nWhere, for the power   43,   following the tree \"downwards\" from   1:\n\n:   :   * (for   2)   compute square of   X,   store X2\n        * (for   3)   compute   X \\* X2,   store X3\n        * (for   5)   compute   X3 \\* X2,   store X5\n        * (for 10)   compute square of   X5,   store X10\n        * (for 20)   compute square of   X10,   store X20\n        * (for 40)   compute square of   X20,   store X40\n        * (for 43)   compute   X40 \\* X3   (result).\n\nNote that for every even integer (in the power tree),   one just squares the previous value.\n\nFor an odd integer, multiply the previous value with an appropriate odd power of   X   (which was previously calculated).\n  For the last multiplication in the above example, it would be   (43-40),   or   3.\n\nAccording to Dr. Knuth (see below),   computer tests have shown that this power tree gives optimum results for all of the   *n*\n  listed above in the graph.\n\nFor   *n*   ≤ 100,000,   the power tree method:\n\n:   :   * bests the factor method   88,803   times,\n        * ties   11,191   times,\n        * loses   6   times.\n\nReferences\n:   :   * Donald E. Knuth's book:   *The Art of Computer Programming, Vol. 2*, Second Edition, Seminumerical Algorithms, section 4.6.3: Evaluation of Powers.\n        * link   codegolf.stackexchange.com/questions/3177/knuths-power-tree     It shows a   **Haskell**,   **Python**,   and a   **Ruby**   computer program example   (but they are mostly   *code golf*).\n        * link   comeoncodeon.wordpress.com/tag/knuth/     (See the section on Knuth's Power Tree.)     It shows a   **C++**   computer program example.\n        * link to Rosetta Code   addition-chain exponentiation."}, {"role": "assistant", "content": "(formerly Perl 6)\nPaths are random. It is possible replace `.pick(*)` with `.reverse` if you want paths as in Perl, or remove it for Python paths.\n\n```\nuse v6;\n\nsub power-path ($n ) {\n    state @unused_nodes = (2,);\n    state @power-tree = (False,0,1);\n    \n    until @power-tree[$n].defined {\n        my $node = @unused_nodes.shift;\n\n        for  $node X+ power-path($node).pick(*) {\n            next if @power-tree[$_].defined;\n            @unused_nodes.push($_);\n            @power-tree[$_]= $node;\n        }        \n    }\n\n    ( $n, { @power-tree[$_] } ...^ 0 ).reverse;\n}\n\nmulti power ( $, 0 ) { 1 };\nmulti power ( $n, $exponent ) {\n    state  %p;\n    my     %r =  %p{$n}  // ( 0 => 1, 1 => $n ) ;  \n\n    for power-path( $exponent ).rotor( 2 => -1 ) -> ( $p, $c ) {\n        %r{ $c } = %r{ $p } * %r{ $c - $p }\n    }\n\n    %p{$n} := %r ;\n    %r{ $exponent }\n}\n\nsay 'Power paths: ',      pairs map *.&power-path,    ^18;\nsay '2 ** key = value: ', pairs map { 2.&power($_) }, ^18; \n\nsay 'Path for 191: ', power-path 191;\nsay '3 ** 191 = ',    power   3, 191;\nsay 'Path for 81: ',  power-path  81;\nsay '1.1 ** 81 = ',   power 1.1,  81;\n\n```\n\nOutput:\n\n```\nPower paths: (0 => () 1 => (1) 2 => (1 2) 3 => (1 2 3) 4 => (1 2 4) 5 => (1 2 3 5) 6 => (1 2 3 6) 7 => (1 2 3 6 7) 8 => (1 2 4 8) 9 => (1 2 3 6 9) 10 => (1 2 3 5 10) 11 => (1 2 3 6 9 11) 12 => (1 2 3 6 12) 13 => (1 2 3 6 12 13) 14 => (1 2 3 6 12 14) 15 => (1 2 3 6 9 15) 16 => (1 2 4 8 16) 17 => (1 2 4 8 16 17))\n2 ** key = value: (0 => 1 1 => 2 2 => 4 3 => 8 4 => 16 5 => 32 6 => 64 7 => 128 8 => 256 9 => 512 10 => 1024 11 => 2048 12 => 4096 13 => 8192 14 => 16384 15 => 32768 16 => 65536 17 => 131072)\nPath for 191: (1 2 3 6 9 18 27 54 108 162 189 191)\n3 ** 191 = 13494588674281093803728157396523884917402502294030101914066705367021922008906273586058258347\nPath for 81: (1 2 3 6 9 18 27 54 81)\n1.1 ** 81 = 2253.24023604401\n\n```"}]}
{"messages": [{"role": "user", "content": "< About Knuth-Morris-Pratt String Search Algorithm >"}, {"role": "assistant", "content": "Based on pseudocode found in WP (kmp\\_search & kmp\\_table). Data and output format mostly follows the Wren entry.\n\n```\n# 20220810 Raku programming solution\n\nsub kmp_search (@S where *.Bool, @W where *.Bool) {\n\n   sub kmp_table (@W where *.Bool) {\n      loop (my ($pos,$cnd,@T) = 1,0,-1 ; $pos < @W.elems ; ($pos, $cnd)>>++) {\n         if @W[$pos] eq @W[$cnd] {\n            @T[$pos]  = @T[$cnd]\n         } else {\n            @T[$pos]  = $cnd;\n            while $cnd ≥ 0 and @W[$pos] ne @W[$cnd] { $cnd = @T[$cnd] }\n         }\n      }\n      @T[$pos] = $cnd;\n      return @T\n   }\n\n   return gather loop (my ($j,$k,@T) = 0,0, |kmp_table @W; $j < @S.elems; ) { \n      if @W[$k] eq @S[$j] { \n         ($j, $k)>>++;   \n         if $k == @W.elems { \n\t    take $j - $k;\n            $k = @T[$k]  \n         } \n      } else {\n         ($j, $k)>>++ if ($k = @T[$k]) < 0    \n      }\n   }\n}\n\nmy @texts = [\n   \"GCTAGCTCTACGAGTCTA\",\n   \"GGCTATAATGCGTA\",\n   \"there would have been a time for such a word\",\n   \"needle need noodle needle\",\n   \"BharôtভাৰতBharôtভারতIndiaBhāratભારતBhāratभारतBhārataಭಾರತBhāratभारतBhāratamഭാരതംBhāratभारतBhāratभारतBharôtôଭାରତBhāratਭਾਰਤBhāratamभारतम्Bārataபாரதம்BhāratamഭാരതംBhāratadēsamభారతదేశం\",\n   \"InhisbookseriesTheArtofComputerProgrammingpublishedbyAddisonWesleyDKnuthusesanimaginarycomputertheMIXanditsassociatedmachinecodeandassemblylanguagestoillustratetheconceptsandalgorithmsastheyarepresented\",\n   \"Nearby farms grew a half acre of alfalfa on the dairy's behalf, with bales of all that alfalfa exchanged for milk.\",\n];\n\nmy @pats = [\"TCTA\", \"TAATAAA\", \"word\", \"needle\", \"ഭാരതം\", \"put\", \"and\", \"alfalfa\"];\n\nsay \"text$_ = @texts[$_]\" for @texts.keys ; \nsay();\n\nfor @pats.keys {\n   my \\j = $_ < 6 ?? $_ !! $_-1 ; # for searching text5 twice\n   say \"Found '@pats[$_]' in 'text{j}' at indices \", kmp_search @texts[j].comb, @pats[$_].comb\n}\n\n```\n\nOutput:\n\n```\ntext0 = GCTAGCTCTACGAGTCTA\ntext1 = GGCTATAATGCGTA\ntext2 = there would have been a time for such a word\ntext3 = needle need noodle needle\ntext4 = BharôtভাৰতBharôtভারতIndiaBhāratભારતBhāratभारतBhārataಭಾರತBhāratभारतBhāratamഭാരതംBhāratभारतBhāratभारतBharôtôଭାରତBhāratਭਾਰਤBhāratamभारतम्Bārataபாரதம்BhāratamഭാരതംBhāratadēsamభారతదేశం\ntext5 = InhisbookseriesTheArtofComputerProgrammingpublishedbyAddisonWesleyDKnuthusesanimaginarycomputertheMIXanditsassociatedmachinecodeandassemblylanguagestoillustratetheconceptsandalgorithmsastheyarepresented\ntext6 = Nearby farms grew a half acre of alfalfa on the dairy's behalf, with bales of all that alfalfa exchanged for milk.\n\nFound 'TCTA' in 'text0' at indices (6 14)\nFound 'TAATAAA' in 'text1' at indices ()\nFound 'word' in 'text2' at indices (40)\nFound 'needle' in 'text3' at indices (0 19)\nFound 'ഭാരതം' in 'text4' at indices (68 138)\nFound 'put' in 'text5' at indices (26 90)\nFound 'and' in 'text5' at indices (101 128 171)\nFound 'alfalfa' in 'text6' at indices (33 87)\n```"}]}
{"messages": [{"role": "user", "content": "Draw a Koch curve. See details: Koch curve"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nKoch curve, actually a full Koch snowflake.\n\n```\nuse SVG;\n\nrole Lindenmayer {\n    has %.rules;\n    method succ {\n        self.comb.map( { %!rules{$^c} // $c } ).join but Lindenmayer(%!rules)\n    }\n}\n\nmy $flake = 'F--F--F' but Lindenmayer( { F => 'F+F--F+F' } );\n\n$flake++ xx 5;\nmy @points = (50, 440);\n\nfor $flake.comb -> $v {\n    state ($x, $y) = @points[0,1];\n    state $d = 2 + 0i;\n    with $v {\n        when 'F' { @points.append: ($x += $d.re).round(.01), ($y += $d.im).round(.01) }\n        when '+' { $d *= .5 + .8660254i }\n        when '-' { $d *= .5 - .8660254i }\n    }\n}\n\nsay SVG.serialize(\n    svg => [\n        width => 600, height => 600, style => 'stroke:rgb(0,0,255)',\n        :rect[:width<100%>, :height<100%>, :fill<white>],\n        :polyline[ points => @points.join(','), :fill<white> ],\n    ],\n);\n\n```\n\nSee: Koch snowflake\n\nVariation using 90° angles:\n\n```\nuse SVG;\n\nrole Lindenmayer {\n    has %.rules;\n    method succ {\n\t    self.comb.map( { %!rules{$^c} // $c } ).join but Lindenmayer(%!rules)\n    }\n}\n\nmy $koch = 'F' but Lindenmayer( { F => 'F+F-F-F+F', } );\n\n$koch++ xx 4;\nmy @points = (450, 250);\n\nfor $koch.comb -> $v {\n    state ($x, $y) = @points[0,1];\n    state $d = -5 - 0i;\n    with $v {\n        when 'F' { @points.append: ($x += $d.re).round(.01), ($y += $d.im).round(.01) }\n        when /< + - >/ { $d *= \"{$v}1i\" }\n    }\n}\n\nsay SVG.serialize(\n    svg => [\n        width => 500, height => 300, style => 'stroke:rgb(0,0,255)',\n        :rect[:width<100%>, :height<100%>, :fill<white>],\n        :polyline[ points => @points.join(','), :fill<white> ],\n    ],\n);\n\n```\n\nSee: Koch curve variant with 90° angles"}]}
{"messages": [{"role": "user", "content": "The Kolakoski sequence is an infinite sequence of natural numbers, (excluding zero); with the property that:\n\n:   *if you form a new sequence from the counts of runs of the same number in the first sequence, this new sequence is the same as the first sequence*.\n\nExample\n\nThis is *not* a Kolakoski sequence:\n\n```\n1,1,2,2,2,1,2,2,1,2,...\n```\n\nIts sequence of run counts, (sometimes called a run length encoding, (RLE); but a true RLE also gives the character that each run encodes), is calculated like this:\n\n:   Starting from the leftmost number of the sequence we have `2` ones, followed by `3` twos, then `1` ones, `2` twos, `1` one, ...\n\nThe above gives the RLE of:\n\n```\n2, 3, 1, 2, 1, ...\n```\n\nThe original sequence is different from its RLE in this case. **It would be the same for a true Kolakoski sequence**.\n\nCreating a Kolakoski sequence\n\nLets start with the two numbers `(1, 2)` that we will cycle through; i.e. they will be used in this order:  \n `1,2,1,2,1,2,....`\n\n1. We start the sequence `s` with the first item from the cycle `c`:  \n    `1`\n2. An index, `k`, into the, (expanding), sequence will step, or index through each item of the sequence `s` from the first, at its own rate.\n\nWe will arrange that the `k`'th item of `s` states how many *times* the *last* item of `s`should appear at the end of `s`.\n\nWe started `s` with `1` and therefore `s[k]` states that it should appear only the `1` time.\n\n3. Increment `k`\n4. Get the next item from `c` and append it to the end of sequence `s`. `s` will then become:  \n    `1, 2`\n5. `k` was moved to the second item in the list and `s[k]` states that it should appear two times, so append another of the last item to the sequence `s`:  \n    `1, 2,2`\n6. Increment `k`\n7. Append the next item from the cycle to the list:  \n    `1, 2,2, 1`\n8. `k` is now at the third item in the list that states that the last item should appear twice so add another copy of the last item to the sequence `s`:  \n    `1, 2,2, 1,1`\n9. increment k\n\n...\n\n**Note** that the RLE of `1, 2, 2, 1, 1, ...` begins `1, 2, 2` which is the beginning of the original sequence. The generation algorithm ensures that this will always be the case.\n\nTask\n\n1. Create a routine/proceedure/function/... that given an initial ordered list/array/tuple etc of the natural numbers `(1, 2)`, returns the next number from the list when accessed in a cycle.\n2. Create another routine that when given the initial ordered list `(1, 2)` and the minimum length of the sequence to generate; uses the first routine and the algorithm above, to generate at least the requested first members of the kolakoski sequence.\n3. Create a routine that when given a sequence, creates the run length encoding of that sequence (as defined above) and returns the result of checking if sequence starts with the exact members of its RLE. (But *note*, due to sampling, do not compare the last member of the RLE).\n4. Show, on this page, (compactly), the first 20 members of the sequence generated from `(1, 2)`\n5. Check the sequence againt its RLE.\n6. Show, on this page, the first 20 members of the sequence generated from `(2, 1)`\n7. Check the sequence againt its RLE.\n8. Show, on this page, the first 30 members of the Kolakoski sequence generated from `(1, 3, 1, 2)`\n9. Check the sequence againt its RLE.\n10. Show, on this page, the first 30 members of the Kolakoski sequence generated from `(1, 3, 2, 1)`\n11. Check the sequence againt its RLE.\n\n(There are rules on generating Kolakoski sequences from this method that are broken by the last example)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.04.01\n\n```\nsub kolakoski (*@seed) {\n    my $k = @seed[0] == 1 ?? 1 !! 0;\n    my @k = flat @seed[0] == 1 ?? (1, @seed[1] xx @seed[1]) !! @seed[0] xx @seed[0],\n      { $k++; @seed[$k % @seed] xx @k[$k] } … *\n}\n\nsub rle (*@series) { @series.join.subst(/((.)$0*)/, -> { $0.chars }, :g).comb».Int }\n\n# Testing\nfor [1, 2], 20,\n    [2, 1], 20,\n    [1, 3, 1, 2], 30,\n    [1, 3, 2, 1], 30\n  -> @seed, $terms {\n    say \"\\n## $terms members of the series generated from { @seed.perl } is:\\n   \",\n    my @kolakoski = kolakoski(@seed)[^$terms];\n    my @rle = rle @kolakoski;\n    say \"   Looks like a Kolakoski sequence?: \", @rle[*] eqv @kolakoski[^@rle];\n}\n\n```\n\nOutput:\n\n```\n## 20 members of the series generated from [1, 2] is:\n   [1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 1 1 2 2 1]\n   Looks like a Kolakoski sequence?: True\n\n## 20 members of the series generated from [2, 1] is:\n   [2 2 1 1 2 1 2 2 1 2 2 1 1 2 1 1 2 2 1 2]\n   Looks like a Kolakoski sequence?: True\n\n## 30 members of the series generated from [1, 3, 1, 2] is:\n   [1 3 3 3 1 1 1 2 2 2 1 3 1 2 2 1 1 3 3 1 2 2 2 1 3 3 1 1 2 1]\n   Looks like a Kolakoski sequence?: True\n\n## 30 members of the series generated from [1, 3, 2, 1] is:\n   [1 3 3 3 2 2 2 1 1 1 1 1 3 3 2 2 1 1 3 2 1 1 1 1 3 3 3 2 2 1]\n   Looks like a Kolakoski sequence?: False\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Graph. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nKosaraju's algorithm (also known as the Kosaraju–Sharir algorithm) is a linear time algorithm to find the strongly connected components of a directed graph. Aho, Hopcroft and Ullman credit it to an unpublished paper from 1978 by S. Rao Kosaraju. The same algorithm was independently discovered by Micha Sharir and published by him in 1981. It makes use of the fact that the transpose graph (the same graph with the direction of every edge reversed) has exactly the same strongly connected components as the original graph.\n  \nFor this task consider the directed graph with these connections:\n\n```\n 0 -> 1\n 1 -> 2\n 2 -> 0\n 3 -> 1,  3 -> 2,  3 -> 4\n 4 -> 3,  4 -> 5\n 5 -> 2,  5 -> 6\n 6 -> 5\n 7 -> 4, 7  -> 6, 7 -> 7\n\n```\n\nAnd report the kosaraju strongly connected component for each node.\n\nReferences\n\n* The article on Wikipedia."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\nInspired by Python & Kotlin entries.\n\nAccepts a hash of lists/arrays holding the vertex (name => (neighbors)) pairs. No longer limited to continuous, positive, integer vertex names.\n\n```\nsub kosaraju (%k) {\n    my %g = %k.keys.sort Z=> flat ^%k;\n    my %h = %g.invert;\n    my %visited;\n    my @stack;\n    my @transpose;\n    my @connected;\n \n    sub visit ($u) {\n        unless %visited{$u} {\n            %visited{$u} = True;\n            for |%k{$u} -> $v {\n                visit($v);\n                @transpose[%g{$v}].push: $u;\n            }\n            @stack.push: $u;\n        }\n    }\n \n    sub assign ($u, $root) {\n        if %visited{$u} {\n            %visited{$u}   = False;\n            @connected[%g{$u}] = $root;\n            assign($_, $root) for |@transpose[%g{$u}];\n        }\n    }\n \n    .&visit for %g.keys;\n    assign($_, $_) for @stack.reverse;\n\n    (|%g{@connected}).pairs.categorize( *.value, :as(*.key) ).values.map: { %h{|$_} };\n}\n\n# TESTING\n\n-> $test { say \"\\nStrongly connected components: \", |kosaraju($test).sort } for\n\n# Same test data as all other entries, converted to a hash of lists\n(((1),(2),(0),(1,2,4),(3,5),(2,6),(5),(4,6,7)).pairs.hash),\n\n# Same layout test data with named vertices instead of numbered.\n(\n %(:Andy<Bart>,\n   :Bart<Carl>,\n   :Carl<Andy>,\n   :Dave<Bart Carl Earl>,\n   :Earl<Dave Fred>,\n   :Fred<Carl Gary>,\n   :Gary<Fred>,\n   :Hank<Earl Gary Hank>)\n)\n\n```\n\nOutput:\n\n```\nStrongly connected components: (0 1 2)(3 4)(5 6)(7)\n\nStrongly connected components: (Andy Bart Carl)(Dave Earl)(Fred Gary)(Hank)\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Kronecker product. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nImplement the   Kronecker product   of two matrices (arbitrary sized) resulting in a block matrix.\n\nTest cases\n\nShow results for each of the following two samples:\n\nSample 1 (from Wikipedia):\n\n```\n\n          ┌   ┐     ┌   ┐     ┌           ┐\n          │1 2│     │0 5│     │ 0  5  0 10│\n          │3 4│  x  │6 7│  =  │ 6  7 12 14│\n\t  └   ┘     └   ┘     │ 0 15  0 20│\n\t                      │18 21 24 28│\n                              └           ┘ \n\n```\n\nSample 2:\n\n```\n          ┌     ┐     ┌       ┐     ┌                       ┐       \n          │0 1 0│     │1 1 1 1│     │0 0 0 0 1 1 1 1 0 0 0 0│\n          │1 1 1│  x  │1 0 0 1│  =  │0 0 0 0 1 0 0 1 0 0 0 0│\n          │0 1 0│     │1 1 1 1│     │0 0 0 0 1 1 1 1 0 0 0 0│\n\t  └     ┘     └       ┘     │1 1 1 1 1 1 1 1 1 1 1 1│\n                                    │1 0 0 1 1 0 0 1 1 0 0 1│\n                                    │1 1 1 1 1 1 1 1 1 1 1 1│\n                                    │0 0 0 0 1 1 1 1 0 0 0 0│\n                                    │0 0 0 0 1 0 0 1 0 0 0 0│\n                                    │0 0 0 0 1 1 1 1 0 0 0 0│\n                                    └                       ┘\n\n```\n\nSee implementations and results below in JavaScript and PARI/GP languages.\n\nRelated task\n\n* Kronecker product based fractals."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2017.01-34-g700a077\n\n```\nsub kronecker_product ( @a, @b ) {\n    return (@a X @b).map: { .[0].list X* .[1].list };\n}\n\n.say for kronecker_product([ <1 2>, <3 4> ],\n                           [ <0 5>, <6 7> ]);\nsay '';\n.say for kronecker_product([ <0 1 0>,   <1 1 1>,   <0 1 0>  ],\n                           [ <1 1 1 1>, <1 0 0 1>, <1 1 1 1>]);\n\n```\n\nOutput:\n\n```\n(0 5 0 10)\n(6 7 12 14)\n(0 15 0 20)\n(18 21 24 28)\n\n(0 0 0 0 1 1 1 1 0 0 0 0)\n(0 0 0 0 1 0 0 1 0 0 0 0)\n(0 0 0 0 1 1 1 1 0 0 0 0)\n(1 1 1 1 1 1 1 1 1 1 1 1)\n(1 0 0 1 1 0 0 1 1 0 0 1)\n(1 1 1 1 1 1 1 1 1 1 1 1)\n(0 0 0 0 1 1 1 1 0 0 0 0)\n(0 0 0 0 1 0 0 1 0 0 0 0)\n(0 0 0 0 1 1 1 1 0 0 0 0)\n```"}]}
{"messages": [{"role": "user", "content": "This task is based on   Kronecker product   of two matrices.\n\nIf your language has no a built-in function for such product then you need to implement it first.\n\nThe essence of fractals is self-replication (at least, self-similar replications).\n\nSo, using   **n**   times self-product of the matrix   (filled with **0**/**1**)   we will have a fractal of the   **n**th   order.\n\nActually, \"self-product\" is a Kronecker power of the matrix.\n\nIn other words: for a matrix   **M**   and a power   **n**   create a function like   **matkronpow(M, n)**,\n  \nwhich returns   MxMxMx...   (**n**   times product).\n\nA formal recurrent *algorithm* of creating Kronecker power of a matrix is the following:\n\nAlgorithm\n\n* Let M is an initial matrix, and Rn is a resultant block matrix of the Kronecker power, where n is the power (a.k.a. order).\n* Self-product of M, i.e., M x M producing R2 (resultant matrix with order/power 2).\n* To receive the next order/power matrix use this recurrent formula: Rn = R(n-1) x M.\n* Plot this Rn matrix to produce the ***n**th* order fractal.\n\nEven just looking at the resultant matrix you can see what will be plotted.  \nThere are virtually infinitely many fractals of this type. You are limited only by your creativity and\nthe power of your computer.\n\nTask\n\nUsing Kronecker product implement and show two popular and well-known fractals, i.e.:\n\n* Vicsek fractal;\n* Sierpinski carpet fractal.\n\nThe last one ( Sierpinski carpet) is already here on RC, but built using different approaches.\n\nTest cases\n\nThese 2 fractals (each order/power 4 at least) should be built using the following 2 simple matrices:\n\n```\n          │ 0 1 0 │    and    │ 1 1 1 │\n          │ 1 1 1 │           │ 1 0 1 │\n          │ 0 1 0 │           │ 1 1 1 │\n\n```\n\nNote\n\n* Output could be a graphical or ASCII-art representation, but if an order is set > 4 then printing is not suitable.\n* The orientation and distortion of the fractal could be your language/tool specific.\n* It would be nice to see one additional fractal of your choice, e.g., based on using a single (double) letter(s) of an alphabet, any sign(s) or already made a resultant matrix of the Kronecker product.\n\nSee implementations and results below in JavaScript, PARI/GP and R languages. They have additional samples of \"H\", \"+\" and checkerboard fractals."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\n```\nsub kronecker-product ( @a, @b ) { (@a X @b).map: { (.[0].list X* .[1].list).Array } }\n\nsub kronecker-fractal ( @pattern, $order = 4 ) {\n    my @kronecker = @pattern;\n    @kronecker = kronecker-product(@kronecker, @pattern) for ^$order;\n    @kronecker\n}\n\nuse Image::PNG::Portable;\n\n#Task requirements\nmy @vicsek = ( [0, 1, 0], [1, 1, 1], [0, 1, 0] );\nmy @carpet = ( [1, 1, 1], [1, 0, 1], [1, 1, 1] );\nmy @six    = ( [0,1,1,1,0], [1,0,0,0,1], [1,0,0,0,0], [1,1,1,1,0], [1,0,0,0,1], [1,0,0,0,1], [0,1,1,1,0] );\n\nfor  'vicsek', @vicsek, 4,\n     'carpet', @carpet, 4,\n     'six',    @six,    3\n  -> $name,    @shape,  $order {\n    my @img = kronecker-fractal( @shape, $order );\n    my $png = Image::PNG::Portable.new: :width(@img[0].elems), :height(@img.elems);\n    (^@img[0]).race(:12batch).map: -> $x {\n        for ^@img -> $y {\n            $png.set: $x, $y, |( @img[$y;$x] ?? <255 255 32> !! <16 16 16> );\n        }\n    }\n    $png.write: \"kronecker-{$name}-perl6.png\";\n}\n\n```\n\nSee Kronecker-Vicsek, Kronecker-Carpet and Kronecker-Six images."}]}
{"messages": [{"role": "user", "content": "Introduction\n\nAn **L-system**, or Lindenmayer system, is a Turing-complete form of computaion, based in the parallel rewriting of symbols, usually provided and managed as strings. The name comes after Aristid Lindenmayer, a biologist who created it in order to simulate the growth of plants.\n\nAn L-system consists of:\n\n:   * An alphabet of symbols\n    * An initial string, known as the *axiom*\n    * A set of rewriting rules, in he form A → B, where A is a single symbol and B is a string. The B string can contain zero, one or multiple symbols, including A.\n\nComputation\n\nAt start, the *current* string is the axiom.\n\nOn each step of computation, every symbol Aₙ in the current string, having a rewriting rule Aₙ → Bₙ, is replaced by Bₙ. if the string Bₙ of the rule Aₙ → Bₙ contains the symbol Aₙ, the rule is not applied recursively. This is why this form of computation is called \"parallel\". Once the rewriting of symbols have been performed, the string was converted to another string, usually longer.\n\nAfter a defined number of steps, the string is the result of the computation.\n\nExample (rabbit population)\n\nAlphabet: { `I`, `M` } for immature and mature rabbit. Only a mature rabbit can procreate a bunny\n\nRules:\n\n:   * `I` → `M` (An immature rabbit will be a mature one in the next step)\n    * `M` → `MI` (A mature rabbit will procreate a bunny in the next step)\n\nAxiom: `I` (Let us start with a immature rabbit)\n\nComputation (5 steps):\n\n| Step | String | Notes |\n| --- | --- | --- |\n| 0 | `I` | the axiom |\n| 1 | `M` |  |\n| 2 | `MI` |  |\n| 3 | `MIM` |  |\n| 4 | `MIMMI` |  |\n| 5 | `MIMMIMIM` | the result |\n\nAs you can see, the number of rabbits (the string length) in each step corresponds to the Fibonacci numbers.\n\nInterpretation\n\nIt is common to make a further use of the resulting string. For example, symbols can represents musical notes, graphic operations, etc. In this sense, the string is like a program, and each symbol is a instruction of that program.\n\nWhen using graphic operations, sometimes specific symbols represent turtle graphics operations such as moving forward, moving forward and drawing, turning a certain angle, etc. Other symbols could represent push/pop operations in a stack data structure, in order to save the position/angle of the pen, to be retieved later.\n\nTask\n\nCreate a function, method, procedure, class, script, etc. (the solution) to compute the steps of a given L-system, and then, to perform the interpretation of the resulting string.\n\nThe inputs of the solution must be:\n\n:   * The axiom\n    * The rewritig rules, in a data structure natural to your language, it could be, for example, an array of pairs of strings (S, R) where S is the symbol and R is the :rewriting of the symbol\n    * The number of steps to perform\n    * The set of operations associated to each symbol of the resulting string, in a natural structure of your language, it could be, for example, an array of pairs (S, O) where S is a symbol and O is a structure that denotes delayed functionallity, such as anonymous functions, callbacks, pointers to functions, names of functions that can be invoked at run time with EVAL, lambda expressions, etc. (list is not exhaustive)\n\nIt is highly recommended for the solution to be absracted enought to let the inputs to be given separated from the solution, this is, the solution should be coded as its final place is inside a library which is invoked with specific values or parameters. It is not required for the solution to contain the necessary code be an actual library, it is enough that the code of the solution is separarted from the code of the invocation.\n\n**Accesing environment objects**. When interpretation produces graphical output, it is common to have objects that operations should access, such as graphic handlers, a stack, etc. A solution is to define the operations requestng such objects as parameters. Another (maybe better) option is to use closures.\n\nIf there already exists a library, package, etc. for your language to perform execution of L-systems, indicate the name of the library, how to get it, if it is open source, and examples of how to use it (see below).\n\nTest cases\n\nProvide one or more test cases of L-systems executed and interpreted by your solution.\n\nReferences\n\n:   * Wikipedia: L-system"}, {"role": "assistant", "content": "L-system functionality as a Role that may be mixed in to a scalar.\n\n```\n# L-system functionality \nrole Lindenmayer {\n    has %.rules;\n    method succ {\n        self.comb.map( { %!rules{$^c} // $c } ).join but Lindenmayer(%!rules)\n    }\n}\n\n# Testing\nmy $rabbits = 'I' but Lindenmayer({I => 'M', M => 'MI'});\n\n.say for $rabbits++ xx 6;\n\n```\n\nOutput:\n\n```\nI\nM\nMI\nMIM\nMIMMI\nMIMMIMIM\n```\n\nAlso see:  \nDragon\\_curve#Raku  \nHilbert\\_curve#Raku  \nKoch\\_curve#Raku  \nPeano\\_curve#Raku  \nPenrose\\_tiling#Raku  \nSierpinski\\_curve#Raku  \nSierpinski\\_arrowhead\\_curve#Raku  \nSierpinski\\_square\\_curve#Raku  \namong others..."}]}
{"messages": [{"role": "user", "content": "The task is to implement the Lagrange Interpolation formula and use it to solve the example problem to find a polynomial\nP of degree<4 satisfying P(1)=1 P(2)=4 P(3)=1 P(4)=5 as described at https://brilliant.org/wiki/lagrange-interpolation\nor https://en.wikipedia.org/wiki/Lagrange\\_polynomial\n\nRelated task Curve that touches three points"}, {"role": "assistant", "content": "**Translation of**: Wren\n\n```\n# 20231020 Raku programming solution\n\nclass Point { has Rat ($.x, $.y) }\n\nsub add(@p1, @p2) { return @p1 <<+>> @p2 } # Add two polynomials.\n\nsub multiply(@p1, @p2) { # Multiply two polynomials.\n   my @prod;\n   for ^+@p1 X ^+@p2 -> ($i, $j) { @prod[$i + $j] += @p1[$i] * @p2[$j] }\n   return @prod;\n}\n\n# Multiply a polynomial by a scalar.\nsub scalarMultiply(@poly, $x) { return @poly.map: * × $x }\n\n# Divide a polynomial by a scalar.\nsub scalarDivide(@poly, $x) { return scalarMultiply(@poly, 1/$x) }\n\n# rosettacode.org/wiki/Horner%27s_rule_for_polynomial_evaluation#Raku\nsub evalPoly(@coefs, $x) { return ([o] map { $_ + $x × * }, @coefs.reverse)(0) }\n\nsub lagrange(@pts) {\n   my ($c, @polys) = @pts.elems;\n   for ^$c -> $i {\n      my @poly = 1;\n      for ^$c -> $j {\n         next if $i == $j;\n         @poly = multiply @poly, [ -@pts[$j].x, 1 ]\n      }\n      @polys[$i] = scalarDivide @poly, evalPoly(@poly.reverse, @pts[$i].x) \n   }\n   my @sum = 0;\n   for ^$c -> $i { @sum = add @sum, scalarMultiply @polys[$i], @pts[$i].y }\n   return @sum;\n}\n\n\nmy @pts = map { Point.new: x=>.[0].Rat,y=>.[1].Rat }, [<1 1>,<2 4>,<3 1>,<4 5>];\n\nsay [~] lagrange(@pts).kv.rotor(2).reverse.map: -> ($expo, $coef) {\n   \"{ '+' if $coef ≥ 0 }$coef.nude.join('/') \" ~ do given $expo { \n      when 0  { \" \" }\n      when 1  { \"𝑥 \" }\n      default { \"𝑥^$_ \" }\n   }\n}\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Lah numbers, sometimes referred to as *Stirling numbers of the third kind*, are coefficients of polynomial expansions expressing rising factorials in terms of falling factorials.\n\nUnsigned Lah numbers count the number of ways a set of **n** elements can be partitioned into **k** non-empty linearly ordered subsets.\n\nLah numbers are closely related to Stirling numbers of the first & second kinds, and may be derived from them.\n\nLah numbers obey the identities and relations:\n\n```\n  L(n, 0), L(0, k) = 0   # for n, k > 0\n  L(n, n) = 1\n  L(n, 1) = n!\n  L(n, k) =           ( n! * (n - 1)! ) / ( k! * (k - 1)! ) / (n - k)!      # For unsigned Lah numbers\n     or\n  L(n, k) = (-1)**n * ( n! * (n - 1)! ) / ( k! * (k - 1)! ) / (n - k)!      # For   signed Lah numbers\n\n```\n\nTask\n:   * Write a routine (function, procedure, whatever) to find **unsigned Lah numbers**. There are several methods to generate unsigned Lah numbers. You are free to choose the most appropriate for your language. If your language has a built-in, or easily, publicly available library implementation, it is acceptable to use that.\n\n:   * Using the routine, generate and show here, on this page, a table (or triangle) showing the unsigned Lah numbers, **L(n, k)**, up to **L(12, 12)**. it is optional to show the row / column for n == 0 and k == 0. It is optional to show places where L(n, k) == 0 (when k > n).\n\n:   * If your language supports large integers, find and show here, on this page, the maximum value of **L(n, k)** where **n == 100**.\n\nSee also\n\n:   * **Wikipedia - Lah number**\n    * **OEIS:A105278 - Unsigned Lah numbers**\n    * **OEIS:A008297 - Signed Lah numbers**\n\nRelated Tasks\n\n:   * **Stirling numbers of the first kind**\n    * **Stirling numbers of the second kind**\n    * **Bell numbers**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\n```\nconstant @factorial = 1, |[\\*] 1..*;\n\nsub Lah (Int \\n, Int \\k) {\n    return @factorial[n] if k == 1;\n    return 1 if k == n;\n    return 0 if k > n;\n    return 0 if k < 1 or n < 1;\n    (@factorial[n] * @factorial[n - 1]) / (@factorial[k] * @factorial[k - 1]) / @factorial[n - k]\n}\n\nmy $upto = 12;\n\nmy $mx = (1..$upto).map( { Lah($upto, $_) } ).max.chars;\n\nput 'Unsigned Lah numbers:  L(n, k):';\nput 'n\\k', (0..$upto)».fmt: \"%{$mx}d\";\n\nfor 0..$upto -> $row {\n    $row.fmt('%-3d').print;\n    put (0..$row).map( { Lah($row, $_) } )».fmt: \"%{$mx}d\";\n}\n\nsay \"\\nMaximum value from the L(100, *) row:\";\nsay (^100).map( { Lah 100, $_ } ).max;\n\n```\n\nOutput:\n\n```\nUnsigned Lah numbers:  L(n, k):\nn\\k         0          1          2          3          4          5          6          7          8          9         10         11         12\n0           1\n1           0          1\n2           0          2          1\n3           0          6          6          1\n4           0         24         36         12          1\n5           0        120        240        120         20          1\n6           0        720       1800       1200        300         30          1\n7           0       5040      15120      12600       4200        630         42          1\n8           0      40320     141120     141120      58800      11760       1176         56          1\n9           0     362880    1451520    1693440     846720     211680      28224       2016         72          1\n10          0    3628800   16329600   21772800   12700800    3810240     635040      60480       3240         90          1\n11          0   39916800  199584000  299376000  199584000   69854400   13970880    1663200     118800       4950        110          1\n12          0  479001600 2634508800 4390848000 3293136000 1317254400  307359360   43908480    3920400     217800       7260        132          1\n\nMaximum value from the L(100, *) row:\n44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000\n```"}]}
{"messages": [{"role": "user", "content": "Langton's ant is a cellular automaton that models an ant sitting on a plane of cells, all of which are white initially, the ant facing in one of four directions.\n\nEach cell can either be black or white.\n\nThe ant moves according to the color of the cell it is currently sitting in, with the following rules:\n\n:   :   1. If the cell is black, it changes to white and the ant turns left;\n        2. If the cell is white, it changes to black and the ant turns right;\n        3. The ant then moves forward to the next cell, and repeat from step 1.\n\nThis rather simple ruleset leads to an initially chaotic movement pattern, and after about 10000 steps, a cycle appears where the ant moves steadily away from the starting location in a diagonal corridor about 10 cells wide.\nConceptually the ant can then walk infinitely far away.\n\nTask\n\nStart the ant near the center of a 100x100 field of cells, which is about big enough to contain the initial chaotic part of the movement.\n\nFollow the movement rules for the ant, terminate when it moves out of the region, and show the cell colors it leaves behind.\n\nThe problem has received some analysis; for more details, please take a look at the Wikipedia article   (a link is below)..\n\nSee also\n\n* Wikipedia:   Langton's ant.\n\nRelated task\n\n* Conway's Game of Life.\n* Elementary cellular automaton"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\nIn this version we use 4-bits-per-char graphics to shrink the output to a quarter the area of ASCII graphics.\n\n```\nconstant @vecs = [1,0,1], [0,-1,1], [-1,0,1], [0,1,1];\nconstant @blocky = ' ▘▝▀▖▌▞▛▗▚▐▜▄▙▟█'.comb;\nconstant $size = 100;\nenum Square <White Black>;\nmy @plane = [White xx $size] xx $size;\nmy ($x, $y) = $size/2, $size/2;\nmy $dir = @vecs.keys.pick;\nmy $moves = 0;\nloop {\n    given @plane[$x][$y] {\n        when :!defined { last }\n        when White { $dir--; $_ = Black; }\n        when Black { $dir++; $_ = White; }\n    }\n    ($x,$y,$moves) »+=« @vecs[$dir %= @vecs];\n}\nsay \"Out of bounds after $moves moves at ($x, $y)\";\nfor 0,2,4 ... $size - 2 -> $y {\n    say join '', gather for 0,2,4 ... $size - 2 -> $x {\n        take @blocky[ 1 * @plane[$x][$y]\n                    + 2 * @plane[$x][$y+1]\n                    + 4 * @plane[$x+1][$y]\n                    + 8 * @plane[$x+1][$y+1] ];\n    }\n}\n\n```\n\nOutput:\n\n```\nOut of bounds after 11669 moves at (-1, 26)\n            ▄▚▚                                   \n           ▟▟▜▟▚                                  \n           ▜▀▚▌▟▚                                 \n            ▜▘▗▌▟▚                                \n             ▜▘▗▌▟▚                               \n              ▜▘▗▌▟▚                              \n               ▜▘▗▌▟▚                             \n                ▜▘▗▌▟▚                            \n                 ▜▘▗▌▟▚                           \n                  ▜▘▗▌▟▚                          \n                   ▜▘▗▌▟▚                         \n                    ▜▘▗▌▟▚                        \n                     ▜▘▗▌▟▚                       \n                      ▜▘▗▌▟▚                      \n                       ▜▘▗▌▟▚                     \n                        ▜▘▗▌▟▚ ▄                  \n                         ▜▘▗▌▟▘▟▘▗                \n                      ▞▀▚ ▜▘▗▌▄▙▝▜                \n                     ▐█  ▌▄▘▘▗▗▞▐▚▌               \n                      ▌▖▝ ▐▚▙▙ ▖▀▖                \n                     ▐▄▝█▀▖▄▗▗▗▀▐▛▛▙              \n                    ▞▚▝▟██▜▞ ▞▗▜▌ ▞▘▌             \n                   ▐▗▄▌▙▜▐▄▛▀▜▞▜▛▛▄▐              \n                    ▘▗▝▜▚▖▌▟▞▛▜▌▜▖ █▌             \n                   ▄▄ ▄▜▛▜▙▖▟▗▛▟▘▌  ▌             \n                  ▟▖ ▘▘▄▛▌▛▟█▖ ▚▜▀  ▌             \n                  ▘▘ █▚▛▜▟▌▘▗█▞▛▞▌  ▌             \n                  ▐▖ ▙▐▙▗█▌▐▀  ▟▛ ▄ ▌             \n                  ▟▙▚▛▀▄▗▟▖▐▗▘▛▐▀▟▌ ▌             \n                  ▘▀▞▛▗▘▘█▐▞▗▗▝▟▖▄▝▝              \n                   ▗▜▞▖▗▘▝█▜▞▖▗▙ ▝ ▙▌             \n                  ▟▞▖▟▄▌▟▄▙▐█▗▟▙▟▚▗▞              \n                  ▘▌▚▖▝▛▀ ▐▘▞█▀▟▛█▖               \n               ▄ ▝▛▚ ▀▜▙▜▜▀▜▚▄▘▙▖                 \n              ▟▖▘▐▜▌▛▄▟▛▝▌ ▜▘▛▗▖▟▌                \n              ▘▀█▙▙▚▄▛▗▛▖ ▞▗▖▚▗▚▞                 \n               ▜ ▖▄▙▛▚▀▗▜▛ ▞▗▝▛                   \n               ▞▌▜▌█▀▀▘▖ ▙  ▌▀                    \n              ▐▗▌█▛    ▀▚▞▚▞                      \n               ▜▖                                 \n                                                  \n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show on this page the largest difference between adjacent primes under 1,000,000."}, {"role": "assistant", "content": "### Built-ins\n\n```\nfor 2..8 -> $n {\n    printf \"Largest prime gap up to {10 ** $n}: %d - between %d and %d.\\n\", .[0], |.[1]\n      given max (^10**$n).grep(&is-prime).rotor(2=>-1).map({.[1]-.[0],$_})\n}\n\n```\n\nOutput:\n\n```\nLargest prime gap up to 100: 8 - between 89 and 97.\nLargest prime gap up to 1000: 20 - between 887 and 907.\nLargest prime gap up to 10000: 36 - between 9551 and 9587.\nLargest prime gap up to 100000: 72 - between 31397 and 31469.\nLargest prime gap up to 1000000: 114 - between 492113 and 492227.\nLargest prime gap up to 10000000: 154 - between 4652353 and 4652507.\nLargest prime gap up to 100000000: 220 - between 47326693 and 47326913.\n```\n\nOr, significantly faster using a\n\n### Module\n\n```\nuse Math::Primesieve;\nmy $sieve = Math::Primesieve.new;\n\nfor 2..8 -> $n {\n    printf \"Largest prime gap up to {10 ** $n}: %d - between %d and %d.\\n\", .[0], |.[1]\n      given max $sieve.primes(10 ** $n).rotor(2=>-1).map({.[1]-.[0],$_})\n}\n\n```\n\nSame output"}]}
{"messages": [{"role": "user", "content": "Task\n\nGenerate **random** 1000-digit number.\n  \n Find the **five** adjacent digits in the 1000-digit number that form the largest 5-digit number.\n\nExtra credit\n\nFind the **five** adjacent digits in the 1000-digit number that form the smallest 5-digit number."}, {"role": "assistant", "content": "Show minimum too because... why not?\n\nUse some Tamil Unicode numbers for brevity, and for amusement purposes.\n\n```\n   ௰ - Tamil number ten\n   ௲ - Tamil number one thousand\n\n```\n\nDo it 5 times for variety, it's random after all.\n\n```\n(^௰).roll(௲).rotor(5 => -4)».join.minmax.bounds.put xx 5\n\n```\n\nSample output:\n\n```\n00371 99975\n00012 99982\n00008 99995\n00012 99945\n00127 99972\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a set of positive integers, write a function to order the integers in such a way that the concatenation of the numbers forms the largest possible integer and return this integer.\n\nUse the following two sets of integers as tests   and   show your program output here.\n\n:   :   :   :   :   * {1, 34, 3, 98, 9, 76, 45, 4}\n                    * {54, 546, 548, 60}\n\nPossible algorithms\n\n1. A solution could be found by trying all combinations and return the best.\n2. Another way to solve this is to note that in the best arrangement, for any two adjacent original integers **X** and **Y**, the concatenation **X** followed by **Y** will be numerically greater than or equal to the concatenation **Y** followed by **X.**\n3. Yet another way to solve this is to pad the integers to the same size by repeating the digits then sort using these repeated integers as a sort key.\n\nSee also\n\n* Algorithms: What is the most efficient way to arrange the given numbers to form the biggest number?\n* Constructing the largest number possible by rearranging a list"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub maxnum(*@x) {\n    [~] @x.sort: -> $a, $b { $b ~ $a leg $a ~ $b }\n}\n\nsay maxnum <1 34 3 98 9 76 45 4>;\nsay maxnum <54 546 548 60>;\n\n```\n\nOutput:\n\n```\n998764543431\n6054854654\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind the largest base 10 integer whose digits are all different,   and   is evenly divisible by each of its individual digits.\n\nThese numbers are also known as   **Lynch-Bell numbers**,   numbers   **n**   such that the\n(base ten) digits are all different (and do not include zero)   and   **n**   is divisible by each of its individual digits.\n\nExample\n\n**135**   is evenly divisible by   **1**,   **3**,   and   **5**.\n\nNote that the digit zero (0) can not be in the number as integer division by zero is undefined.\n\nThe digits must all be unique so a base ten number will have at most **9** digits.\n\nFeel free to use analytics and clever algorithms to reduce the search space your example needs to visit, but it must do an actual search. (Don't just feed it the answer and verify it is correct.)\n\nStretch goal\n\nDo the same thing for hexadecimal.\n\nRelated tasks\n:   * gapful numbers.\n    * palindromic gapful numbers.\n\nAlso see\n:   * The OEIS sequence:   A115569: Lynch-Bell numbers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.08\n\n### Base 10\n\nThe number can not have a zero in it, that implies that it can not have a 5 either since if it has a 5, it must be divisible by 5, but the only numbers divisible by 5 end in 5 or 0. It can't be zero, and if it is odd, it can't be divisible by 2, 4, 6 or 8. So that leaves 98764321 as possible digits the number can contain. The sum of those 8 digits is not divisible by three so the largest possible integer must use no more than 7 of them (since 3, 6 and 9 would be eliminated). Strictly by removing possibilities that cannot possibly work we are down to at most 7 digits.\n\nWe can deduce that the digit that won't get used is one of 1, 4, or 7 since those are the only ones where the removal will yield a sum divisible by 3. It is *extremely* unlikely be 1, since EVERY number is divisible by 1. Removing it reduces the number of digits available but doesn't gain anything as far as divisibility. It is unlikely to be 7 since 7 is prime and can't be made up of multiples of other numbers. Practically though, the code to accommodate these observations is longer running and more complex than just brute-forcing it from here.\n\nIn order to accommodate the most possible digits, the number must be divisible by 7, 8 and 9. If that is true then it is automatically divisible by 2, 3, 4, & 6 as they can all be made from the combinations of multiples of 2 and 3 which are present in 8 & 9; so we'll only bother to check multiples of 9 \\* 8 \\* 7 or 504.\n\nAll these optimizations get the run time to well under 1 second.\n\n```\nmy $magic-number = 9 * 8 * 7;                        # 504\n\nmy $div = 9876432 div $magic-number * $magic-number; # largest 7 digit multiple of 504 < 9876432\n\nfor $div, { $_ - $magic-number } ... * -> $test {    # only generate multiples of 504\n    next if $test ~~ / <[05]> /;                     # skip numbers containing 0 or 5\n    next if $test ~~ / (.).*$0 /;                    # skip numbers with non unique digits\n\n    say \"Found $test\";                               # Found a solution, display it\n    for $test.comb {\n        printf \"%s / %s = %s\\n\", $test, $_, $test / $_;\n    }\n    last\n}\n\n```\n\nOutput:\n\n```\nFound 9867312\n9867312 / 9 = 1096368\n9867312 / 8 = 1233414\n9867312 / 6 = 1644552\n9867312 / 7 = 1409616\n9867312 / 3 = 3289104\n9867312 / 1 = 9867312\n9867312 / 2 = 4933656\n```\n\n### Base 16\n\nThere are fewer analytical optimizations available for base 16. Other than 0, no digits can be ruled out so a much larger space must be searched. We'll start at the largest possible permutation (FEDCBA987654321) and work down so as soon as we find **a** solution, we know it is **the** solution. The combination of `.race` with `.first` lets us utilize concurrency and exit early when the single desired solution is found.\n\n```\nmy $hex = 'FEDCBA987654321';        # largest possible hex number\nmy $magic-number = [lcm] 1 .. 15;   # find least common multiple\nmy $div = :16($hex) div $magic-number * $magic-number;\n\n# hunt for target stepping backwards in multiples of the lcm\nmy $target = ($div, * - $magic-number ... 0).race.first: -> \\test {\n    my \\num= test.base(16);\n    (num.contains('0') || num.comb.Bag.values.max > 1) ?? False !! True\n};\nmy $hexnum = $target.base(16);\n\nsay \"Found $hexnum\"; # Found a solution, display it\n\nsay ' ' x 12, 'In base 16', ' ' x 36, 'In base 10';\nfor $hexnum.comb {\n    printf \"%s / %s = %s  |  %d / %2d = %19d\\n\",\n        $hexnum, $_, ($target / :16($_)).base(16),\n        $target, :16($_), $target / :16($_);}\n\n```\n\nOutput:\n\n```\nFound FEDCB59726A1348\n            In base 16                                    In base 10\nFEDCB59726A1348 / F = 10FDA5B4BE4F038  |  1147797065081426760 / 15 =   76519804338761784\nFEDCB59726A1348 / E = 1234561D150B83C  |  1147797065081426760 / 14 =   81985504648673340\nFEDCB59726A1348 / D = 139AD2E43E0C668  |  1147797065081426760 / 13 =   88292081929340520\nFEDCB59726A1348 / C = 153D0F21EDE2C46  |  1147797065081426760 / 12 =   95649755423452230\nFEDCB59726A1348 / B = 172B56538F25ED8  |  1147797065081426760 / 11 =  104345187734675160\nFEDCB59726A1348 / 5 = 32F8F11E3AED0A8  |  1147797065081426760 /  5 =  229559413016285352\nFEDCB59726A1348 / 9 = 1C5169829283B08  |  1147797065081426760 /  9 =  127533007231269640\nFEDCB59726A1348 / 7 = 2468AC3A2A17078  |  1147797065081426760 /  7 =  163971009297346680\nFEDCB59726A1348 / 2 = 7F6E5ACB93509A4  |  1147797065081426760 /  2 =  573898532540713380\nFEDCB59726A1348 / 6 = 2A7A1E43DBC588C  |  1147797065081426760 /  6 =  191299510846904460\nFEDCB59726A1348 / A = 197C788F1D76854  |  1147797065081426760 / 10 =  114779706508142676\nFEDCB59726A1348 / 1 = FEDCB59726A1348  |  1147797065081426760 /  1 = 1147797065081426760\nFEDCB59726A1348 / 3 = 54F43C87B78B118  |  1147797065081426760 /  3 =  382599021693808920\nFEDCB59726A1348 / 4 = 3FB72D65C9A84D2  |  1147797065081426760 /  4 =  286949266270356690\nFEDCB59726A1348 / 8 = 1FDB96B2E4D4269  |  1147797065081426760 /  8 =  143474633135178345\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nTask description is taken from Project Euler (https://projecteuler.net/problem=4)\n  \nA palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.\n  \nFind the largest palindrome made from the product of two 3-digit numbers.\n\nStretch Goal\n\nFind the largest palindrome made from the product of two n-digit numbers, where n ranges from 4 to 7.\n\nExtended Stretch Goal\n\nFind the largest palindrome made from the product of two n-digit numbers, where n ranges beyond 7,"}, {"role": "assistant", "content": "```\nuse Inline::Perl5;\nmy $p5 = Inline::Perl5.new();\n$p5.use: 'ntheory';\nmy &divisors = $p5.run('sub { ntheory::divisors $_[0] }');\n\n.say for (2..12).map: {.&lpp};\n\nmulti lpp ($oom where {!($_ +& 1)}) { # even number of multiplicand digits\n    my $f = +(9 x $oom);\n    my $o = $oom / 2;\n    my $pal = +(9 x $o ~ 0 x $oom ~ 9 x $o);\n    sprintf \"Largest palindromic product of two %2d-digit integers: %d × %d = %d\", $oom, $pal div $f, $f, $pal\n}\n\nmulti lpp ($oom where {$_ +& 1}) { # odd number of multiplicand digits\n    my $p;\n    (+(1 ~ (0 x ($oom - 1))) .. +(9 ~ (9 x ($oom - 1)))).reverse.map({ +($_ ~ .flip) }).map: -> $pal {\n        for my @factors = divisors(\"$pal\")».Int.grep({ .chars == $oom }).sort( -* ) {\n            next unless $pal div $_ ∈ @factors;\n            $p = sprintf(\"Largest palindromic product of two %2d-digit integers: %d × %d = %d\", $oom, $pal div $_, $_, $pal);\n            last;\n        }\n        last if $p;\n    }\n    $p\n}\n\n```\n\n```\nLargest palindromic product of two  2-digit integers: 91 × 99 = 9009\nLargest palindromic product of two  3-digit integers: 913 × 993 = 906609\nLargest palindromic product of two  4-digit integers: 9901 × 9999 = 99000099\nLargest palindromic product of two  5-digit integers: 99681 × 99979 = 9966006699\nLargest palindromic product of two  6-digit integers: 999001 × 999999 = 999000000999\nLargest palindromic product of two  7-digit integers: 9997647 × 9998017 = 99956644665999\nLargest palindromic product of two  8-digit integers: 99990001 × 99999999 = 9999000000009999\nLargest palindromic product of two  9-digit integers: 999920317 × 999980347 = 999900665566009999\nLargest palindromic product of two 10-digit integers: 9999900001 × 9999999999 = 99999000000000099999\nLargest palindromic product of two 11-digit integers: 99999943851 × 99999996349 = 9999994020000204999999\nLargest palindromic product of two 12-digit integers: 999999000001 × 999999999999 = 999999000000000000999999\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nThe task description is taken for Project Euler (https://projecteuler.net/problem=3)\n  \nWhat is the largest prime factor of the number 600851475143 ?"}, {"role": "assistant", "content": "Note: These are both extreme overkill for the task requirements.\n\n### Not particularly fast\n\nPure Raku. Using Prime::Factor from the Raku ecosystem. Makes it to 2^95 - 1 in 1 second on my system.\n\n```\nuse Prime::Factor;\n\nmy $start = now;\n\nfor flat 600851475143, (1..∞).map: { 2 +< $_ - 1 } {\n    say \"Largest prime factor of $_: \", max prime-factors $_;\n    last if now - $start > 1; # quit after one second of total run time\n}\n\n```\n\n```\nLargest prime factor of 600851475143: 6857\nLargest prime factor of 3: 3\nLargest prime factor of 7: 7\nLargest prime factor of 15: 5\nLargest prime factor of 31: 31\nLargest prime factor of 63: 7\nLargest prime factor of 127: 127\nLargest prime factor of 255: 17\nLargest prime factor of 511: 73\nLargest prime factor of 1023: 31\nLargest prime factor of 2047: 89\nLargest prime factor of 4095: 13\nLargest prime factor of 8191: 8191\nLargest prime factor of 16383: 127\nLargest prime factor of 32767: 151\nLargest prime factor of 65535: 257\nLargest prime factor of 131071: 131071\nLargest prime factor of 262143: 73\nLargest prime factor of 524287: 524287\nLargest prime factor of 1048575: 41\nLargest prime factor of 2097151: 337\nLargest prime factor of 4194303: 683\nLargest prime factor of 8388607: 178481\nLargest prime factor of 16777215: 241\nLargest prime factor of 33554431: 1801\nLargest prime factor of 67108863: 8191\nLargest prime factor of 134217727: 262657\nLargest prime factor of 268435455: 127\nLargest prime factor of 536870911: 2089\nLargest prime factor of 1073741823: 331\nLargest prime factor of 2147483647: 2147483647\nLargest prime factor of 4294967295: 65537\nLargest prime factor of 8589934591: 599479\nLargest prime factor of 17179869183: 131071\nLargest prime factor of 34359738367: 122921\nLargest prime factor of 68719476735: 109\nLargest prime factor of 137438953471: 616318177\nLargest prime factor of 274877906943: 524287\nLargest prime factor of 549755813887: 121369\nLargest prime factor of 1099511627775: 61681\nLargest prime factor of 2199023255551: 164511353\nLargest prime factor of 4398046511103: 5419\nLargest prime factor of 8796093022207: 2099863\nLargest prime factor of 17592186044415: 2113\nLargest prime factor of 35184372088831: 23311\nLargest prime factor of 70368744177663: 2796203\nLargest prime factor of 140737488355327: 13264529\nLargest prime factor of 281474976710655: 673\nLargest prime factor of 562949953421311: 4432676798593\nLargest prime factor of 1125899906842623: 4051\nLargest prime factor of 2251799813685247: 131071\nLargest prime factor of 4503599627370495: 8191\nLargest prime factor of 9007199254740991: 20394401\nLargest prime factor of 18014398509481983: 262657\nLargest prime factor of 36028797018963967: 201961\nLargest prime factor of 72057594037927935: 15790321\nLargest prime factor of 144115188075855871: 1212847\nLargest prime factor of 288230376151711743: 3033169\nLargest prime factor of 576460752303423487: 3203431780337\nLargest prime factor of 1152921504606846975: 1321\nLargest prime factor of 2305843009213693951: 2305843009213693951\nLargest prime factor of 4611686018427387903: 2147483647\nLargest prime factor of 9223372036854775807: 649657\nLargest prime factor of 18446744073709551615: 6700417\nLargest prime factor of 36893488147419103231: 145295143558111\nLargest prime factor of 73786976294838206463: 599479\nLargest prime factor of 147573952589676412927: 761838257287\nLargest prime factor of 295147905179352825855: 131071\nLargest prime factor of 590295810358705651711: 10052678938039\nLargest prime factor of 1180591620717411303423: 122921\nLargest prime factor of 2361183241434822606847: 212885833\nLargest prime factor of 4722366482869645213695: 38737\nLargest prime factor of 9444732965739290427391: 9361973132609\nLargest prime factor of 18889465931478580854783: 616318177\nLargest prime factor of 37778931862957161709567: 10567201\nLargest prime factor of 75557863725914323419135: 525313\nLargest prime factor of 151115727451828646838271: 581283643249112959\nLargest prime factor of 302231454903657293676543: 22366891\nLargest prime factor of 604462909807314587353087: 1113491139767\nLargest prime factor of 1208925819614629174706175: 4278255361\nLargest prime factor of 2417851639229258349412351: 97685839\nLargest prime factor of 4835703278458516698824703: 8831418697\nLargest prime factor of 9671406556917033397649407: 57912614113275649087721\nLargest prime factor of 19342813113834066795298815: 14449\nLargest prime factor of 38685626227668133590597631: 9520972806333758431\nLargest prime factor of 77371252455336267181195263: 2932031007403\nLargest prime factor of 154742504910672534362390527: 9857737155463\nLargest prime factor of 309485009821345068724781055: 2931542417\nLargest prime factor of 618970019642690137449562111: 618970019642690137449562111\nLargest prime factor of 1237940039285380274899124223: 18837001\nLargest prime factor of 2475880078570760549798248447: 23140471537\nLargest prime factor of 4951760157141521099596496895: 2796203\nLargest prime factor of 9903520314283042199192993791: 658812288653553079\nLargest prime factor of 19807040628566084398385987583: 165768537521\nLargest prime factor of 39614081257132168796771975167: 30327152671\n```\n\n### Particularly fast\n\nUsing Perl 5 ntheory library via Inline::Perl5. Makes it to about 2^155 - 1 in 1 second on my system. *Varies from 2^145-1 (lowest seen) to 2^168-1 (highest seen).*\n\n```\nuse Inline::Perl5;\nmy $p5 = Inline::Perl5.new();\n$p5.use: 'ntheory';\nmy &lpf = $p5.run('sub { ntheory::todigitstring ntheory::vecmax ntheory::factor $_[0] }');\n\nmy $start = now;\n\nfor flat 600851475143, (1..∞).map: { 2 +< $_ - 1 } {\n    say \"Largest prime factor of $_: \", lpf \"$_\";\n    last if now - $start > 1; # quit after one second of total run time\n}\n\n```\n\nSame output only much longer."}]}
{"messages": [{"role": "user", "content": "Task\n\nThe task description is taken from Project Euler:\n  \n(https://projecteuler.net/problem=11)\n  \n  \nGiven the 20×20 grid below:\n\n08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08\n  \n49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00\n  \n81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65\n  \n52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91\n  \n22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80\n  \n24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50\n  \n32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70\n  \n67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21\n  \n24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72\n  \n21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95\n  \n78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92\n  \n16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57\n  \n86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58\n  \n19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40\n  \n04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66\n  \n88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69\n  \n04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36\n  \n20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16\n  \n20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54\n  \n01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48\n  \n  \nWhat is the greatest product of four adjacent numbers in the same direction (down, right) in the 20×20 grid?"}, {"role": "assistant", "content": "General solution. No hard coded values. Works with any size matrix, configurable number of terms.\n\n```\nmy @matrix = q:to/END/.lines».words;\n  08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08\n  49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00\n  81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65\n  52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91\n  22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80\n  24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50\n  32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70\n  67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21\n  24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72\n  21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95\n  78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92\n  16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57\n  86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58\n  19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40\n  04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66\n  88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69\n  04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36\n  20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16\n  20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54\n  01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 \nEND\n\nmy $terms = 4;\n\nsay \"Largest product of $terms adjacent elements: \" ~ max flat (^@matrix).map: {\n    @matrix.rotor($terms => -$terms+1).flat»[$_].batch($terms)».reduce(&[*]), # vertical\n    @matrix[$_].rotor($terms => -$terms+1)».reduce(&[*]);                     # horizontal\n}\n\n```\n\nOutput:\n\n```\nLargest product of 4 adjacent elements: 51267216\n```"}]}
{"messages": [{"role": "user", "content": "Task\n:   a(1) = 1; for n > 1, a(n) = **largest** proper divisor of n, where **n < 101** ."}, {"role": "assistant", "content": "A little odd to special case a(1) == 1 as technically, 1 doesn't have any proper divisors... but it matches **OEIS A032742** so whatever.\n\nNote: this example is ridiculously overpowered (and so, somewhat inefficient) for a range of 1 to 100, but will easily handle large numbers without modification.\n\n```\nuse Prime::Factor;\n\nfor 0, 2**67 - 1 -> $add {\n    my $start = now;\n\n    my $range = $add + 1 .. $add + 100;\n\n    say \"GPD for {$range.min} through {$range.max}:\";\n\n    say ( $range.hyper(:14batch).map: {$_ == 1 ?? 1 !! $_ %% 2 ?? $_ / 2 !! .&proper-divisors.max} )\\\n        .batch(10)».fmt(\"%{$add.chars + 1}d\").join: \"\\n\";\n\n    say (now - $start).fmt(\"%0.3f seconds\\n\");\n}\n\n```\n\nOutput:\n\n```\nGPD for 1 through 100:\n 1  1  1  2  1  3  1  4  3  5\n 1  6  1  7  5  8  1  9  1 10\n 7 11  1 12  5 13  9 14  1 15\n 1 16 11 17  7 18  1 19 13 20\n 1 21  1 22 15 23  1 24  7 25\n17 26  1 27 11 28 19 29  1 30\n 1 31 21 32 13 33  1 34 23 35\n 1 36  1 37 25 38 11 39  1 40\n27 41  1 42 17 43 29 44  1 45\n13 46 31 47 19 48  1 49 33 50\n0.071 seconds\n\nGPD for 147573952589676412928 through 147573952589676413027:\n  73786976294838206464   49191317529892137643   73786976294838206465                      1   73786976294838206466   21081993227096630419   73786976294838206467   49191317529892137645   73786976294838206468    8680820740569200761\n  73786976294838206469    5088756985850910791   73786976294838206470   49191317529892137647   73786976294838206471   13415813871788764813   73786976294838206472   29514790517935282589   73786976294838206473   49191317529892137649\n  73786976294838206474    6416258808246800563   73786976294838206475     977310944302492801   73786976294838206476   49191317529892137651   73786976294838206477   29514790517935282591   73786976294838206478      87167130885810049\n  73786976294838206479   49191317529892137653   73786976294838206480   21081993227096630423   73786976294838206481    7767050136298758577   73786976294838206482   49191317529892137655   73786976294838206483    2784414199805215339\n  73786976294838206484   11351842506898185613   73786976294838206485   49191317529892137657   73786976294838206486     939961481462907089   73786976294838206487   29514790517935282595   73786976294838206488   49191317529892137659\n  73786976294838206489      82581954443019817   73786976294838206490        147258377885867   73786976294838206491   49191317529892137661   73786976294838206492   29514790517935282597   73786976294838206493   13415813871788764817\n  73786976294838206494   49191317529892137663   73786976294838206495                      1   73786976294838206496    2202596307308603179   73786976294838206497   49191317529892137665   73786976294838206498    5088756985850910793\n  73786976294838206499                      1   73786976294838206500   49191317529892137667   73786976294838206501   21081993227096630429   73786976294838206502   29514790517935282601   73786976294838206503   49191317529892137669\n  73786976294838206504   13415813871788764819   73786976294838206505     103270785577100359   73786976294838206506   49191317529892137671   73786976294838206507   29514790517935282603   73786976294838206508   21081993227096630431\n  73786976294838206509   49191317529892137673   73786976294838206510   11351842506898185617   73786976294838206511                      1   73786976294838206512   49191317529892137675   73786976294838206513    1305964182209525779\n0.440 seconds\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program or a script that returns the date of the last Fridays of each month of a given year.\n\nThe year may be given through any simple input method in your language (command line, std in, etc).\n\nExample of an expected output:\n\n```\n./last_fridays 2012\n2012-01-27\n2012-02-24\n2012-03-30\n2012-04-27\n2012-05-25\n2012-06-29\n2012-07-27\n2012-08-31\n2012-09-28\n2012-10-26\n2012-11-30\n2012-12-28\n\n```\n\nRelated tasks\n\n* Five weekends\n* Day of the week\n* Find the last Sunday of each month"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub MAIN (Int $year = Date.today.year) {\n    my @fri;\n    for Date.new(\"$year-01-01\") .. Date.new(\"$year-12-31\") {\n        @fri[.month] = .Str if .day-of-week == 5;\n    }\n    .say for @fri[1..12];\n}\n\n```\n\nExample:\n\n```\n$ ./lastfri 2038\n2038-01-29\n2038-02-26\n2038-03-26\n2038-04-30\n2038-05-28\n2038-06-25\n2038-07-30\n2038-08-27\n2038-09-24\n2038-10-29\n2038-11-26\n2038-12-31\n```\n\nA solution without a result array to store things in:\n\n```\nsub MAIN (Int $year = Date.today.year) {\n    say ~.value.reverse.first: *.day-of-week == 5\n        for classify *.month, Date.new(\"$year-01-01\") .. Date.new(\"$year-12-31\");\n}\n\n```\n\nHere, `classify` sorts the dates into one bin per month (but preserves the order in each bin). We then take the list inside each bin (`.value`) and find the last (`.reverse.first`) date which is a Friday.\n\nAnother variation where the data flow can be read left to right using feed operators:\n\n```\nsub MAIN (Int $year = Date.today.year) {\n    .say for Date.new(\"$year-01-01\") .. Date.new(\"$year-12-31\") ==> classify *.month ==>\n             map *.value.reverse.first: *.day-of-week == 5\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "A certain children's game involves starting with a word in a particular category.   Each participant in turn says a word, but that word must begin with the final letter of the previous word.   Once a word has been given, it cannot be repeated.   If an opponent cannot give a word in the category, they fall out of the game.\n\nFor example, with   \"animals\"   as the category,\n\n```\nChild 1: dog \nChild 2: goldfish\nChild 1: hippopotamus\nChild 2: snake\n...\n\n```\n\nTask\n\nTake the following selection of 70 English Pokemon names   (extracted from   Wikipedia's list of Pokemon)   and generate the/a sequence with the highest possible number of Pokemon names where the subsequent name starts with the final letter of the preceding name.\n\nNo Pokemon name is to be repeated.\n\n```\naudino bagon baltoy banette bidoof braviary bronzor carracosta charmeleon\ncresselia croagunk darmanitan deino emboar emolga exeggcute gabite\ngirafarig gulpin haxorus heatmor heatran ivysaur jellicent jumpluff kangaskhan\nkricketune landorus ledyba loudred lumineon lunatone machamp magnezone mamoswine\nnosepass petilil pidgeotto pikachu pinsir poliwrath poochyena porygon2\nporygonz registeel relicanth remoraid rufflet sableye scolipede scrafty seaking\nsealeo silcoon simisear snivy snorlax spoink starly tirtouga trapinch treecko\ntyrogue vigoroth vulpix wailord wartortle whismur wingull yamask\n\n```\n\nExtra brownie points for dealing with the full list of   646   names."}, {"role": "assistant", "content": "(formerly Perl 6)\nA breadth-first search that uses disk files to avoid memory exhaustion. Each candidate sequence is encoded at one character per name, so to avoid reuse of names we merely have to make sure there are no repeat characters in our encoded string. (The encoding starts at ASCII space for the first name, so newline is not among the encoded characters.)\n\n```\nmy @names = <\n    audino bagon baltoy banette bidoof braviary bronzor carracosta charmeleon\n    cresselia croagunk darmanitan deino emboar emolga exeggcute gabite\n    girafarig gulpin haxorus heatmor heatran ivysaur jellicent jumpluff kangaskhan\n    kricketune landorus ledyba loudred lumineon lunatone machamp magnezone mamoswine\n    nosepass petilil pidgeotto pikachu pinsir poliwrath poochyena porygon2\n    porygonz registeel relicanth remoraid rufflet sableye scolipede scrafty seaking\n    sealeo silcoon simisear snivy snorlax spoink starly tirtouga trapinch treecko\n    tyrogue vigoroth vulpix wailord wartortle whismur wingull yamask\n>;\n\nmy @last = @names.map: {.substr(*-1,1).ord }\nmy @succs = [] xx 128;\nfor @names.kv -> $i, $name {\n    my $ix = $name.ord; # $name.substr(0,1).ord\n    push @succs[$ix], $i;\n}\n\nmy $OUT = open \"llfl.new\", :w orelse .die;\n$OUT.print: chr($_ + 32),\"\\n\" for 0 ..^ @names;\nclose $OUT;\nmy $new = +@names;\nmy $len = 1;\n\nwhile $new {\n    say \"Length { $len++ }: $new candidates\";\n    shell 'mv llfl.new llfl.known';\n    my $IN = open \"llfl.known\" orelse .die;\n    my $OUT = open \"llfl.new\", :w orelse .die;\n    $new = 0;\n\n    loop {\n\tmy $cand = $IN.get // last;\n\tfor @succs[@last[$cand.ord - 32]][] -> $i {\n\t    my $ic = chr($i + 32);\n\t    next if $cand ~~ /$ic/;\n\t    $OUT.print: $ic,$cand,\"\\n\";\n\t    $new++;\n\t}\n    }\n    $IN.close;\n    $OUT.close;\n}\n\nmy $IN = open \"llfl.known\" orelse .die;\nmy $eg = $IN.lines.pick;\nsay \"Length of longest: \", $eg.chars;\nsay join ' ', $eg.ords.reverse.map: { @names[$_ - 32] }\n\n```\n\nOutput:\n\n```\nLength 1: 70 candidates\nLength 2: 172 candidates\nLength 3: 494 candidates\nLength 4: 1288 candidates\nLength 5: 3235 candidates\nLength 6: 7731 candidates\nLength 7: 17628 candidates\nLength 8: 37629 candidates\nLength 9: 75122 candidates\nLength 10: 139091 candidates\nLength 11: 236679 candidates\nLength 12: 367405 candidates\nLength 13: 516210 candidates\nLength 14: 650916 candidates\nLength 15: 733915 candidates\nLength 16: 727566 candidates\nLength 17: 621835 candidates\nLength 18: 446666 candidates\nLength 19: 260862 candidates\nLength 20: 119908 candidates\nLength 21: 40296 candidates\nLength 22: 10112 candidates\nLength 23: 1248 candidates\nLength of longest: 23\nmachamp petilil loudred darmanitan nosepass simisear rufflet trapinch heatmor registeel landorus starly yamask kricketune exeggcute emboar relicanth haxorus seaking girafarig gabite emolga audino\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nList = [6, 81, 243, 14, 25, 49, 123, 69, 11]\n  \nFind the two smallest items, remove them from the list, find their sum, and add the sum to the end of list.\n  \nRepeat until the list contains one element.\n  \nShow the steps and last item on this page.\n  \nShow the unsorted list in output in case \"Without sort\""}, {"role": "assistant", "content": "Uses no sorting; does not modify overall list order while processing.\n\n```\nsay ' Original ', my @list = 6, 81, 243, 14, 25, 49, 123, 69, 11;\n\nsay push @list: get(min @list) + get(min @list) while @list > 1;\n\nsub get ($min) {\n    @list.splice: @list.first(* == $min, :k), 1;\n    printf \" %3d \", $min;\n    $min;\n}\n\n```\n\nOutput:\n\n```\n Original [6 81 243 14 25 49 123 69 11]\n   6   11 [81 243 14 25 49 123 69 17]\n  14   17 [81 243 25 49 123 69 31]\n  25   31 [81 243 49 123 69 56]\n  49   56 [81 243 123 69 105]\n  69   81 [243 123 105 150]\n 105  123 [243 150 228]\n 150  228 [243 378]\n 243  378 [621]\n\n```"}]}
{"messages": [{"role": "user", "content": "A Latin Square is in its reduced form if the first row and first column contain items in their natural order. The order n is the number of items. For any given n there is a set of reduced Latin Squares whose size increases rapidly with n. g is a number which identifies a unique element within the set of reduced Latin Squares of order n. The objective of this task is to construct the set of all Latin Squares of a given order and to provide a means which given suitable values for g any element within the set may be obtained.\n\nFor a reduced Latin Square the first row is always 1 to n. The second row is all Permutations/Derangements of 1 to n starting with 2. The third row is all Permutations/Derangements of 1 to n starting with 3 which do not clash (do not have the same item in any column) with row 2. The fourth row is all Permutations/Derangements of 1 to n starting with 4 which do not clash with rows 2 or 3. Likewise continuing to the nth row.\n\nDemonstrate by:\n\n* displaying the four reduced Latin Squares of order 4.\n* for n = 1 to 6 (or more) produce the set of reduced Latin Squares; produce a table which shows the size of the set of reduced Latin Squares and compares this value times n! times (n-1)! with the values in OEIS A002860."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# utilities: factorial, sub-factorial, derangements\nsub  postfix:<!>($n) { (constant f = 1, |[\\×] 1..*)[$n] }\nsub   prefix:<!>($n) { (1, 0, 1, -> $a, $b { ($++ + 2) × ($b + $a) } ... *)[$n] }\nsub derangements(@l) { @l.permutations.grep(-> @p { none(@p Zeqv @l) }) }\n\nsub LS-reduced (Int $n) {\n    return [1] if $n == 1;\n\n    my @LS;\n    my @l = 1 X+ ^$n;\n    my %D = derangements(@l).classify(*.[0]);\n\n    for [X] (^(!$n/($n-1))) xx $n-1 -> $tuple {\n        my @d.push: @l;\n        @d.push: %D{2}[$tuple[0]];\n        LOOP:\n        for 3 .. $n -> $x {\n            my @try = |%D{$x}[$tuple[$x-2]];\n            last LOOP if any @try »==« @d[$_] for 1..@d-1;\n            @d.push: @try;\n        }\n        next unless @d == $n and [==] [Z+] @d;\n        @LS.push: @d;\n    }\n    @LS\n}\n\nsay .join(\"\\n\") ~ \"\\n\" for LS-reduced(4);\nfor 1..6 -> $n {\n    printf \"Order $n: Size %-4d x $n! x {$n-1}! => Total %d\\n\", $_, $_ * $n! * ($n-1)! given LS-reduced($n).elems\n}\n\n```\n\nOutput:\n\n```\n1 2 3 4\n2 1 4 3\n3 4 1 2\n4 3 2 1\n\n1 2 3 4\n2 1 4 3\n3 4 2 1\n4 3 1 2\n\n1 2 3 4\n2 3 4 1\n3 4 1 2\n4 1 2 3\n\n1 2 3 4\n2 4 1 3\n3 1 4 2\n4 3 2 1\n\nOrder 1: Size 1    x 1! x 0! => Total 1\nOrder 2: Size 1    x 2! x 1! => Total 2\nOrder 3: Size 1    x 3! x 2! => Total 12\nOrder 4: Size 4    x 4! x 3! => Total 576\nOrder 5: Size 56   x 5! x 4! => Total 161280\nOrder 6: Size 9408 x 6! x 5! => Total 812851200\n```"}]}
{"messages": [{"role": "user", "content": "Section 3.3 of [Generalised 2-designs with Block Size 3(Andy L. Drizen)] describes a method of generating Latin Squares of order n attributed to Jacobson and Matthews. The purpose of this task is to produce a function which given a valid Latin Square transforms it to another using this method.\n\npart 1\n\nUse one of the 4 Latin Squares in reduced form of order 4 as X0 to generate 10000 Latin Squares using X(n-1) to generate X(n). Convert the resulting Latin Squares to their reduced form, display them and the number of times each is produced.\n\npart 2\n\nAs above for order 5, but do not display the squares. Generate the 56 Latin Squares in reduced form of order 5, confirm that all 56 are produced by the Jacobson and Matthews technique and display the number of each produced.\n\npart 3\n\nGenerate 750 Latin Squares of order 42 and display the 750th.\n\npart 4\n\nGenerate 1000 Latin Squares of order 256. Don't display anything but confirm the approximate time taken and anything else you may find interesting"}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20210729 Raku programming solution \n\n#!/usr/bin/env raku\n\nsub makeCube(\\from, Int \\n) {  \n   my @c = [[[ 0 xx n ] xx n ] xx n ]; \n   from.Bool ?? do race for ^n X ^n -> (\\i,\\j) { @c[i;j; { from[i;j]-1 } ] = 1 }\n             !! do race for ^n X ^n -> (\\i,\\j) { @c[i;j; {   (i+j)%n   } ] = 1 }\n   return @c                   \n}\n\nsub shuffleCube(@c) {\n   my ($rx, $ry, $rz); my \\n = +@c; my Bool \\proper = $ = True;\n\n   repeat { ($rx ,$ry, $rz) = (^n).roll: 3 } until @c[$rx;$ry;$rz] == 0;\n   loop { \n      my ($ox, $oy, $oz); \n      for ^n { last if @c[ $ox = $_ ;$ry;$rz] == 1 }\n      if !proper and (^3).roll==0 { \n         for $ox^…^n { last if @c[ $ox = $_ ;$ry;$rz] == 1 } \n      }\n      for ^n { last if @c[$rx; $oy = $_ ;$rz] == 1 }\n      if !proper and (^3).roll==0 {\n         for $oy^…^n { last if @c[$rx; $oy = $_ ;$rz] == 1 }\n      } \n      for ^n { last if @c[$rx;$ry;  $oz = $_ ] == 1 }\n      if !proper and (^3).roll==0 {\n         for $oz^…^n { last if @c[$rx;$ry; $oz = $_ ] == 1 }\n      }\n\n      (@c[$rx;$ry;$rz],@c[$rx;$oy;$oz],@c[$ox;$ry;$oz],@c[$ox;$oy;$rz]) »+=»1;\n      (@c[$rx;$ry;$oz],@c[$rx;$oy;$rz],@c[$ox;$ry;$rz],@c[$ox;$oy;$oz]) »-=»1; \n      \n      @c[$ox;$oy;$oz] < 0 ?? (($rx,$ry,$rz) = ($ox,$oy,$oz)) !! last ;\n      proper = False \n   }        \n}\n\nsub toMatrix(@c) {\n   my \\n = +@c;  \n   my @m = [[0 xx n] xx n]; \n   for ^n X ^n -> (\\i,\\j) { \n      for ^n -> \\k { if @c[i;j;k] != 0 { @m[i;j] = k and last } }\n   }\n   return @m\n}\n\nsub toReduced(@m is copy) { \n   my \\n = +@m; \n   for 0…(n-2) -> \\j {\n      if ( @m[0;j] != j ) { \n         for j^…^n -> \\k {\n            if ( @m[0;k] == j ) { \n               for 0…^n -> \\i { (@m[i;j], @m[i;k]) = (@m[i;k], @m[i;j]) }\n               last \n            } \n         } \n      } \n   }   \n   for 1…(n-2) -> \\i {\n      if ( @m[i;0] != i ) {\n         for i^…^n -> \\k { \n            if ( @m[k;0] == i ) { \n               for 0…^n -> \\j { (@m[i;j], @m[k;j]) = (@m[k;j], @m[i;j]) }     \n               last      \n            }\n         }\n      } \n   } \n   return @m\n}\n\nsub printAs1based { say ($_ »+» 1).Str for @_.rotor: @_.elems.sqrt }\n\nmy (%freq, @c, @in);\n\nsay \"Part 1: 10,000 latin Squares of order 4 in reduced form:\\n\";\n@in = [[1, 2, 3, 4], [2, 1, 4, 3], [3, 4, 1, 2], [4, 3, 2, 1]];\n@c = makeCube(@in, 4); \nfor ^10_000 {\n   shuffleCube @c ; \n   %freq{@c.&toMatrix.&toReduced».List.flat.Str}++\n}    \nfor %freq.kv -> $k, $v { \n   printAs1based $k.split(' ');   \n   say \"\\nOccurs $v times.\\n\"\n}\n\nsay \"Part 2: 10,000 latin Squares of order 5 in reduced form:\\n\";\n@in = [ [1,2,3,4,5], [2,3,4,5,1], [3,4,5,1,2], [4,5,1,2,3], [5,1,2,3,4] ];\n%freq = ();\n@c = makeCube(@in, 5);\nfor ^10_000 { \n   shuffleCube @c ; \n   %freq{@c.&toMatrix.&toReduced».List.flat.Str}++ \n}\nfor %freq.values.kv -> $i, $j { printf \"%2d(%3d)%s\", $i+1, $j, ' ' }\n\nsay \"\\n\\nPart 3: 750 latin squares of order 42, showing the last one:\\n\";\n@c = makeCube([], 42); # (1..42).pick(*)\n( for ^750 { shuffleCube @c } ) and printAs1based @c.&toMatrix».List.flat ;\n\nsay \"\\nPart 4: 100 latin squares of order 256:\\n\";\nmy $snapshot = now;\n@c = makeCube([], 256);\nfor ^100 { shuffleCube @c } # without hyper, will do only 100 cycles \nsay \"Generated in { now - $snapshot } seconds.\"\n\n```\n\nOutput:\n\n```\nPart 1: 10,000 latin Squares of order 4 in reduced form:\n\n1 2 3 4\n2 1 4 3\n3 4 1 2\n4 3 2 1\n\nOccurs 2442 times.\n\n1 2 3 4\n2 4 1 3\n3 1 4 2\n4 3 2 1\n\nOccurs 2705 times.\n\n1 2 3 4\n2 3 4 1\n3 4 1 2\n4 1 2 3\n\nOccurs 2548 times.\n\n1 2 3 4\n2 1 4 3\n3 4 2 1\n4 3 1 2\n\nOccurs 2305 times.\n\nPart 2: 10,000 latin Squares of order 5 in reduced form:\n\n 1(210)  2(191)  3(186)  4(158)  5(219)  6(164)  7(147)  8(160)  9(196) 10(188) 11(193) 12(168) 13(195) 14(173) 15(151) 16(184) 17(211) 18(171) 19(185) 20(155) 21(157) 22(191) 23(195) 24(177) 25(157) 26(191) 27(165) 28(178) 29(191) 30(180) 31(193) 32(176) 33(196) 34(178) 35(156) 36(168) 37(155) 38(152) 39(155) 40(223) 41(159) 42(165) 43(210) 44(175) 45(195) 46(188) 47(178) 48(154) 49(172) 50(176) 51(178) 52(164) 53(175) 54(196) 55(187) 56(189) \n\nPart 3: 750 latin squares of order 42, showing the last one:\n\n26 27 4 41 31 10 28 13 3 29 21 42 14 39 19 8 5 7 6 40 17 37 35 33 1 38 22 34 18 11 12 2 32 36 9 24 25 23 16 15 30 20\n16 40 6 11 22 14 41 42 20 7 24 8 29 27 28 4 26 19 21 39 37 9 2 32 36 15 12 13 38 5 31 33 34 3 17 1 23 35 30 18 10 25\n31 15 11 3 5 22 13 10 14 24 41 18 6 16 17 29 36 37 12 28 23 39 34 8 27 40 4 35 7 19 32 26 21 1 2 33 20 9 38 30 25 42\n13 37 31 38 42 9 11 2 10 36 22 34 18 23 12 39 25 20 19 26 8 41 16 6 21 32 5 4 33 17 40 24 30 29 27 3 28 14 1 7 35 15\n41 7 17 28 24 12 29 8 31 22 1 3 11 42 23 26 39 13 25 19 36 18 33 37 6 5 20 15 2 16 14 4 27 35 38 10 30 32 9 21 34 40\n5 19 12 32 20 30 6 33 17 16 27 13 8 9 2 37 21 18 39 4 7 40 1 15 3 35 11 24 10 31 36 23 29 41 22 25 26 28 34 14 42 38\n11 14 20 5 3 32 19 27 42 18 12 41 34 6 24 21 38 26 10 35 33 28 9 22 23 39 17 40 31 15 30 37 16 2 36 4 8 1 13 25 29 7\n20 6 22 16 34 26 33 23 2 11 29 7 4 13 21 42 9 24 14 41 15 31 5 3 25 18 19 30 1 10 37 36 17 12 39 27 40 38 28 32 8 35\n4 25 32 8 28 17 40 19 22 15 23 2 35 5 34 16 18 39 38 24 30 13 41 1 20 3 36 33 42 12 26 29 10 31 6 21 14 37 7 9 11 27\n21 2 35 39 26 28 36 16 7 37 19 32 33 1 38 27 4 8 23 6 5 34 40 30 29 42 14 10 9 22 11 12 25 15 13 31 17 18 41 24 20 3\n30 28 3 12 6 8 31 32 40 42 25 38 9 33 16 14 13 27 26 17 4 19 20 24 15 36 37 18 11 23 10 22 1 39 21 5 34 41 2 35 7 29\n8 34 26 6 16 33 15 28 41 38 40 24 30 21 22 17 20 35 32 23 42 25 11 5 12 1 31 2 13 3 39 27 14 9 18 7 19 29 36 4 37 10\n1 22 2 7 39 23 14 18 11 30 15 17 26 10 6 28 16 12 24 31 35 36 37 21 40 29 13 8 3 41 34 38 4 32 25 42 5 27 20 19 33 9\n25 32 1 9 35 6 42 34 37 10 13 20 5 19 30 41 17 36 7 15 40 38 26 31 2 23 18 28 24 33 21 11 22 4 14 39 27 8 3 29 16 12\n17 12 18 30 11 4 10 5 28 8 33 31 19 22 36 13 6 9 34 42 29 1 27 39 38 21 25 23 26 24 7 15 2 16 41 14 32 40 35 20 3 37\n27 36 39 37 18 13 34 14 19 5 32 26 38 12 3 23 1 30 17 11 6 35 21 16 24 41 7 9 28 20 2 31 40 10 4 29 22 25 33 42 15 8\n36 24 28 2 32 11 37 12 29 33 16 9 40 3 10 34 7 15 4 27 22 20 25 18 13 26 42 39 17 14 5 8 41 21 23 30 35 31 6 38 19 1\n32 30 36 34 14 7 22 9 35 23 6 21 37 2 5 15 31 33 3 16 25 17 4 27 19 13 24 29 40 39 28 1 20 38 10 11 42 12 8 41 26 18\n2 41 8 20 29 35 25 4 6 1 17 19 3 18 42 33 12 34 5 32 11 15 30 38 39 14 23 31 21 37 22 9 26 27 16 28 36 7 40 10 13 24\n39 1 27 14 2 20 9 26 4 25 18 33 41 28 29 32 34 38 13 7 21 8 10 35 31 17 16 19 23 30 15 5 6 40 37 12 3 36 42 22 24 11\n3 13 9 24 15 21 8 41 33 32 20 1 25 40 27 22 29 31 18 36 10 11 17 2 37 28 39 42 14 4 16 35 7 30 34 26 38 6 12 23 5 19\n6 33 37 26 30 15 20 35 21 39 14 27 7 4 32 36 2 5 9 18 34 23 22 17 42 24 28 11 8 1 38 3 12 25 31 41 29 10 19 13 40 16\n33 16 21 29 40 38 24 7 30 27 11 25 2 32 37 5 35 4 22 9 31 42 18 36 10 34 1 14 12 13 8 41 23 17 3 19 15 20 39 6 28 26\n14 17 24 31 19 27 26 6 38 3 9 36 12 41 15 18 37 22 40 33 16 32 29 42 11 4 10 7 34 25 23 28 35 13 20 8 2 5 21 1 39 30\n18 31 29 22 37 25 3 24 26 28 8 4 20 36 9 30 33 42 27 38 1 7 13 10 32 11 2 16 19 21 35 14 5 23 40 15 41 39 17 12 6 34\n34 9 15 19 23 41 5 39 24 31 26 30 13 25 11 10 40 1 16 22 2 33 28 12 14 37 38 32 29 8 3 7 42 20 35 6 18 4 27 17 21 36\n24 42 5 23 10 37 35 17 18 13 7 39 21 29 8 1 32 40 20 14 12 4 15 26 22 25 9 6 41 36 27 34 3 19 28 16 11 30 31 2 38 33\n7 23 41 10 17 24 21 22 36 14 30 16 42 34 18 19 11 3 1 37 39 12 38 40 8 33 35 25 4 32 20 6 9 5 15 13 31 26 29 28 27 2\n23 18 25 42 27 5 1 38 34 12 31 15 32 20 40 6 19 10 28 30 13 3 8 7 4 2 29 26 36 9 17 21 24 37 33 35 39 22 11 16 14 41\n28 11 40 35 36 42 16 25 13 19 4 5 39 26 20 12 15 41 37 34 38 14 31 9 17 7 30 27 6 2 29 10 8 24 1 18 21 33 32 3 22 23\n40 38 23 1 21 19 32 29 12 4 2 35 31 11 26 7 28 16 41 10 3 22 24 20 33 27 8 37 15 42 25 39 13 14 30 36 6 34 18 5 9 17\n19 26 34 27 8 29 7 20 16 41 36 14 10 15 4 25 3 6 33 5 9 21 23 13 35 30 32 22 37 38 18 17 31 11 12 40 1 42 24 39 2 28\n35 29 10 33 13 31 39 1 9 21 38 11 36 30 14 40 42 17 2 20 41 27 6 19 18 22 3 12 5 26 24 16 28 7 8 23 37 15 25 34 4 32\n10 35 33 21 4 3 2 30 25 40 39 12 1 37 31 20 24 28 42 8 14 26 32 23 9 16 6 38 22 34 41 19 11 18 29 17 7 13 15 27 36 5\n15 5 13 25 9 2 17 40 27 35 42 37 16 8 39 31 41 23 36 1 32 10 7 28 30 19 33 21 20 29 4 18 38 6 11 34 24 3 22 26 12 14\n22 39 16 4 41 1 38 11 5 26 10 23 15 14 35 3 8 29 30 13 28 6 12 25 7 20 40 17 32 27 9 42 18 34 19 2 33 24 37 36 31 21\n9 3 38 15 25 34 12 21 1 20 5 40 17 24 33 2 27 14 8 29 18 30 19 41 16 10 26 36 35 28 6 32 37 42 7 22 13 11 4 31 23 39\n37 10 14 40 12 36 18 3 39 6 35 29 24 38 41 9 23 25 31 21 19 2 42 34 26 8 27 1 30 7 33 13 15 28 32 20 4 16 5 11 17 22\n29 20 7 13 38 18 30 37 23 17 34 22 28 31 25 11 14 2 15 12 24 16 36 4 5 9 21 3 27 35 1 40 39 8 42 32 10 19 26 33 41 6\n12 21 42 18 7 39 27 36 8 34 37 28 23 17 13 24 30 32 35 3 20 29 14 11 41 31 15 5 16 6 19 25 33 22 26 38 9 2 10 40 1 4\n42 4 30 36 1 16 23 15 32 9 3 10 27 35 7 38 22 21 11 2 26 24 39 29 28 6 34 41 25 40 13 20 19 33 5 37 12 17 14 8 18 31\n38 8 19 17 33 40 4 31 15 2 28 6 22 7 1 35 10 11 29 25 27 5 3 14 34 12 41 20 39 18 42 30 36 26 24 9 16 21 23 37 32 13\n\nPart 4: 100 latin squares of order 256:\n\nGenerated in 76.816295878 seconds.\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSimulate the countdown of a rocket launch from   **5**   down to   **0**   seconds,   and then display the moving, accelerating rocket on the standard output device as a simple ASCII art animation."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nUses ANSI graphics. Works best in a 24 bit ANSI terminal at least 80x24, though bigger is better.\n\nThis is a very simple simulation. It assumes a constant ~2G+ acceleration in a gravitational field; so net +10 meters per second². It completely neglects the effects of air friction, impulse, snap, crackle & pop and has an unrealistically clean fuel burn (no contrail). It does however (unlike most of the entries at this time) start at the base of the terminal (on the ground) and go up, rather than starting at the top and dropping a contrail. It calculates and displays an accurate displacement and velocity over time and uses those to scale its vertical screen displacement.\n\nThe motion is a little \"notchy\" as the vertical resolution in a terminal is rather low. Exits after the rocket leaves the visible area of the terminal. See the example animated gif\n\n```\nsignal(SIGINT).tap: { cleanup() }\n\nmy ($rows,$cols) = qx/stty size/.words;\nmy $v = floor $rows - 9;\nmy $h = floor $cols / 2 - 4;\nmy $a = 0;\nmy $start = now;\nmy $t = -5;\nmy $i = 0;\nmy $j = 0;\n\nmy @r = Q'   |',   Q'  /_\\',  Q'  | |',  Q' /| |\\', Q'/_|_|_\\';\nmy @x = Q' (/|\\)', Q' {/|\\}', Q'  \\|/',  Q'   |';\nmy @y = Q'  /|\\',  Q' // \\\\', Q' (/ \\)', Q'  \\ /'; #'\n\nmy $sp = ' ' x $h;\n\nmy $altitude = 0;\nmy $velocity = 0;\n\nmy @pal = \"\\e[38;2;255;0;0m\", \"\\e[38;2;255;255;0m\", \"\\e[38;2;255;155;0m\";\nconstant \\W = \"\\e[38;2;255;255;255m\";\n\nprint \"\\e[?25l\\e[48;5;232m\";\n\nloop {\n    if $t >= 0 {\n        $velocity = 5 * $t²;\n        $altitude = $velocity * $t / 2;\n        $a = ($altitude / $v).round;\n    }\n    cleanup() if $a > $rows + 5;\n\n    print \"\\e[H\\e[J\", \"\\n\" xx $v, W, $sp, @r.join(\"\\n$sp\"), \"\\n\", $sp;\n    if $t < 0 {\n        print Q'\\/   \\/'\n    } else {\n        exhaust( @pal[$i], $a )\n    }\n    print W, \"\\n\", '▔' x $cols, @pal[1];\n    printf \"\\n Time: T %-4s %9s  Altitude: %6.2f meters  Velocity: %5.1f m/sec\\n\",\n    $t < 0 ?? \"- {$t.round.abs}\" !! \"+ {$t.round}\",\n    $t < 0 ?? '' !! $a == 0 ?? 'Ignition!' !! 'Lift-off!',\n    $altitude.round(.01), $velocity.round(.1);\n\n    ++$i;\n    $i %= 3;\n    ++$j;\n    $j %= 2;\n    $t = (now - $start - 5);\n    sleep .05;\n}\n\nsub exhaust ($clr, $a) {\n    print Q'\\/', $clr, Q'/^\\', W, Q'\\/'; #'\n    return if $a == 0;\n    if $a < 4 {\n        print \"\\n\", $clr,\n        $sp, ( $j ?? @x[^$a].join(\"\\n$sp\") !! @y[^$a].join(\"\\n$sp\"))\n    } else {\n        print \"\\n\", $clr,\n        $sp, ( $j ?? @x.join(\"\\n$sp\") !! @y.join(\"\\n$sp\"));\n        print \"\\n\" x $a - 4;\n    }\n}\n\n# clean up on exit, reset ANSI codes, scroll, re-show the cursor & clear screen\nsub cleanup () {  print \"\\e[0m\", \"\\n\" xx 50, \"\\e[H\\e[J\\e[?25h\"; exit(0) }\n\n```\n\nSample output:\n\nSee rocket-perl6.gif (offsite animated gif image)"}]}
{"messages": [{"role": "user", "content": "The Law of cosines states that for an angle γ, (gamma) of any triangle, if the sides adjacent to the angle are A and B and the side opposite is C; then the lengths of the sides are related by this formula:\n\n```\n           A2 + B2 - 2ABcos(γ) = C2 \n\n```\n\nSpecific angles\n\nFor an angle of of   **90º**   this becomes the more familiar \"Pythagoras equation\":\n\n```\n           A2 + B2  =  C2           \n\n```\n\nFor an angle of   **60º**   this becomes the less familiar equation:\n\n```\n           A2 + B2 - AB  =  C2       \n\n```\n\nAnd finally for an angle of   **120º**   this becomes the equation:\n\n```\n           A2 + B2 + AB  =  C2      \n\n```\n\nTask\n\n* Find all integer solutions (in order) to the three specific cases, distinguishing between each angle being considered.\n* Restrain all sides to the integers   **1..13**   inclusive.\n* Show how many results there are for each of the three angles mentioned above.\n* Display results on this page.\n\nNote: Triangles with the same length sides but different order are to be treated as the same.\n\nOptional Extra credit\n\n* How many 60° integer triples are there for sides in the range 1..10\\_000 *where the sides are not all of the same length*.\n\nRelated Task\n\n* Pythagorean triples\n\nSee also\n\n* Visualising Pythagoras: ultimate proofs and crazy contortions Mathlogger Video"}, {"role": "assistant", "content": "(formerly Perl 6)\nIn each routine, race is used to allow concurrent operations, requiring the use of the atomic increment operator, ⚛++, to safely update @triples, which must be declared fixed-sized, as an auto-resizing array is not thread-safe. At exit, default values in @triples are filtered out with the test `!eqv Any`.\n\n```\nmulti triples (60, $n) {\n    my %sq = (1..$n).map: { .² => $_ };\n    my atomicint $i = 0;\n    my @triples[2*$n];\n    (1..^$n).race(:8degree).map: -> $a {\n        for $a^..$n -> $b {\n            my $cos = $a * $a + $b * $b - $a * $b;\n            @triples[$i⚛++] = $a, %sq{$cos}, $b if %sq{$cos}:exists;\n        }\n    }\n    @triples.grep: so *;\n}\n\nmulti triples (90, $n) {\n    my %sq = (1..$n).map: { .² => $_ };\n    my atomicint $i = 0;\n    my @triples[2*$n];\n    (1..^$n).race(:8degree).map: -> $a {\n        for $a^..$n -> $b {\n            my $cos = $a * $a + $b * $b;\n            @triples[$i⚛++] = $a, $b, %sq{$cos} and last if %sq{$cos}:exists;\n        }\n    }\n    @triples.grep: so *;\n}\n\nmulti triples (120, $n) {\n    my %sq = (1..$n).map: { .² => $_ };\n    my atomicint $i = 0;\n    my @triples[2*$n];\n    (1..^$n).race(:8degree).map: -> $a {\n        for $a^..$n -> $b {\n            my $cos = $a * $a + $b * $b + $a * $b;\n            @triples[$i⚛++] = $a, $b, %sq{$cos} and last if %sq{$cos}:exists;\n        }\n    }\n    @triples.grep: so *;\n}\n\nuse Sort::Naturally;\n\nmy $n = 13;\nsay \"Integer triangular triples for sides 1..$n:\";\nfor 120, 90, 60 -> $angle {\n    my @itt = triples($angle, $n);\n    if $angle == 60 { push @itt, \"$_ $_ $_\" for 1..$n }\n    printf \"Angle %3d° has %2d solutions: %s\\n\", $angle, +@itt, @itt.sort(&naturally).join(', ');\n}\n\nmy ($angle, $count) = 60, 10_000;\nsay \"\\nExtra credit:\";\nsay \"$angle° integer triples in the range 1..$count where the sides are not all the same length: \", +triples($angle, $count);\n\n```\n\nOutput:\n\n```\nInteger triangular triples for sides 1..13:\nAngle 120° has  2 solutions: 3 5 7, 7 8 13\nAngle  90° has  3 solutions: 3 4 5, 5 12 13, 6 8 10\nAngle  60° has 15 solutions: 1 1 1, 2 2 2, 3 3 3, 3 7 8, 4 4 4, 5 5 5, 5 7 8, 6 6 6, 7 7 7, 8 8 8, 9 9 9, 10 10 10, 11 11 11, 12 12 12, 13 13 13\n\nExtra credit:\n60° integer triples in the range 1..10000 where the sides are not all the same length: 18394\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDetermine whether a given year is a leap year in the Gregorian calendar.\n\nSee also\n\n* Leap year (wiki)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2010.07\n\n```\nsay \"$year is a {Date.is-leap-year($year) ?? 'leap' !! 'common'} year.\"\n```\n\nIn Rakudo 2010.07, `Date.is-leap-year` is implemented as\n\n```\nmulti method is-leap-year($y = $!year) {\n    $y %% 4 and not $y %% 100 or $y %% 400\n}\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCompute the   least common multiple   (LCM)   of two integers.\n\nGiven   *m*   and   *n*,   the least common multiple is the smallest positive integer that has both   *m*   and   *n*   as factors.\n\nExample\n\nThe least common multiple of   **12**   and   **18**   is   **36**,       because:\n\n:   * **12**   is a factor     (**12** × **3** = **36**),     and\n    * **18**   is a factor     (**18** × **2** = **36**),     and\n    * there is no positive integer less than   **36**   that has both factors.\n\nAs a special case,   if either   *m*   or   *n*   is zero,   then the least common multiple is zero.\n\nOne way to calculate the least common multiple is to iterate all the multiples of   *m*,   until you find one that is also a multiple of   *n*.\n\nIf you already have   *gcd*   for greatest common divisor,   then this formula calculates   *lcm*.\n\n:   :   :   :   lcm\n                ⁡\n                (\n                m\n                ,\n                n\n                )\n                =\n\n                |\n                m\n                ×\n                n\n\n                |\n\n                gcd\n                ⁡\n                (\n                m\n                ,\n                n\n                )\n                {\\displaystyle {\\displaystyle \\operatorname {lcm} (m,n)={\\frac {|m\\times n|}{\\operatorname {gcd} (m,n)}}}}\n\nOne can also find   *lcm*   by merging the prime decompositions of both   *m*   and   *n*.\n\nRelated task\n:   * greatest common divisor.\n\nSee also\n\n* MathWorld entry:   Least Common Multiple.\n* Wikipedia entry:   Least common multiple."}, {"role": "assistant", "content": "(formerly Perl 6)\nThis function is provided as an infix so that it can be used productively with various metaoperators.\n\n```\nsay 3 lcm 4;            # infix\nsay [lcm] 1..20;        # reduction\nsay ~(1..10 Xlcm 1..10) # cross\n\n```\n\nOutput:\n\n```\n12\n232792560\n1 2 3 4 5 6 7 8 9 10 2 2 6 4 10 6 14 8 18 10 3 6 3 12 15 6 21 24 9 30 4 4 12 4 20 12 28 8 36 20 5 10 15 20 5 30 35 40 45 10 6 6 6 12 30 6 42 24 18 30 7 14 21 28 35 42 7 56 63 70 8 8 24 8 40 24 56 8 72 40 9 18 9 36 45 18 63 72 9 90 10 10 30 20 10 30 70 40 90 10\n```"}]}
{"messages": [{"role": "user", "content": "Find the minimum positive integer **m** such that **n** factorial plus **m** is prime.\n\nE.G.\n\n```\n   0! = 1. The next prime greater than 1 is 2. 2 - 1 = 1, so a(0) = 1.\n   1! = 1. The next prime greater than 1 is 2. 2 - 1 = 1, so a(1) = 1.\n   2! = 2. The next prime greater than 2 is 3. 3 - 2 = 1, so a(2) = 1.\n   3! = 6. The next prime greater than 6 is 7. 7 - 6 = 1, so a(3) = 1.\n   4! = 24. The next prime greater than 24 is 29. 29 - 24 = 5, so a(4) = 5.\n\n```\n\nand so on...\n\nTask\n\n* Find and display the first fifty terms in the series. (**0!** through **49!**)\n* Find and display the position and value of the first **m** greater than **1000**.\n\nStretch\n\n* Find and display the position and value of each the first **m** greater than **2000, 3000, 4000** ... **10,000**.\n\nSee also\n\n* OEIS:A033932 - Least positive m such that n! + m is prime"}, {"role": "assistant", "content": "```\nmy @f = lazy flat 1, [\\×] 1..*;\n\nsink @f[700]; # pre-reify for concurrency\n\nmy @least-m = lazy (^∞).hyper(:2batch).map: {(1..*).first: -> \\n {(@f[$_] + n).is-prime}};\n\nsay \"Least positive m such that n! + m is prime; first fifty:\\n\" \n ~ @least-m[^50].batch(10)».fmt(\"%3d\").join: \"\\n\";\n\nfor (1..10).map: * × 1e3 {\n    my $key = @least-m.first: * > $_, :k;\n    printf \"\\nFirst m > $_ is %d at position %d\\n\", @least-m[$key], $key;\n}\n\n```\n\nOutput:\n\n```\nLeast positive m such that n! + m is prime; first fifty:\n  1   1   1   1   5   7   7  11  23  17\n 11   1  29  67  19  43  23  31  37  89\n 29  31  31  97 131  41  59   1  67 223\n107 127  79  37  97  61 131   1  43  97\n 53   1  97  71  47 239 101 233  53  83\n\nFirst m > 1000 is 1069 at position 107\n\nFirst m > 2000 is 3391 at position 192\n\nFirst m > 3000 is 3391 at position 192\n\nFirst m > 4000 is 4943 at position 284\n\nFirst m > 5000 is 5233 at position 384\n\nFirst m > 6000 is 6131 at position 388\n\nFirst m > 7000 is 9067 at position 445\n\nFirst m > 8000 is 9067 at position 445\n\nFirst m > 9000 is 9067 at position 445\n\nFirst m > 10000 is 12619 at position 599\n```"}]}
{"messages": [{"role": "user", "content": "**Left factorials**,   !n,   may refer to either   *subfactorials*   or to   *factorial sums*;\n  \nthe same notation can be confusingly seen being used for the two different definitions.\n\nSometimes,   *subfactorials*   (also known as *derangements*)   may use any of the notations:\n\n:   :   :   :   :   :   :   * **!*n*`**\n                            * **!*n***\n                            * ***n*¡**\n\n(It may not be visually obvious, but the last example uses an upside-down exclamation mark.)\n\nThis Rosetta Code task will be using this formula   (*factorial sums*)   for   **left factorial**:\n\n:   :   :   :   :   !\n                    n\n                    =\n\n                    ∑\n\n                    k\n                    =\n                    0\n\n                    n\n                    −\n                    1\n                    k\n                    !\n                    {\\displaystyle {\\displaystyle !n=\\sum \\_{k=0}^{n-1}k!}}\n\n:   :   :   :   where\n\n:   :   :   :   :   !\n                    0\n                    =\n                    0\n                    {\\displaystyle {\\displaystyle !0=0}}\n\nTask\n\nDisplay the left factorials for:\n\n* zero through ten     (inclusive)\n* 20   through   110   (inclusive)   by tens\n\nDisplay the length (in decimal digits) of the left factorials for:\n\n* 1,000   through   10,000   (inclusive), by thousands.\n\nAlso see\n\n* The OEIS entry: A003422 left factorials\n* The MathWorld entry: left factorial\n* The MathWorld entry: factorial sums\n* The MathWorld entry: subfactorial\n\nRelated task\n\n* permutations/derangements (subfactorials)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nImplement left factorial as a prefix !. Note that this redefines the core prefix ! (not) function.\n\n```\nsub prefix:<!> ($k) { (constant l = 0, |[\\+] 1, (|[\\*] 1..*))[$k] }\n\n$ = !10000; # Pre-initialize\n\n.say for ( 0 … 10, 20 … 110 ).hyper(:4batch).map: { sprintf \"!%d  = %s\", $_, !$_ };\n.say for (1000, 2000 … 10000).hyper(:4batch).map: { sprintf \"!%d has %d digits.\", $_, chars !$_ };\n\n```\n\nOutput:\n\n```\n!0  = 0\n!1  = 1\n!2  = 2\n!3  = 4\n!4  = 10\n!5  = 34\n!6  = 154\n!7  = 874\n!8  = 5914\n!9  = 46234\n!10  = 409114\n!20  = 128425485935180314\n!30  = 9157958657951075573395300940314\n!40  = 20935051082417771847631371547939998232420940314\n!50  = 620960027832821612639424806694551108812720525606160920420940314\n!60  = 141074930726669571000530822087000522211656242116439949000980378746128920420940314\n!70  = 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314\n!80  = 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314\n!90  = 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314\n!100  = 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314\n!110  = 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314\n!1000 has 2565 digits.\n!2000 has 5733 digits.\n!3000 has 9128 digits.\n!4000 has 12670 digits.\n!5000 has 16322 digits.\n!6000 has 20062 digits.\n!7000 has 23875 digits.\n!8000 has 27749 digits.\n!9000 has 31678 digits.\n!10000 has 35656 digits.\n```\n\nIf you would rather not override prefix ! operator and you can live with just defining lazy lists and indexing into them, this should suffice; (and is in fact very slightly faster than the first example since it avoids routine dispatch overhead):\n\n```\nconstant leftfact = 0, |[\\+] 1, (|[\\*] 1..*);\n\n$ = leftfact[10000]; # Pre-initialize\n\n.say for ( 0 … 10, 20 … 110 ).hyper(:4batch).map: { sprintf \"!%d  = %s\", $_, leftfact[$_] };\n.say for (1000, 2000 … 10000).hyper(:4batch).map: { sprintf \"!%d has %d digits.\", $_, chars leftfact[$_] };\n\n```\n\nSame output."}]}
{"messages": [{"role": "user", "content": "The prime-counting function π(n) computes the number of primes not greater than n. Legendre was the first mathematician to create a formula to compute π(n) based on the inclusion/exclusion principle.\n\nTo calculate:\n\nDefine\n\n```\nφ(x, 0) = x\nφ(x, a) = φ(x, a−1) − φ(⌊x/pa⌋, a−1), where pa is the ath prime number.\n\n```\n\nthen\n\n```\nπ(n) = 0 when n < 2\nπ(n) = φ(n, a) + a - 1, where a = π(√n), n ≥ 2\n\n```\n\nThe Legendre formula still requires the use of a sieve to enumerate primes; however it's only required to sieve up to the √n, and for counting primes, the Legendre method is generally much faster than sieving up to n.\n\nTask\n\nCalculate π(n) for values up to 1 billion. Show π(n) for n = 1, 10, 100, ... 109.\n\nFor this task, you may refer to a prime number sieve (such as the Sieve of Eratosthenes or the extensible sieve) in an external library to enumerate the primes required by the formula. Also note that it will be necessary to memoize the results of φ(x, a) in order to have reasonable performance, since the recurrence relation would otherwise take exponential time.\n\n**Comments on Task**\n\nRegarding \"it will be necessary to memoize the results of φ(x, a)\", it will have exponential time performance without memoization only if a very small optimization that should be obvious is not done: it should be obvious that one can stop \"splitting\" the φ(x, a) \"tree\" when 'x' is zero, and even before that since the real meaning of the \"phi\"/φ function is to produce a count of all of the values greater than zero (including one) up to `x` that have been culled of all multiples of the primes up to and including the `pa` prime value, if `x` is less than or equal to `pa`, then the whole \"tree\" must result in a value of just one. If this minor (and obvious) optimization is done, the \"exponential time\" performance goes away, memoization is not absolutely necessary (saving the overhead in time and space of doing the memoization), and the time complexity becomes O(n/(log n2) and the space complexity becomes O(n1/2/log n) as they should be.\n\nThis is the problem when non-mathematician programmers blindly apply such a general formula as the recursive Legendre one without doing any work to understand it or even doing some trivial hand calculations to better understand how it works just because they have very powerful computers which mask the limitations: a few minutes of hand calculation would make it obvious that there is no need to \"split\"/recursively call for \"phi\" nodes where the first argument is zero, and someone with a mathematics interest would then investigate to see if that limit can be pushed a little further as here to the range of nodes whose result will always be one. Once there is no exponential growth of the number of \"nodes\", then there is no need for memoization as usually implemented with a hash table at a huge cost of memory overhead and constant time computation per operation.\n\nAs to \"the Legendre method is generally much faster than sieving up to n.\", while the number of operations for the Legendre algorithm is about a factor of `log n` squared less than the number of operations for odds-only Sieve of Eratosthenes (SoE) sieving, those operations are \"divide\" operations which are generally much slower than the simple array access and addition operations used in sieving and the SoE can be optimized further using wheel factorization so that the required time for a given range can be less for a fully optimized SoE than for the common implementation of the Legendre algorithm; the trade off is that a fully optimized SoE is at least 500 lines of code, whereas the basic version of the Legendre prime counting algorithm is only about 40 to 50 lines of code (depending somewhat on the language used).\n\nAlso note that the Legendre prime counting function was never used practically at the time it was invented other than to demonstrate that it would find the count of primes to a trivial range only knowing the primes up to the square root of that range and there were too many operations (especially long integer division operations) to actually use it for any reasonably range even with this optimization (about 250 thousand divisions to count primes to ten million), but the follow-on work by Meissel in the 1800's definitely would have used this optimization and others in order to hand calculate the number of primes to a billion (1e9) in about ten years. Even with this optimization, Meissel would have had to hand calculate over five million divisions, so certainly used other Look Up Tables (LUT's) although certainly not caching of Phi/φ values in order to reduce the work to something possible in this amount of time. A \"TinyPhi\" LUT table for the first six primes of thirteen and less would have reduced the amount of work Meissel did to about 600 thousand divisions, but even that would have been perhaps too much and it is very likely that he also used \"partial sieving\" techniques, although that would have meant that as well as a table of the primes up to a million, he would have also needed 161 other tables of that range to a million sieved by the primes up to 13, 17, 19, to 997; however, that extra work in building these tables (which might have been done mechanically) would pay off in reducing the number of divisions to about seven thousand so the divisions become a minor problem possible to do over months and the majority of the time would be spent producing the partial sieving tables up to a million.\n\nThe reason that Meissel refined the Legendre method would have been that, even applying all of the optimizations including \"partial sieving\", he would still have had to do about three and a half million divisions to count the primes to a billion even if the number of primes and \"partial sieve tables\" only needed to be known to about 32 thousand, where his \"Meissel\" algorithm reduced the number of divisions to only a few thousand as per the above. Without a computer, he could never have completed the calculation of the number of primes to a billion using an optimized Legendre algorithm where he could using his modification. However, modern computers make (reasonably) quick work of integer divisions so that optimized algorithms of the Legendre type become moderately useful although at the cost of memory use as compared to Meissel type algorithms."}, {"role": "assistant", "content": "Seems like an awful lot of pointless work. Using prime sieve anyway, why not just use it?\n\n```\nuse Math::Primesieve;\n\nmy $sieve = Math::Primesieve.new;\n\nsay \"10^$_\\t\" ~ $sieve.count: exp($_,10) for ^10;\n\nsay (now - INIT now) ~ ' elapsed seconds';\n\n```\n\nOutput:\n\n```\n10^0\t0\n10^1\t4\n10^2\t25\n10^3\t168\n10^4\t1229\n10^5\t9592\n10^6\t78498\n10^7\t664579\n10^8\t5761455\n10^9\t50847534\n0.071464489 elapsed seconds\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a method (function, procedure etc.) in your language which calculates the length of the major arc of a circle of given radius between two angles.\n\nIn this diagram the major arc is colored green   (note: this website leaves cookies).\n\nIllustrate the use of your method by calculating the length of the major arc of a circle of radius 10 units, between angles of 10 and 120 degrees."}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.02\n\nTaking a slightly different approach. Rather than the simplest thing that\ncould possibly work, implements a reusable arc-length routine. Standard notation\nfor angles has the zero to the right along an 'x' axis with a\ncounter-clockwise rotation for increasing angles. This version follows\nconvention and assumes the first given angle is \"before\" the second when\nrotating counter-clockwise. In order to return the major swept angle in the\ntask example, you need to supply the \"second\" angle first. (The measurement\nwill be from the first given angle counter-clockwise to the second.)\n\nIf you don't supply a radius, returns the radian arc angle which may then be\nmultiplied by the radius to get actual circumferential length.\n\nWorks in radian angles by default but provides a postfix ° operator to convert\ndegrees to radians and a postfix ᵍ to convert gradians to radians.\n\n```\nsub arc ( Real \\a1, Real \\a2, :r(:$radius) = 1 ) {\n    ( ([-] (a2, a1).map((* + τ) % τ)) + τ ) % τ × $radius\n}\n\nsub postfix:<°> (\\d) { d × τ / 360 }\nsub postfix:<ᵍ> (\\g) { g × τ / 400 }\n\nsay 'Task example: from 120° counter-clockwise to 10° with 10 unit radius';\nsay arc(:10radius, 120°, 10°), ' engineering units';\n\nsay \"\\nSome test examples:\";\nfor \\(120°, 10°), # radian magnitude (unit radius)\n    \\(10°, 120°), # radian magnitude (unit radius)\n    \\(:radius(10/π), 180°, -90°), # 20 unit circumference for ease of comparison\n    \\(0°, -90°, :r(10/π),),       #  ↓  ↓  ↓  ↓  ↓  ↓  ↓\n    \\(:radius(10/π), 0°, 90°),\n    \\(π/4, 7*π/4, :r(10/π)),\n    \\(175ᵍ, -45ᵍ, :r(10/π)) {  # test gradian parameters\n    printf \"Arc length: %8s  Parameters: %s\\n\", arc(|$_).round(.000001), $_.raku\n}\n\n```\n\nOutput:\n\n```\nTask example: from 120° counter-clockwise to 10° with 10 unit radius\n43.63323129985824 engineering units\n\nSome test examples:\nArc length: 4.363323  Parameters: \\(2.0943951023931953e0, 0.17453292519943295e0)\nArc length: 1.919862  Parameters: \\(0.17453292519943295e0, 2.0943951023931953e0)\nArc length:        5  Parameters: \\(3.141592653589793e0, -1.5707963267948966e0, :radius(3.183098861837907e0))\nArc length:       15  Parameters: \\(0e0, -1.5707963267948966e0, :r(3.183098861837907e0))\nArc length:        5  Parameters: \\(0e0, 1.5707963267948966e0, :radius(3.183098861837907e0))\nArc length:       15  Parameters: \\(0.7853981633974483e0, 5.497787143782138e0, :r(3.183098861837907e0))\nArc length:        9  Parameters: \\(2.7488935718910685e0, -0.7068583470577035e0, :r(3.183098861837907e0))\n```"}]}
{"messages": [{"role": "user", "content": "*Leonardo numbers*   are also known as the   *Leonardo series*.\n\nThe   **Leonardo numbers**   are a sequence of numbers defined by:\n\n```\n       L(0) = 1                                          [1st equation]  \n       L(1) = 1                                          [2nd equation]  \n       L(n) = L(n-1)  +    L(n-2)   +  1                 [3rd equation]  \n                    ─── also ───\n       L(n) =      2  *  Fib(n+1)   -  1                 [4th equation]  \n\n```\n\n:   :   :   :   where the   **+ 1**   will herein be known as the   *add*   number.\n            :   where the   **FIB**   is the   Fibonacci numbers.\n\nThis task will be using the 3rd equation (above) to calculate the Leonardo numbers.\n\nEdsger W. Dijkstra   used   Leonardo numbers   as an integral part of\nhis   smoothsort   algorithm.\n\nThe first few Leonardo numbers are:\n\n```\n    1   1   3   5   9   15   25   41   67   109   177   287   465   753   1219   1973   3193   5167   8361  ··· \n\n```\n\nTask\n:   :   * show the 1st   **25**   Leonardo numbers, starting at **L(0)**.\n        * allow the first two Leonardo numbers to be specified   [for **L(0)** and **L(1)**].\n        * allow the   *add*   number to be specified   (**1** is the default).\n        * show the 1st   **25**   Leonardo numbers, specifying **0** and **1** for **L(0)** and **L(1)**, and **0** for the *add* number.\n\n(The last task requirement will produce the Fibonacci numbers.)\n\nShow all output here on this page.\n\nRelated tasks\n\n* Fibonacci number\n* Fibonacci n-step number sequences\n\nSee also\n\n* Wikipedia, Leonardo numbers\n* Wikipedia, Fibonacci numbers\n* OEIS Leonardo numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub 𝑳 ( $𝑳0 = 1, $𝑳1 = 1, $𝑳add = 1 ) { $𝑳0, $𝑳1, { $^n2 + $^n1 + $𝑳add } ... * }\n\n# Part 1\nsay \"The first 25 Leonardo numbers:\";\nput 𝑳()[^25];\n\n# Part 2\nsay \"\\nThe first 25 numbers using 𝑳0 of 0, 𝑳1 of 1, and adder of 0:\";\nput 𝑳( 0, 1, 0 )[^25];\n\n```\n\nOutput:\n\n```\nThe first 25 Leonardo numbers:\n1 1 3 5 9 15 25 41 67 109 177 287 465 753 1219 1973 3193 5167 8361 13529 21891 35421 57313 92735 150049\n\nThe first 25 numbers using 𝑳0 of 0, 𝑳1 of 1, and adder of 0:\n0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nOpen a text file and count the occurrences of each letter.\n\nSome of these programs count all characters (including punctuation),\nbut some only count letters A to Z.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nIn Raku, whenever you want to count things in a collection, the rule of thumb is to use the Bag structure.\n\n*In response to some of the breathless exposition in the Frink entry.*\n\n* Has a Unicode-aware function, which intelligently enumerates through what a human would consider to be a single visible character. - Raku doesn't have **a** special Unicode aware string processing function, rather **all** of Rakus text/string wrangling functions are Unicode aware by default.\n\n* Unicode-aware lowercase function. - See above: lowercase, uppercase, fold-case, title-case, all Unicode aware by default.\n\n* Uses full Unicode tables to determine what is a \"letter.\" - Um... Yeah, Unicode aware by default.\n\n* Works with high Unicode characters, that is above \\uFFFF. - OK, now we're just repeating ourselves.\n\n* Normalize Unicode characters with its normalizeUnicode function. - Raku; normalized by default.\n\n* Implements all of (NFC, NFD, NFKC, NFKD). NFC is the default. - Yep.\n\n\"How many other languages in this page do all or any of this correctly?\" Quite a few I suspect. Some even moreso than Frink.\n\n```\n.&ws.say for slurp.comb.Bag.sort: -*.value;\n\nsub ws ($pair) { \n    $pair.key ~~ /\\n/\n    ?? ('NEW LINE' => $pair.value)\n    !! $pair.key ~~ /\\s/\n    ?? ($pair.key.uniname => $pair.value)\n    !! $pair\n}\n\n```\n\nOutput when fed the same Les Misérables text file as used in the Word frequency task:\n\n```\nSPACE => 522095\ne => 325692\nt => 222916\na => 199790\no => 180974\nh => 170210\nn => 167006\ni => 165201\ns => 157585\nr => 145118\nd => 106987\nl => 97131\nNEW LINE => 67662\nu => 67340\nc => 62717\nm => 56021\nf => 53494\nw => 53301\n, => 48784\ng => 46060\np => 39932\ny => 37985\nb => 34276\n. => 30589\nv => 24045\n\" => 14340\nk => 14169\nT => 12547\n- => 11037\nI => 10067\nA => 7355\nH => 6600\nM => 6206\n; => 5885\nE => 4968\nC => 4583\nS => 4392\n' => 3938\nx => 3692\n! => 3539\nR => 3531\nP => 3424\nO => 3401\nj => 3390\nB => 3185\nW => 3180\nN => 3053\n? => 2976\nF => 2754\nG => 2508\n: => 2468\nJ => 2448\nL => 2444\nq => 2398\nV => 2200\n_ => 2070\nz => 1847\nD => 1756\né => 1326\nY => 1238\nU => 895\n1 => 716\n8 => 412\nX => 333\nK => 321\nè => 292\n3 => 259\n2 => 248\n5 => 220\n0 => 218\n* => 181\n4 => 181\n) => 173\n( => 173\n6 => 167\nÉ => 146\n7 => 143\nQ => 135\n] => 122\n[ => 122\n9 => 117\næ => 106\n= => 75\nê => 74\nZ => 59\nà => 59\nâ => 56\n> => 50\n< => 50\n/ => 50\nç => 48\nNO-BREAK SPACE => 45\nî => 39\nü => 37\n| => 36\nô => 34\n# => 26\nù => 18\nï => 18\nÆ => 10\nû => 9\n+ => 5\nÈ => 5\në => 5\nÀ => 4\n@ => 2\nñ => 2\nÇ => 2\n$ => 2\n% => 1\n& => 1\n{ => 1\n} => 1\n½ => 1\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Levenshtein distance. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn information theory and computer science, the **Levenshtein distance** is a metric for measuring the amount of difference between two sequences (i.e. an edit distance). The Levenshtein distance between two strings is defined as the minimum number of edits needed to transform one string into the other, with the allowable edit operations being insertion, deletion, or substitution of a single character.\n\nExample\n\nThe Levenshtein distance between \"**kitten**\" and \"**sitting**\" is 3, since the following three edits change one into the other, and there isn't a way to do it with fewer than three edits:\n\n:   :   1. **k**itten   **s**itten   (substitution of 'k' with 's')\n        2. sitt**e**n   sitt**i**n   (substitution of 'e' with 'i')\n        3. sittin   sittin**g**   (insert 'g' at the end).\n\n*The Levenshtein distance between   \"**rosettacode**\",   \"**raisethysword**\"   is   **8**.*\n\n*The distance between two strings is same as that when both strings are reversed.*\n\nTask\n\nImplements a Levenshtein distance function, or uses a library function, to show the Levenshtein distance between   \"kitten\"   and   \"sitting\".\n\nRelated task\n\n* Longest common subsequence\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nImplementation of the Wikipedia algorithm. Since column 0 and row 0 are used for base distances, the original algorithm would require us to compare \"@s[$i-1] eq @t[$j-1]\", and reference $m and $n separately. Prepending an unused value (undef) onto @s and @t makes their indices align with the $i,$j numbering of @d, and lets us use .end instead of $m,$n.\n\n```\nsub levenshtein-distance ( Str $s, Str $t --> Int ) {\n    my @s = *, |$s.comb;\n    my @t = *, |$t.comb;\n\n    my @d;\n    @d[$_;  0] = $_ for ^@s.end;\n    @d[ 0; $_] = $_ for ^@t.end;\n\n    for 1..@s.end X 1..@t.end -> ($i, $j) {\n        @d[$i; $j] = @s[$i] eq @t[$j]\n            ??   @d[$i-1; $j-1]    # No operation required when eq\n            !! ( @d[$i-1; $j  ],   # Deletion\n                 @d[$i  ; $j-1],   # Insertion\n                 @d[$i-1; $j-1],   # Substitution\n               ).min + 1;\n    }\n\n    @d[*-1][*-1];\n}\n\nfor <kitten sitting>, <saturday sunday>, <rosettacode raisethysword> -> ($s, $t) {\n    say \"Levenshtein distance('$s', '$t') == \", levenshtein-distance($s, $t)\n}\n```\n\nOutput:\n\n```\nLevenshtein distance('kitten', 'sitting') == 3\nLevenshtein distance('saturday', 'sunday') == 3\nLevenshtein distance('rosettacode', 'raisethysword') == 8\n```"}]}
{"messages": [{"role": "user", "content": "The Levenshtein distance algorithm returns the number of atomic operations (insertion, deletion or edition) that must be performed on a string in order to obtain an other one, but it does not say anything about the actual operations used or their order.\n\nAn alignment is a notation used to describe the operations used to turn a string into an other. At some point in the strings, the minus character ('-') is placed in order to signify that a character must be added at this very place. For instance, an alignment between the words 'place' and 'palace' is:\n\n```\nP-LACE\nPALACE\n\n```\n\nTask\n\nWrite a function that shows the alignment of two strings for the corresponding levenshtein distance.\n\nAs an example, use the words \"rosettacode\" and \"raisethysword\".\n\nYou can either implement an algorithm, or use a dedicated library (thus showing us how it is named in your language)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nsub align ( Str $σ, Str $t ) {\n    my @s = flat *, $σ.comb;\n    my @t = flat *, $t.comb;\n     \n    my @A;\n    @A[$_][ 0]<d s t> = $_, @s[1..$_].join, '-' x $_ for ^@s;\n    @A[ 0][$_]<d s t> = $_, '-' x $_, @t[1..$_].join for ^@t;\n     \n    for 1 ..^ @s X 1..^ @t -> (\\i, \\j) {\n\tif @s[i] ne @t[j] {\n\t    @A[i][j]<d> = 1 + my $min =\n\t    min @A[i-1][j]<d>, @A[i][j-1]<d>, @A[i-1][j-1]<d>;\n\t    @A[i][j]<s t> =\n\t    @A[i-1][j]<d> == $min ??  (@A[i-1][j]<s t> Z~ @s[i], '-') !!\n\t    @A[i][j-1]<d> == $min ??  (@A[i][j-1]<s t> Z~ '-', @t[j]) !!\n\t    (@A[i-1][j-1]<s t> Z~ @s[i], @t[j]);\n\t} else {\n\t    @A[i][j]<d s t> = @A[i-1][j-1]<d s t> Z~ '', @s[i], @t[j];\n\t}\n    }\n     \n    return @A[*-1][*-1]<s t>;\n}\n \n.say for align 'rosettacode', 'raisethysword';\n\n```\n\nOutput:\n\n```\nro-settac-o-de\nraisethysword-\n```"}]}
{"messages": [{"role": "user", "content": "In plane geometry, a line (or segment) may intersect a circle at 0, 1 or 2 points.\n\nTask\n\nImplement a method (function, procedure etc.) in your language which takes as parameters:\n\n* the starting point of a line;\n* the point where the line ends;\n* the center point of a circle;\n* the circle's radius; and\n* whether the line is a segment or extends to infinity beyond the above points.\n\nThe method should return the intersection points (if any) of the circle and the line.\n\nIllustrate your method with some examples (or use the Go examples below).\n\nStretch Task\n\nInclude results for a circle with center at (10, 10) and radius 5 combined with a line through points (5, 0) and (5, 20) and that same circle combined with a line segment from (-5, 10) to (5, 10).\n\nReferences\n\n* See Math Stack Exchange for development of the formulae needed.\n* See Wolfram for the formulae needed."}, {"role": "assistant", "content": "(formerly Perl 6)\nExtend solution space to 3D. Reference: this SO question and answers\n\n```\nsub LineCircularOBJintersection(@P1, @P2, @Centre, \\Radius) {\n   my @d = @P2 »-« @P1 ;           # d\n   my @f = @P1 »-« @Centre ;       # c\n\n   my \\a = [+] @d»²;               # d dot d\n   my \\b = 2 * ([+] @f »*« @d);    # 2 * f dot d\n   my \\c = ([+] @f»²) - Radius²;   # f dot f - r²\n   my \\Δ =  b²-(4*a*c);            # discriminant\n\n   if (Δ < 0) {\n      return [];\n   } else {\n      my (\\t1,\\t2) = (-b - Δ.sqrt)/(2*a), (-b + Δ.sqrt)/(2*a);\n      if 0 ≤ t1|t2 ≤ 1 {\n         return @P1 »+« ( @P2 »-« @P1 ) »*» t1, @P1 »+« ( @P2 »-« @P1 ) »*» t2\n      } else {\n         return []\n      }\n   }\n}\n\nmy \\DATA = [\n   [ <-10 11>, < 10 -9>, <3 -5>, 3 ],\n   [ <-10 11>, <-11 12>, <3 -5>, 3 ],\n   [ <  3 -2>, <  7 -2>, <3 -5>, 3 ],\n   [ <  3 -2>, <  7 -2>, <0  0>, 4 ],\n   [ <  0 -3>, <  0  6>, <0  0>, 4 ],\n   [ <  6  3>, < 10  7>, <4  2>, 5 ],\n   [ <  7  4>, < 11 18>, <4  2>, 5 ],\n   [ <5  2 −2.26 >, <0.77 2 4>, <1 4 0>, 4 ]\n];\n\nfor DATA {\n   my @solution = LineCircularOBJintersection $_[0] , $_[1] , $_[2], $_[3];\n   say \"For data set: \", $_;\n   say \"Solution(s) is/are: \", @solution.Bool ?? @solution !! \"None\";\n}\n\n```\n\nOutput:\n\n```\nFor data set: [(-10 11) (10 -9) (3 -5) 3]\nSolution(s) is/are: [(3 -2) (6 -5)]\nFor data set: [(-10 11) (-11 12) (3 -5) 3]\nSolution(s) is/are: None\nFor data set: [(3 -2) (7 -2) (3 -5) 3]\nSolution(s) is/are: [(3 -2) (3 -2)]\nFor data set: [(3 -2) (7 -2) (0 0) 4]\nSolution(s) is/are: [(-3.4641016151377544 -2) (3.4641016151377544 -2)]\nFor data set: [(0 -3) (0 6) (0 0) 4]\nSolution(s) is/are: [(0 -4) (0 4)]\nFor data set: [(6 3) (10 7) (4 2) 5]\nSolution(s) is/are: [(1 -2) (8 5)]\nFor data set: [(7 4) (11 18) (4 2) 5]\nSolution(s) is/are: [(5.030680985703315 -2.892616550038399) (7.459885052032535 5.60959768211387)]\nFor data set: [(5 2 −2.26) (0.77 2 4) (1 4 0) 4]\nSolution(s) is/are: [(4.2615520237084015 2 -1.1671668246843006) (1.13386504516801 2 3.461514141193441)]\n\n```"}]}
{"messages": [{"role": "user", "content": "The linear congruential generator is a very simple example of a random number generator.\n\nAll linear congruential generators use this formula:\n\n* r\n\n  n\n  +\n  1\n  =\n  a\n  ×\n\n  r\n\n  n\n  +\n  c\n\n\n  (\n  mod\n\n  m\n  )\n  {\\displaystyle {\\displaystyle r\\_{n+1}=a\\times r\\_{n}+c{\\pmod {m}}}}\n\nWhere:\n\n* r\n\n  0\n  {\\displaystyle {\\displaystyle r\\_{0}}}\n   is a seed.\n* r\n\n  1\n  {\\displaystyle {\\displaystyle r\\_{1}}}\n  , \n\n  r\n\n  2\n  {\\displaystyle {\\displaystyle r\\_{2}}}\n  , \n\n  r\n\n  3\n  {\\displaystyle {\\displaystyle r\\_{3}}}\n  , ..., are the random numbers.\n* a\n  {\\displaystyle {\\displaystyle a}}\n  , \n\n  c\n  {\\displaystyle {\\displaystyle c}}\n  , \n\n  m\n  {\\displaystyle {\\displaystyle m}}\n   are constants.\n\nIf one chooses the values of \n\na\n{\\displaystyle {\\displaystyle a}}\n, \n\nc\n{\\displaystyle {\\displaystyle c}}\n and \n\nm\n{\\displaystyle {\\displaystyle m}}\n with care, then the generator produces a uniform distribution of integers from \n\n0\n{\\displaystyle {\\displaystyle 0}}\n to \n\nm\n−\n1\n{\\displaystyle {\\displaystyle m-1}}\n.\n\nLCG numbers have poor quality. \n\nr\n\nn\n{\\displaystyle {\\displaystyle r\\_{n}}}\n and \n\nr\n\nn\n+\n1\n{\\displaystyle {\\displaystyle r\\_{n+1}}}\n are not independent, as true random numbers would be. Anyone who knows \n\nr\n\nn\n{\\displaystyle {\\displaystyle r\\_{n}}}\n can predict \n\nr\n\nn\n+\n1\n{\\displaystyle {\\displaystyle r\\_{n+1}}}\n, therefore LCG is not cryptographically secure. The LCG is still good enough for simple tasks like Miller-Rabin primality test, or FreeCell deals. Among the benefits of the LCG, one can easily reproduce a sequence of numbers, from the same \n\nr\n\n0\n{\\displaystyle {\\displaystyle r\\_{0}}}\n. One can also reproduce such sequence with a different programming language, because the formula is so simple.\n\nThe task is to replicate two historic random number generators. One is the `rand()` function from BSD libc, and the other is the `rand()` function from the Microsoft C Runtime (MSCVRT.DLL). Each replica must yield the same sequence of integers as the original generator, when starting from the same seed.\n\nIn these formulas, the seed becomes \n\ns\nt\na\nt\n\ne\n\n0\n{\\displaystyle {\\displaystyle state\\_{0}}}\n. The random sequence is \n\nr\na\nn\n\nd\n\n1\n{\\displaystyle {\\displaystyle rand\\_{1}}}\n, \n\nr\na\nn\n\nd\n\n2\n{\\displaystyle {\\displaystyle rand\\_{2}}}\n and so on.\n\nBSD formula\n\n* s\n  t\n  a\n  t\n\n  e\n\n  n\n  +\n  1\n  =\n  1103515245\n  ×\n  s\n  t\n  a\n  t\n\n  e\n\n  n\n  +\n  12345\n\n\n  (\n  mod\n\n\n  2\n\n  31\n  )\n  {\\displaystyle {\\displaystyle state\\_{n+1}=1103515245\\times state\\_{n}+12345{\\pmod {2^{31}}}}}\n* r\n  a\n  n\n\n  d\n\n  n\n  =\n  s\n  t\n  a\n  t\n\n  e\n\n  n\n  {\\displaystyle {\\displaystyle rand\\_{n}=state\\_{n}}}\n* r\n  a\n  n\n\n  d\n\n  n\n  {\\displaystyle {\\displaystyle rand\\_{n}}}\n   is in range 0 to 2147483647.\n\nMicrosoft formula\n\n* s\n  t\n  a\n  t\n\n  e\n\n  n\n  +\n  1\n  =\n  214013\n  ×\n  s\n  t\n  a\n  t\n\n  e\n\n  n\n  +\n  2531011\n\n\n  (\n  mod\n\n\n  2\n\n  31\n  )\n  {\\displaystyle {\\displaystyle state\\_{n+1}=214013\\times state\\_{n}+2531011{\\pmod {2^{31}}}}}\n* r\n  a\n  n\n\n  d\n\n  n\n  =\n  s\n  t\n  a\n  t\n\n  e\n\n  n\n  ÷\n\n  2\n\n  16\n  {\\displaystyle {\\displaystyle rand\\_{n}=state\\_{n}\\div 2^{16}}}\n* r\n  a\n  n\n\n  d\n\n  n\n  {\\displaystyle {\\displaystyle rand\\_{n}}}\n   is in range 0 to 32767.\n\nThe BSD formula was so awful that FreeBSD switched to a different formula.\n\nMore info is at Random number generator (included)#C."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nWe'll define subroutines implementing the LCG algorithm for each version. We'll make them return a lazy list.\n\n```\nconstant modulus = 2**31;\nsub bsd  {\n    $^seed, ( 1103515245 * * + 12345 ) % modulus ... *\n}\nsub ms   {\n    map * +> 16, (\n\t$^seed, ( 214013 * * + 2531011 ) % modulus ... *\n    )\n}\n \nsay 'BSD LCG first 10 values (first one is the seed):';\n.say for bsd(0)[^10];\n \nsay \"\\nMS LCG first 10 values (first one is the seed):\";\n.say for ms(0)[^10];\n\n```\n\n```\nBSD LCG first 10 values (first one is the seed):\n0\n12345\n1406932606\n654583775\n1449466924\n229283573\n1109335178\n1051550459\n1293799192\n794471793\n\nMS LCG first 10 values (first one is the seed):\n0\n38\n7719\n21238\n2437\n8855\n11797\n8365\n32285\n10450\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay the current CPU utilization, as a percentage, calculated from  `/proc/stat`.\n\nBackground\n\nMost Linux kernels provide a virtual   `/proc`   filesystem, providing an interface to various internal data structures.\n\nOne of these internal structures (`/proc/stat`) includes information on the amount of time (in `USER_HZ`) spent in various states.   From this information, we can, with a little effort, determine the current level of CPU utilization, as a percent of time spent in any states other than *idle*.\n\nTo do this:\n\n:   :   :   1. read the first line of   `/proc/stat`\n            2. discard the first word of that first line   (it's always `cpu`)\n            3. sum all of the times found on that first line to get the total time\n            4. divide the fourth column (\"idle\") by the total time, to get the fraction of time spent being idle\n            5. subtract the previous fraction from 1.0 to get the time spent being   *not*   idle\n            6. multiple by   **100**   to get a percentage\n\nThe times in `/proc/stat` are monotonically increasing, and begin at some point during the kernel's initialization (ie during boot up).   So the steps above will give the total CPU utilization since boot, which may or may not be useful to some.   To get a more real-time utilization, we simply repeat the steps above with some small sleep interval in between, and instead of using the absolute total and idle times, we use use the total time delta and the idle time delta to compute the utilization.\n\nThis project is based on   this blog post   by Paul Colby,   and the   Bash   version comes from there."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $last-total = 0;\nmy $last-idle  = 0;\n\nloop {\n    my $Δ-total = (my $this-total = [+] my @cpu = \"/proc/stat\".IO.lines[0].words[1..*]) - $last-total;\n    my $Δ-idle  = (my $this-idle  = @cpu[3]) - $last-idle;\n    $last-total = $this-total;\n    $last-idle  = $this-idle;\n    print \"\\b\" x 40, (100 * (1 - $Δ-idle / $Δ-total)).fmt(\"Utilization: %0.1f%% \");\n    sleep(1);\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "A list comprehension is a special syntax in some programming languages to describe lists. It is similar to the way mathematicians describe sets, with a *set comprehension*, hence the name.\n\nSome attributes of a list comprehension are:\n\n1. They should be distinct from (nested) for loops and the use of map and filter functions within the syntax of the language.\n2. They should return either a list or an iterator (something that returns successive members of a collection, in order).\n3. The syntax has parts corresponding to that of set-builder notation.\n\nTask\n\nWrite a list comprehension that builds the list of all Pythagorean triples with elements between   **1**   and   **n**.\n\nIf the language has multiple ways for expressing such a construct (for example, direct list comprehensions and generators), write one example for each."}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku has single-dimensional list comprehensions that fall out naturally from nested modifiers; multidimensional comprehensions are also supported via the cross operator; however, Raku does not (yet) support multi-dimensional list comprehensions with dependencies between the lists, so the most straightforward way is currently:\n\n```\nmy $n = 20;\nsay gather for 1..$n -> $x {\n         for $x..$n -> $y {\n           for $y..$n -> $z {\n             take $x,$y,$z if $x*$x + $y*$y == $z*$z;\n           }\n         }\n       }\n\n```\n\nOutput:\n\n```\n((3 4 5) (5 12 13) (6 8 10) (8 15 17) (9 12 15) (12 16 20))\n```\n\nNote that gather/take is the primitive in Raku corresponding to generators or coroutines in other languages. It is not, however, tied to function call syntax in Raku. We can get away with that because lists are lazy, and the demand for more of the list is implicit; it does not need to be driven by function calls."}]}
{"messages": [{"role": "user", "content": "You came back from grocery shopping.   After putting away all the goods, you are left with a pile of plastic bags, which you want to save for later use, so you take one bag and stuff all the others into it, and throw it under the sink.   In doing so, you realize that there are various ways of nesting the bags, with all bags viewed as identical.\n\nIf we use a matching pair of parentheses to represent a bag, the ways are:\n\nFor 1 bag, there's one way:\n\n```\n ()\t<- a bag\n\n```\n\nfor 2 bags, there's one way:\n\n```\n (())\t<- one bag in another\n\n```\n\nfor 3 bags, there are two:\n\n```\n ((())) <- 3 bags nested Russian doll style\n (()()) <- 2 bags side by side, inside the third\n\n```\n\nfor 4 bags, four:\n\n```\n (()()())\n ((())())\n ((()()))\n (((())))\n\n```\n\nNote that because all bags are identical, the two 4-bag strings `((())())` and `(()(()))` represent the same configuration.\n\nIt's easy to see that each configuration for *n* bags represents a *n*-node rooted tree, where a bag is a tree node, and a bag with its content forms a subtree. The outermost bag is the tree root. Number of configurations for given *n* is given by OEIS A81.\n\nTask\n\nWrite a program that, when given *n*, enumerates all ways of nesting *n* bags.   You can use the parentheses notation above, or any tree representation that's unambiguous and preferably intuitive.\n\nThis task asks for enumeration of trees only; for counting solutions without enumeration, that OEIS page lists various formulas, but that's not encouraged by this task, especially if implementing it would significantly increase code size.\n\nAs an example output, run 5 bags.   There should be 9 ways."}, {"role": "assistant", "content": "(formerly Perl 6)\nBags are represented by Raku type Bag.\n\n```\nuse v6;\n\nmulti expand-tree ( Bag $tree ) {\n    bag(bag(bag()) (+) $tree) (+)\n    [(+)] (\n        $tree.keys ==> map {\n            $^a.&expand-tree.map: * (+) ( $tree (-) bag($^a) )\n        }\n    );\n}\n\nmulti expand-trees ( Bag $trees ) {\n    [(+)] $trees.keys.map:  { $_.&expand-tree } ;\n}      \n\nmy $n = 5;\nfor ( bag(), bag(bag()), *.&expand-trees ... * )[$n] {\n    print ++$,\".\\t\";\n    .say\n};\n\n```\n\nOutput:\n\n```\n1.\tbag(bag(), bag(bag()(2))) => 2\n2.\tbag(bag(bag()(3))) => 1\n3.\tbag(bag(bag(bag()), bag())) => 2\n4.\tbag(bag(bag(bag(bag())))) => 1\n5.\tbag(bag(bag())(2)) => 1\n6.\tbag(bag(bag(bag()(2)))) => 1\n7.\tbag(bag(), bag(bag(bag()))) => 2\n8.\tbag(bag(bag()), bag()(2)) => 2\n9.\tbag(bag()(4)) => 1\n\n```\n\nThe bag `bag(bag(bag()), bag()(2))` coresponds with `((())()())`. There are two independent ways how we can get it by nesting 4 bags."}]}
{"messages": [{"role": "user", "content": "Programming languages have different ways of expressing floating-point literals.\n\nTask\n\nShow how floating-point literals can be expressed in your language: decimal or other bases, exponential notation, and any other special features.\n\nYou may want to include a regular expression or BNF/ABNF/EBNF defining allowable formats for your language.\n\nRelated tasks\n\n* Literals/Integer\n* Extreme floating point values"}, {"role": "assistant", "content": "(formerly Perl 6)\nFloating point numbers (the Num type) are written in the standard 'e' scientific notation:\n\n```\n2e2      # same as 200e0, 2e2, 200.0e0  and 2.0e2\n6.02e23\n-2e48\n1e-9\n1e0\n\n```\n\nA number like 3.1416 is specifically not floating point, but rational (the Rat type), equivalent to 3927/1250. On the other hand, Num(3.1416) would be considered a floating literal though by virtue of mandatory constant folding."}]}
{"messages": [{"role": "user", "content": "Some programming languages have ways of expressing integer literals in bases other than the normal base ten.\n\nTask\n\nShow how integer literals can be expressed in as many bases as your language allows.\n\nNote:   this should **not** involve the calling of any functions/methods, but should be interpreted by the compiler or interpreter as an integer written to a given base.\n\nAlso show any other ways of expressing literals, e.g. for different types of integers.\n\nRelated task\n\n* Literals/Floating point"}, {"role": "assistant", "content": "(formerly Perl 6)\nThese all print 255.\n\n```\nsay 255;\nsay 0d255;\nsay 0xff;\nsay 0o377;\nsay 0b1111_1111;\n\nsay :10<255>;\nsay :16<ff>;\nsay :8<377>;\nsay :2<1111_1111>;\nsay :3<100110>;\nsay :4<3333>;\nsay :12<193>;\nsay :36<73>;\n```\n\nThere is a specced form for bases above 36, but rakudo does not yet implement it."}]}
{"messages": [{"role": "user", "content": "Task\n\nShow literal specification of characters and strings.\n\nIf supported, show how the following work:\n\n:   * *verbatim strings*   (quotes where escape sequences are quoted literally)\n    * *here-strings*\n\nAlso, discuss which quotes expand variables.\n\nRelated tasks\n\n* Special characters\n* Here document\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\nUnlike most languages that hardwire their quoting mechanisms, the quote mechanism in Raku is extensible, and all normal-looking quotes actually derive from a parent quoting language called Q via grammatical mixins, applied via standard Raku adverbial syntax.\nThe available quote mixins, straight from current spec S02, are:\n\n```\nShort       Long            Meaning\n=====       ====            =======\n:x          :exec           Execute as command and return results\n:w          :words          Split result on words (no quote protection)\n:ww         :quotewords     Split result on words (with quote protection)\n:v          :val            Evaluate word or words for value literals\n:q          :single         Interpolate \\\\, \\q and \\' (or whatever)\n:qq         :double         Interpolate with :s, :a, :h, :f, :c, :b\n:s          :scalar         Interpolate $ vars\n:a          :array          Interpolate @ vars\n:h          :hash           Interpolate % vars\n:f          :function       Interpolate & calls\n:c          :closure        Interpolate {...} expressions\n:b          :backslash      Interpolate \\n, \\t, etc. (implies :q at least)\n:to         :heredoc        Parse result as heredoc terminator\n            :regex          Parse as regex\n            :subst          Parse as substitution\n            :trans          Parse as transliteration\n            :code           Quasiquoting\n:p          :path           Return a Path object (see S16 for more options\n```\n\nIn any case, an initial Q, q, or qq may omit the initial colon to form traditional Perl quotes such as qw//.\nAnd Q can be used by itself to introduce a quote that has no escapes at all except for the closing delimiter:\n\n```\nmy $raw = Q'$@\\@#)&!#';\n```\n\nNote that the single quotes there imply no single quoting semantics as they would in Perl 5. They're just the quotes the programmer happened to choose, since they were most like the raw quoting. Single quotes imply :q only when used as normal single quotes are, as discussed below.\nAs in Perl 5, you can use any non-alphanumeric, non-whitespace characters for delimiters with the general forms of quoting, including matching bracket characters, including any Unicode brackets.\n\nUsing the definitions above, we can derive the various standard \"sugar\" quotes from Q, including:\n\n```\nNormal  Means\n======  =====\nq/.../  Q :q /.../\nqq/.../ Q :qq /.../\n'...'   Q :q /.../\n\"...\"   Q :qq /.../\n<...>   Q :q :w :v /.../\n«...»   Q :qq :ww :v /.../\n/.../   Q :regex /.../\nquasi {...} Q :code {...}\n```\n\nThe :qq-derived languages all give normal Perlish interpolation, but individual interpolations may be chosen or suppressed with extra adverbs.\n\nUnlike in Perl 5, we don't use backticks as shorthand for what is now expressed as qqx// in Raku.\n(Backticks are now reserved for user-defined syntax.)\nHeredocs now have no special << syntax,\nbut fall out of the :to adverb:\n\n```\nsay qq:to/END/;\n    Your ad here.\n    END\n```\n\nIndentation equivalent to the ending tag is automatically removed.\n\nBackslash sequences recognized by :b (and hence :qq) include:\n\n```\n\"\\a\"        # BELL\n\"\\b\"        # BACKSPACE\n\"\\t\"        # TAB\n\"\\n\"        # LINE FEED\n\"\\f\"        # FORM FEED\n\"\\r\"        # CARRIAGE RETURN\n\"\\e\"        # ESCAPE\n\"\\x263a\"    # ☺\n\"\\o40\"      # SPACE\n\"\\0\"        # NULL\n\n\"\\cC\"       # CTRL-C\n\"\\c8\"       # BACKSPACE\n\"\\c[13,10]\" # CRLF\n\"\\c[LATIN CAPITAL LETTER A, COMBINING RING ABOVE]\"\n```\n\nLeading 0 specifically does not mean octal in Perl 6;\nyou must use \\o instead."}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function that takes two logical (boolean) values, and outputs the result of \"and\" and \"or\" on both arguments as well as \"not\" on the first arguments.\n\nIf the programming language doesn't provide a separate type for logical values, use the type most commonly used for that purpose.\n\nIf the language supports additional logical operations on booleans such as XOR, list them as well."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku has an abundance of logical operators for various purposes.\n\n```\nsub logic($a,$b) {\n    say \"$a && $b is \", $a && $b;     # short-circuiting\n    say \"$a || $b is \", $a || $b;     # short-circuiting\n    say \"$a ^^ $b is \", $a ^^ $b;\n    say \"!$a is \",     !$a;\n\n    say \"$a ?& $b is \", $a ?& $b;     # non-short-circuiting\n    say \"$a ?| $b is \", $a ?| $b;     # non-short-circuiting\n    say \"$a ?^ $b is \", $a ?^ $b;     # non-short-circuiting\n\n    say \"$a +& $b is \", $a +& $b;     # numeric bitwise\n    say \"$a +| $b is \", $a +| $b;     # numeric bitwise\n    say \"$a +^ $b is \", $a +^ $b;     # numeric bitwise\n\n    say \"$a ~& $b is \", $a ~& $b;     # buffer bitwise\n    say \"$a ~| $b is \", $a ~| $b;     # buffer bitwise\n    say \"$a ~^ $b is \", $a ~| $b;     # buffer bitwise\n\n    say \"$a & $b is \", $a & $b;       # junctional/autothreading\n    say \"$a | $b is \", $a | $b;       # junctional/autothreading\n    say \"$a ^ $b is \", $a ^ $b;       # junctional/autothreading\n\n    say \"$a and $b is \", ($a and $b); # loose short-circuiting\n    say \"$a or $b is \",  ($a or $b);  # loose short-circuiting\n    say \"$a xor $b is \", ($a xor $b);\n    say \"not $a is \",    (not $a);\n}\n\nlogic(3,10);\n\n```\n\nOutput:\n\n```\n3 && 10 is 10\n3 || 10 is 3\n3 ^^ 10 is Nil\n!3 is False\n3 ?& 10 is True\n3 ?| 10 is True\n3 ?^ 10 is False\n3 +& 10 is 2\n3 +| 10 is 11\n3 +^ 10 is 9\n3 ~& 10 is 1\n3 ~| 10 is 30\n3 ~^ 10 is 30\n3 & 10 is all(3, 10)\n3 | 10 is any(3, 10)\n3 ^ 10 is one(3, 10)\n3 and 10 is 10\n3 or 10 is 3\n3 xor 10 is Nil\nnot 3 is False\n```"}]}
{"messages": [{"role": "user", "content": "The least-squares method (see references below) in statistics is used to fit data\nto the best of a family of similar curves by finding the parameters for a curve\nwhich minimizes the total of the distances from each data point to the curve.\n\nOften, the curve used is a straight line, in which case the method is also called\nlinear regression. If a curve which uses logarithmic growth is fit, the method can be\ncalled logistic regression.\n\nA commonly used family of functions used in statistical studies of populations,\nincluding the growth of epidemics, are curves akin to the logistic curve:\n\n```\n        ƒ(x) = L / (1 + e-k(x-x0)) \n\n```\n\nThough predictions based on fitting to such curves may error, especially if used to\nextrapolate from incomplete data, curves similar to the logistic curve have had\ngood fits in population studies, including modeling the growth of past epidemics.\n\nGiven the following daily world totals since  December 31, 2019  for persons who have become infected with the novel coronavirus Covid-19:\n\n```\nDaily totals:\n27, 27, 27, 44, 44, 59, 59, 59, 59, 59, 59, 59, 59, 60, 60,\n61, 61, 66, 83, 219, 239, 392, 534, 631, 897, 1350, 2023, 2820,\n4587, 6067, 7823, 9826, 11946, 14554, 17372, 20615, 24522, 28273,\n31491, 34933, 37552, 40540, 43105, 45177, 60328, 64543, 67103,\n69265, 71332, 73327, 75191, 75723, 76719, 77804, 78812, 79339, \n80132, 80995, 82101, 83365, 85203, 87024, 89068, 90664, 93077, \n95316, 98172, 102133, 105824, 109695, 114232, 118610, 125497, \n133852, 143227, 151367, 167418, 180096, 194836, 213150, 242364, \n271106, 305117, 338133, 377918, 416845, 468049, 527767, 591704, \n656866, 715353, 777796, 851308, 928436, 1000249, 1082054, 1174652\n\n```\n\nUse the following variant of the logistic curve as a formula:\n\n```\n        ƒ(t) = n0 e(r t) / ((1 + n0 (e(r t) - 1) / K) \n\n```\n\nWhere:\n\n:   :   * **r**    is the rate of growth of the infection in the population.\n        * **K**    is the world population, about 7.8 billion.\n        * **n0**    is 27, the number of cases found in China at the start of the pandemic.\n\nThe    **R0**    of an infection (different from   **r**   above) is a measure of how many\nnew individuals will become infected for every individual currently infected.\nIt is an important measure of how quickly an infectious disease may spread.\n\n**R0**   is related to the logistic curve's   **r**   parameter by the formula:\n\n```\n        r ≈ ln(R0) / G \n\n```\n\nwhere    **G**    the generation time, is roughly the sum of the incubation time, perhaps 5 days, and\nthe mean contagion period, perhaps 7 days, so, for covid-19, roughly we have:\n\n```\n        R0 ≈ e12r \n\n```\n\nTask\n\n* Demonstrate code that finds a least-squares fits of the curve to the data.\n* Show the calculated    **r**    for the logistic curve.\n* Show the final    **R0**    parameter you calculate from the logistic curve    **r**    value parameter.\n\nSee also\n:   * [Basic reproduction number] * [Logistic functions] * [Least squares] * [World covid-19 case tallies] * [Calculating r and R0]"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.05\n\n**Translation of**: Perl\n\nOriginal task numbers of cases per day as of April 05 plus updated, as of today, May 11 numbers.\n\n```\nmy $K  = 7_800_000_000; #  population\nmy $n0 = 27;            #  cases @ day 0\n\nmy @Apr05 = <\n         27      27      27      44      44      59      59      59      59      59\n         59      59      59      60      60      61      61      66      83     219\n        239     392     534     631     897    1350    2023    2820    4587    6067\n       7823    9826   11946   14554   17372   20615   24522   28273   31491   34933\n      37552   40540   43105   45177   60328   64543   67103   69265   71332   73327\n      75191   75723   76719   77804   78812   79339   80132   80995   82101   83365\n      85203   87024   89068   90664   93077   95316   98172  102133  105824  109695\n     114232  118610  125497  133852  143227  151367  167418  180096  194836  213150\n     242364  271106  305117  338133  377918  416845  468049  527767  591704  656866\n     715353  777796  851308  928436 1000249 1082054 1174652\n>;\n\nmy @May11 = <\n         27      27      27      44      44      59      59      59      59      59\n         59      59      59      60      60      61      61      66      83     219\n        239     392     534     631     897    1350    2023    2820    4587    6067\n       7823    9826   11946   14554   17372   20615   24522   28273   31491   34933\n      37552   40540   43105   45177   60328   64543   67103   69265   71332   73327\n      75191   75723   76719   77804   78812   79339   80132   80995   82101   83365\n      85203   87026   89068   90865   93077   95316   98172  102133  105824  109695\n     114235  118613  125497  133853  143259  154774  167418  180094  194843  213149\n     242374  271116  305235  338235  377968  416881  468092  527839  591796  656834\n     715377  777187  851587  928491 1006063 1087822 1174306 1245601 1316988 1391881\n    1476792 1563819 1653160 1734868 1807256 1873639 1953786 2033745 2117297 2199460\n    2278484 2350993 2427353 2513399 2579823 2657910 2731217 2832750 2915977 2981542\n    3054404 3131487 3216467 3308341 3389459 3468047 3545486 3624789 3714816 3809262\n    3899379 3986931 4063525\n>;\n\nsub logistic-func ($rate, @y) {\n    my $sq = 0;\n    for ^@y -> $time {\n        my $ert = exp($rate * $time);\n        my $δt = ($n0 * $ert) / (1 + $n0 * ($ert-1) / $K) - @y[$time];\n        $sq += $δt²;\n    }\n    $sq\n}\n\nsub solve (&f, $guess, \\ε, @y) {\n    my $fₙ-minus;\n    my $fₙ-plus;\n    my $rate   = $guess;\n    my $fₙ     = f $rate, @y;\n    my $Δ      = $rate;\n    my $factor = 2;\n    while $Δ > ε {\n        ($fₙ-minus = f $rate - $Δ, @y) < $fₙ ??\n        do {\n            $fₙ    = $fₙ-minus;\n            $rate -= $Δ;\n            $Δ    *= $factor;\n        } !!\n        ($fₙ-plus = f $rate + $Δ, @y) < $fₙ ??\n        do {\n            $fₙ    = $fₙ-plus;\n            $rate += $Δ;\n            $Δ    *= $factor;\n        } !!\n        $Δ /= $factor\n    }\n    $rate\n}\n\nfor @Apr05, 'Dec 31 - Apr 5',\n    @May11, 'Dec 31 - May 11' -> @y, $period {\n    my $rate = solve(&logistic-func, 0.5, 0, @y);\n    my $R0   = exp(12 * $rate);\n    say \"\\nFor period: $period\";\n    say \"Instantaneous rate of growth: r = \" , $rate.fmt('%08f');\n    say \"Reproductive rate: R0 = \", $R0.fmt('%08f');\n}\n\n```\n\nOutput:\n\n```\nFor period: Dec 31 - Apr 5\nInstantaneous rate of growth: r = 0.112302\nReproductive rate: R0 = 3.848279\n\nFor period: Dec 31 - May 11\nInstantaneous rate of growth: r = 0.093328\nReproductive rate: R0 = 3.064672\n```"}]}
{"messages": [{"role": "user", "content": "This task is about writing a computer program that has long literals   (character\nliterals that may require specifying the words/tokens on more than one (source)\nline,   either with continuations or some other method, such as abutments or\nconcatenations   (or some other mechanisms).\n\nThe literal is to be in the form of a \"list\",   a literal that contains many\nwords (tokens) separated by a blank (space),   in this case   (so as to have a\ncommon list),   the (English) names of the chemical elements of the periodic table.\n\nThe list is to be in (ascending) order of the (chemical) element's atomic number:\n\n```\nhydrogen helium lithium beryllium boron carbon nitrogen oxygen fluorine neon sodium aluminum silicon ...\n\n```\n\n... up to the last known (named) chemical element   (at this time).\n\nDo not include any of the   \"unnamed\"   chemical element names such as:\n\n```\nununennium unquadnilium triunhexium penthextrium penthexpentium septhexunium octenntrium ennennbium\n\n```\n\nTo make computer programming languages comparable,   the statement widths should be\nrestricted to less than   **81**   bytes (characters),   or less\nif a computer programming language has more restrictive limitations or standards.\n\nAlso mention what column the programming statements can start in if   *not*  \nin column one.\n\nThe list   *may*   have leading/embedded/trailing blanks during the\ndeclaration   (the actual program statements),   this allows the list to be\nmore readable.   The \"final\" list shouldn't have any leading/trailing or superfluous\nblanks   (when stored in the program's \"memory\").\n\nThis list should be written with the idea in mind that the\nprogram   *will*   be updated,   most likely by someone other than the\noriginal author,   as there will be newer (discovered) elements of the periodic\ntable being added   (possibly in the near future).   These future updates\nshould be one of the primary concerns in writing these programs and it should be \"easy\"\nfor someone else to add chemical elements to the list   (within the computer\nprogram).\n\nAttention should be paid so as to not exceed the   *clause length*   of\ncontinued or specified statements,   if there is such a restriction.   If the\nlimit is greater than (say) 4,000 bytes or so,   it needn't be mentioned here.\n\nTask\n:   * Write a computer program (by whatever name) to contain a list of the known elements.\n    * The program should eventually contain a long literal of words   (the elements).\n    * The literal should show how one could create a long list of blank-delineated words.\n    * The \"final\" (stored) list should only have a single blank between elements.\n    * Try to use the most idiomatic approach(es) in creating the final list.\n    * Use continuation if possible, and/or show alternatives   (possibly using concatenation).\n    * Use a program comment to explain what the continuation character is if it isn't obvious.\n    * The program should contain a variable that has the date of the last update/revision.\n    * The program, when run, should display with verbiage:\n\n    :   :   * The last update/revision date   (and should be unambiguous).\n            * The number of chemical elements in the list.\n            * The name of the highest (last) element name.\n\nShow all output here, on this page.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "|  |\n| --- |\n| This example is **incorrect**. Please fix the code and remove this message.  ***Details:*** The task is to have a list of the names of the elements, not their atomic weight and chemical element symbol.   Also, the element names are not capitalized. |\n\nIncorrectly marked incorrect. Enforcing rules that exists only in somebodies head.\n\n**Works with**: Rakudo version 2020.02\n\nNot really sure I understand the point of this task. Seems to be load some list into memory and manipulate it somehow. Exceptionally boring to just read it in and then read it back out again. Perform some more interesting manipulations. Use < > quoting construct for literal string; unlimited (memory limited) characters, spaces don't matter, new-lines don't matter, blank lines don't matter.\n\n```\nmy %periodic;\n%periodic<revision-date> = Date.new(2020,3,23);\n%periodic<table> = |<\n\n         Hydrogen  1.0079     H             Helium  4.0026    He\n          Lithium  6.941     Li          Beryllium  9.0122    Be\n            Boron  10.811     B             Carbon  12.0107    C\n         Nitrogen  14.0067    N             Oxygen  15.9994    O\n         Fluorine  18.9984    F               Neon  20.1797   Ne\n           Sodium  22.9897   Na          Magnesium  24.305    Mg\n         Aluminum  26.9815   Al            Silicon  28.0855   Si\n       Phosphorus  30.9738    P             Sulfur  32.065     S\n         Chlorine  35.453    Cl          Potassium  39.0983    K\n            Argon  39.948    Ar            Calcium  40.078    Ca\n         Scandium  44.9559   Sc           Titanium  47.867    Ti\n         Vanadium  50.9415    V           Chromium  51.9961   Cr\n        Manganese  54.938    Mn               Iron  55.845    Fe\n           Nickel  58.6934   Ni             Cobalt  58.9332   Co\n           Copper  63.546    Cu               Zinc  65.39     Zn\n          Gallium  69.723    Ga          Germanium  72.64     Ge\n          Arsenic  74.9216   As           Selenium  78.96     Se\n          Bromine  79.904    Br            Krypton  83.8      Kr\n         Rubidium  85.4678   Rb          Strontium  87.62     Sr\n          Yttrium  88.9059    Y          Zirconium  91.224    Zr\n          Niobium  92.9064   Nb         Molybdenum  95.94     Mo\n       Technetium  98        Tc          Ruthenium  101.07    Ru\n          Rhodium  102.9055  Rh          Palladium  106.42    Pd\n           Silver  107.8682  Ag            Cadmium  112.411   Cd\n           Indium  114.818   In                Tin  118.71    Sn\n         Antimony  121.76    Sb             Iodine  126.9045   I\n        Tellurium  127.6     Te              Xenon  131.293   Xe\n           Cesium  132.9055  Cs             Barium  137.327   Ba\n        Lanthanum  138.9055  La             Cerium  140.116   Ce\n     Praseodymium  140.9077  Pr          Neodymium  144.24    Nd\n       Promethium  145       Pm           Samarium  150.36    Sm\n         Europium  151.964   Eu         Gadolinium  157.25    Gd\n          Terbium  158.9253  Tb         Dysprosium  162.5     Dy\n          Holmium  164.9303  Ho             Erbium  167.259   Er\n          Thulium  168.9342  Tm          Ytterbium  173.04    Yb\n         Lutetium  174.967   Lu            Hafnium  178.49    Hf\n         Tantalum  180.9479  Ta           Tungsten  183.84     W\n          Rhenium  186.207   Re             Osmium  190.23    Os\n          Iridium  192.217   Ir           Platinum  195.078   Pt\n             Gold  196.9665  Au            Mercury  200.59    Hg\n         Thallium  204.3833  Tl               Lead  207.2     Pb\n          Bismuth  208.9804  Bi           Polonium  209       Po\n         Astatine  210       At              Radon  222       Rn\n         Francium  223       Fr             Radium  226       Ra\n         Actinium  227       Ac       Protactinium  231.0359  Pa\n          Thorium  232.0381  Th          Neptunium  237       Np\n          Uranium  238.0289   U          Americium  243       Am\n        Plutonium  244       Pu             Curium  247       Cm\n        Berkelium  247       Bk        Californium  251       Cf\n      Einsteinium  252       Es            Fermium  257       Fm\n      Mendelevium  258       Md           Nobelium  259       No\n    Rutherfordium  261       Rf         Lawrencium  262       Lr\n          Dubnium  262       Db            Bohrium  264       Bh\n       Seaborgium  266       Sg         Meitnerium  268       Mt\n      Roentgenium  272       Rg            Hassium  277       Hs\n     Darmstadtium  ???       Ds        Copernicium  ???       Cn\n         Nihonium  ???       Nh          Flerovium  ???       Fl\n        Moscovium  ???       Mc        Livermorium  ???       Lv\n       Tennessine  ???       Ts          Oganesson  ???       Og\n\n>.words.map: { (:name($^a), :weight($^b), :symbol($^c)).hash };\n\nput 'Revision date: ',                                   %periodic<revision-date>;\nput 'Last element by position (nominally by weight): ',  %periodic<table>.tail.<name>;\nput 'Total number of elements: ',                        %periodic<table>.elems;\nput 'Last element sorted by full name: ',                %periodic<table>.sort( *.<name> ).tail.<name>;\nput 'Longest element name: ',                            %periodic<table>.sort( *.<name>.chars ).tail.<name>;\nput 'Shortest element name: ',                           %periodic<table>.sort( -*.<name>.chars ).tail.<name>;\nput 'Symbols for elements whose name starts with \"P\": ', %periodic<table>.grep( *.<name>.starts-with('P') )».<symbol>;\nput \"Elements with molecular weight between 20 & 40:\\n \",%periodic<table>.grep( {+.<weight> ~~ Numeric and 20 < .<weight> < 40} )».<name>;\nput \"SCRN: \",                                            %periodic<table>[87,17,92]».<symbol>.join.tclc;\n\n```\n\nOutput:\n\n```\nRevision date: 2020-03-23\nLast element by position (nominally by weight): Oganesson\nTotal number of elements: 118\nLast element sorted by full name: Zirconium\nLongest element name: Rutherfordium\nShortest element name: Tin\nSymbols for elements whose name starts with \"P\": P K Pd Pr Pm Pt Po Pa Pu\nElements with molecular weight between 20 & 40:\n Neon Sodium Magnesium Aluminum Silicon Phosphorus Sulfur Chlorine Potassium Argon\nSCRN: Raku\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nExplicitly implement   long multiplication.\n\nThis is one possible approach to arbitrary-precision integer algebra.\n\nFor output, display the result of    264 \\* 264.\n\nOptionally, verify your result against builtin arbitrary precision support.\n\nThe decimal representation of    264    is:\n\n```\n18,446,744,073,709,551,616\n\n```\n\nThe output of    264 \\* 264    is    2128,    and is:\n\n```\n340,282,366,920,938,463,463,374,607,431,768,211,456\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-17\n\nFor efficiency (and novelty), this program explicitly implements long multiplication, but in base 10000. That base was chosen because multiplying two 5-digit numbers can overflow a 32-bit integer, but two 4-digit numbers cannot.\n\n```\nsub num_to_groups ( $num ) { $num.flip.comb(/.**1..4/)».flip     };\nsub groups_to_num ( @g   ) { [~] flat @g.pop, @g.reverse».fmt('%04d') };\n\nsub long_multiply ( Str $x, Str $y ) {\n    my @group_sums;\n    for flat num_to_groups($x).pairs X num_to_groups($y).pairs -> $xp, $yp {\n        @group_sums[ $xp.key + $yp.key ] += $xp.value * $yp.value;\n    }\n\n    for @group_sums.keys -> $k {\n        next if @group_sums[$k] < 10000;\n        @group_sums[$k+1] += @group_sums[$k].Int div 10000;\n        @group_sums[$k] %= 10000;\n    }\n\n    return groups_to_num @group_sums;\n}\n\nmy $str = '18446744073709551616';\nlong_multiply( $str, $str ).say;\n\n# cross-check with native implementation\nsay +$str * +$str;\n\n```\n\nOutput:\n\n```\n340282366920938463463374607431768211456\n340282366920938463463374607431768211456\n\n```"}]}
{"messages": [{"role": "user", "content": "A   **long prime**   (as defined here)   is a prime number whose reciprocal   (in decimal)   has\na   *period length*   of one less than the prime number.\n\n**Long primes**   are also known as:\n\n:   :   :   * base ten cyclic numbers\n            * full reptend primes\n            * golden primes\n            * long period primes\n            * maximal period primes\n            * proper primes\n\nAnother definition:   primes   **p**   such that the decimal expansion of   **1/p**   has period   **p-1**,   which is the greatest period possible for any integer.\n\nExample\n\n**7**   is the first long prime,   the reciprocal of seven\nis   **1****/****7**,   which\nis equal to the repeating decimal fraction   **0.142857142857···**\n\nThe length of the   *repeating*   part of the decimal fraction\nis six,   (the underlined part)   which is one less\nthan the (decimal) prime number   **7**.\n  \nThus   **7**   is a long prime.\n\nThere are other (more) general definitions of a   **long prime**   which\ninclude wording/verbiage for bases other than ten.\n\nTask\n:   * Show all long primes up to   **500**   (preferably on one line).\n    * Show the   *number*   of long primes up to         **500**\n    * Show the   *number*   of long primes up to      **1,000**\n    * Show the   *number*   of long primes up to      **2,000**\n    * Show the   *number*   of long primes up to      **4,000**\n    * Show the   *number*   of long primes up to      **8,000**\n    * Show the   *number*   of long primes up to   **16,000**\n    * Show the   *number*   of long primes up to   **32,000**\n    * Show the   *number*   of long primes up to   **64,000**   (optional)\n    * Show all output here.\n\nAlso see\n\n* Wikipedia: full reptend prime\n* MathWorld: full reptend prime\n* OEIS: A001913"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.06\n\nNot very fast as the numbers get larger.\n\n```\nuse Math::Primesieve;\nmy $sieve = Math::Primesieve.new;\n\nsub is-long (Int $p) {\n    my $r = 1;\n    my $rr = $r = (10 * $r) % $p for ^$p;\n    my $period;\n    loop {\n        $r = (10 * $r) % $p;\n        ++$period;\n        last if $period >= $p or $r == $rr;\n    }\n    $period == $p - 1 and $p > 2;\n}\n\nmy @primes = $sieve.primes(500);\nmy @long-primes = @primes.grep: {.&is-long};\n\nput \"Long primes ≤ 500:\\n\", @long-primes;\n\n@long-primes = ();\n\nfor 500, 1000, 2000, 4000, 8000, 16000, 32000, 64000 -> $upto {\n    state $from = 0;\n    my @extend = $sieve.primes($from, $upto);\n    @long-primes.append: @extend.hyper(:8degree).grep: {.&is-long};\n    say \"\\nNumber of long primes ≤ $upto: \", +@long-primes;\n    $from = $upto;\n}\n\n```\n\nOutput:\n\n```\nLong primes ≤ 500:\n7 17 19 23 29 47 59 61 97 109 113 131 149 167 179 181 193 223 229 233 257 263 269 313 337 367 379 383 389 419 433 461 487 491 499\n\nNumber of long primes ≤ 500: 35\n\nNumber of long primes ≤ 1000: 60\n\nNumber of long primes ≤ 2000: 116\n\nNumber of long primes ≤ 4000: 218\n\nNumber of long primes ≤ 8000: 390\n\nNumber of long primes ≤ 16000: 716\n\nNumber of long primes ≤ 32000: 1300\n\nNumber of long primes ≤ 64000: 2430\n```"}]}
{"messages": [{"role": "user", "content": "An evil wizard has trapped you in the stairwell of his castle. Your only hope of escape is to run up all 100 steps to reach the top, and you can run one step per second. Unfortunately the wizard uses magic to lengthen the staircase by five steps per second. The new steps are inserted randomly between existing steps, so if you're lucky some of them might be beneath you and not ahead of you.\n\nCan you escape, or are you doomed to run up an ever-lengthening staircase forever?\n\nWrite a program to simulate your escape attempt. How are you doing after ten minutes? For every second between 600 and 609 seconds inclusive print the number of steps behind you and the number still ahead of you.\n\nIf you escaped, run 10,000 tests and print the average time taken and the average final length of the staircase."}, {"role": "assistant", "content": "```\nmy ($trials, $t-total, $s-total) = 10000;\n\nsay 'Seconds  steps behind  steps ahead';\n\nrace for ^$trials {\n    my $stairs   = 100;\n    my $location = 0;\n    my $seconds  = 0;\n\n    loop {\n        ++$seconds;\n        ++$location;\n        last if $location > $stairs;\n        for (1..$stairs).roll(5) {\n            ++$location if $_ <= $location;\n            ++$stairs;\n        }\n        say \"  $seconds        $location         {$stairs-$location}\" if !$_ && (599 < $seconds < 610);\n    }\n\n    $t-total += $seconds;\n    $s-total += $stairs;\n}\n\nsay \"Average seconds: {$t-total/$trials},  Average steps: {$s-total/$trials}\";\n\n```\n\nSample output:\n\n```\nSeconds  steps behind  steps ahead\n  600        2143         957\n  601        2149         956\n  602        2153         957\n  603        2158         957\n  604        2164         956\n  605        2170         955\n  606        2175         955\n  607        2178         957\n  608        2183         957\n  609        2187         958\nAverage seconds: 2716.0197,  Average steps: 13677.143\n```"}]}
{"messages": [{"role": "user", "content": "Most years have 52 weeks, some have 53, according to ISO8601.\n\nTask\n\nWrite a function which determines if a given year is long (53 weeks) or not, and demonstrate it."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\nDecember 28 is always in the last week of the year. (By ISO8601)\n\n```\nsub is-long ($year) { Date.new(\"$year-12-28\").week[1] == 53 }\n\n# Testing\nsay   \"Long years in the 20th century:\\n\", (1900..^2000).grep: &is-long;\nsay \"\\nLong years in the 21st century:\\n\", (2000..^2100).grep: &is-long;\nsay \"\\nLong years in the 22nd century:\\n\", (2100..^2200).grep: &is-long;\n\n```\n\nOutput:\n\n```\nLong years in the 20th century:\n(1903 1908 1914 1920 1925 1931 1936 1942 1948 1953 1959 1964 1970 1976 1981 1987 1992 1998)\n\nLong years in the 21st century:\n(2004 2009 2015 2020 2026 2032 2037 2043 2048 2054 2060 2065 2071 2076 2082 2088 2093 2099)\n\nLong years in the 22nd century:\n(2105 2111 2116 2122 2128 2133 2139 2144 2150 2156 2161 2167 2172 2178 2184 2189 2195)\n```"}]}
{"messages": [{"role": "user", "content": "It is often useful to find the common prefix of a set of strings, that is, the longest initial portion of all strings that are identical.\n\nGiven a set of strings, *R*, for a prefix *S*, it should hold that:\n\n:   ∀\n    x\n     \n    ∈\n     \n    R\n    :\n     \n    S\n    ≤\n    {\\displaystyle {\\displaystyle \\forall x\\ \\in \\ R:\\ S\\leq }}\n    pref \n\n     \n    x\n    {\\displaystyle {\\displaystyle \\ x}}\n     ~ \"for all members *x* of set *R*, it holds true that string *S* is a prefix of *x*\"\n:   (help here: *does not express that* S *is the longest common prefix of* x)\n\nAn example use case for this: given a set of phone numbers, identify a common dialing code. This can be accomplished by first determining the common prefix (if any), and then matching it against know dialing codes (iteratively dropping characters from rhs until a match is found, as the *lcp* function may match more than the dialing code).\n\nTest cases\n\nFor a function, *lcp*, accepting a list of strings, the following should hold true\n(the empty string, \n\nε\n{\\displaystyle {\\displaystyle \\varepsilon }}\n, is considered a prefix of all strings):\n\n```\nlcp(\"interspecies\",\"interstellar\",\"interstate\") = \"inters\"\nlcp(\"throne\",\"throne\") = \"throne\"\nlcp(\"throne\",\"dungeon\") = \n  \n    \n      \n        \n          \n            ε\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\varepsilon }}\n  \n\nlcp(\"throne\",\n  \n    \n      \n        \n          \n            ε\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\varepsilon }}\n  \n,\"throne\") = \n  \n    \n      \n        \n          \n            ε\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\varepsilon }}\n  \n\nlcp(\"cheese\") = \"cheese\"\nlcp(\n  \n    \n      \n        \n          \n            ε\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\varepsilon }}\n  \n) = \n  \n    \n      \n        \n          \n            ε\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\varepsilon }}\n  \n\nlcp(\n  \n    \n      \n        \n          \n            ∅\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\emptyset }}\n  \n) = \n  \n    \n      \n        \n          \n            ε\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\varepsilon }}\n  \n\nlcp(\"prefix\",\"suffix\") = \n  \n    \n      \n        \n          \n            ε\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\varepsilon }}\n  \n\nlcp(\"foo\",\"foobar\") = \"foo\"\n\n```\n\n*Task inspired by this stackoverflow question*: Find the longest common starting substring in a set of strings\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-11-28\n\nThis should work on infinite strings (if and when we get them), since .ords is lazy. In any case, it does just about the minimal work by evaluating all strings lazily in parallel. A few explanations of the juicy bits: @s is the list of strings, and the hyper operator » applies the .ords to each of those strings, producing a list of lists. The | operator inserts each of those sublists as an argument into an argument list so that we can use a reduction operator across the list of lists, which makes sense if the operator in question knows how to deal with list arguments. In this case we use the Z ('zip') metaoperator with eqv as a base operator, which runs eqv across all the lists in parallel for each position, and will fail if not all the lists have the same ordinal value at that position, or if any of the strings run out of characters. Then we count up the leading matching positions and carve up one of the strings to that length.\n\n```\nmulti lcp()    { '' }\nmulti lcp($s)  { ~$s }\nmulti lcp(*@s) { substr @s[0], 0, [+] [\\and] [Zeqv] |@s».ords }\n\nuse Test;\nplan 8;\n\nis lcp(\"interspecies\",\"interstellar\",\"interstate\"), \"inters\";\nis lcp(\"throne\",\"throne\"), \"throne\";\nis lcp(\"throne\",\"dungeon\"), '';\nis lcp(\"cheese\"), \"cheese\";\nis lcp(''), '';\nis lcp(), '';\nis lcp(\"prefix\",\"suffix\"), '';\nis lcp(\"foo\",\"foobar\"), 'foo';\n\n```\n\nOutput:\n\n```\n1..8\nok 1 - \nok 2 - \nok 3 - \nok 4 - \nok 5 - \nok 6 - \nok 7 - \nok 8 - \n```"}]}
{"messages": [{"role": "user", "content": "**Introduction**\n\nDefine a *subsequence* to be any output string obtained by deleting zero or more symbols from an input string.\n\nThe Longest Common Subsequence (**LCS**) is a subsequence of maximum length common to two or more strings.\n\nLet *A* ≡ *A*[0]… *A*[m - 1] and *B* ≡ *B*[0]… *B*[n - 1], m < n be strings drawn from an alphabet Σ of size s, containing every distinct symbol in A + B.\n\nAn ordered pair (i, j) will be referred to as a match if *A*[i] = *B*[j], where 0 ≤ i < m and 0 ≤ j < n.\n\nThe set of matches **M** defines a relation over matches: **M**[i, j] ⇔ (i, j) ∈ **M**.\n\nDefine a *non-strict* product-order (≤) over ordered pairs, such that (i1, j1) ≤ (i2, j2) ⇔ i1 ≤ i2 and j1 ≤ j2. We define (≥) similarly.\n\nWe say ordered pairs p1 and p2 are *comparable* if either p1 ≤ p2 or p1 ≥ p2 holds. If i1 < i2 and j2 < j1 (or i2 < i1 and j1 < j2) then neither p1 ≤ p2 nor p1 ≥ p2 are possible, and we say p1 and p2 are *incomparable*.\n\nDefine the *strict* product-order (<) over ordered pairs, such that (i1, j1) < (i2, j2) ⇔ i1 < i2 and j1 < j2. We define (>) similarly.\n\nA chain **C** is a subset of **M** consisting of at least one element m; and where either m1 < m2 or m1 > m2 for every pair of distinct elements m1 and m2. An antichain **D** is any subset of **M** in which every pair of distinct elements m1 and m2 are incomparable.\n\nA chain can be visualized as a strictly increasing curve that passes through matches (i, j) in the m\\*n coordinate space of **M**[i, j].\n\nEvery Common Sequence of length *q* corresponds to a chain of cardinality *q*, over the set of matches **M**. Thus, finding an LCS can be restated as the problem of finding a chain of maximum cardinality *p*.\n\nAccording to [Dilworth 1950], this cardinality *p* equals the minimum number of disjoint antichains into which **M** can be decomposed. Note that such a decomposition into the minimal number p of disjoint antichains may not be unique.\n\n**Background**\n\nWhere the number of symbols appearing in matches is small relative to the length of the input strings, reuse of the symbols increases; and the number of matches will tend towards O(*m\\*n*) quadratic growth. This occurs, for example, in the Bioinformatics application of nucleotide and protein sequencing.\n\nThe divide-and-conquer approach of [Hirschberg 1975] limits the space required to O(*n*). However, this approach requires O(*m\\*n*) time even in the best case.\n\nThis quadratic time dependency may become prohibitive, given very long input strings. Thus, heuristics are often favored over optimal Dynamic Programming solutions.\n\nIn the application of comparing file revisions, records from the input files form a large symbol space; and the number of symbols approaches the length of the LCS. In this case the number of matches reduces to linear, O(*n*) growth.\n\nA binary search optimization due to [Hunt and Szymanski 1977] can be applied to the basic Dynamic Programming approach, resulting in an expected performance of O(*n log m*). Performance can degrade to O(*m\\*n log m*) time in the worst case, as the number of matches grows to O(*m\\*n*).\n\n**Note**\n\n[Rick 2000] describes a linear-space algorithm with a time bound of O(*n\\*s + p\\*min(m, n - p)*).\n\n**Legend**\n\n```\nA, B are input strings of lengths m, n respectively\np is the length of the LCS\nM is the set of matches (i, j) such that A[i] = B[j]\nr is the magnitude of M\ns is the magnitude of the alphabet Σ of distinct symbols in A + B\n\n```\n\n**References**\n\n[Dilworth 1950] \"A decomposition theorem for partially ordered sets\"\nby Robert P. Dilworth, published January 1950,\nAnnals of Mathematics [Volume 51, Number 1, *pp.* 161-166]\n\n[Goeman and Clausen 2002] \"A New Practical Linear Space Algorithm for the Longest Common\nSubsequence Problem\" by Heiko Goeman and Michael Clausen,\npublished 2002, Kybernetika [Volume 38, Issue 1, *pp.* 45-66]\n\n[Hirschberg 1975] \"A linear space algorithm for computing maximal common subsequences\"\nby Daniel S. Hirschberg, published June 1975\nCommunications of the ACM [Volume 18, Number 6, *pp.* 341-343]\n\n[Hunt and McIlroy 1976] \"An Algorithm for Differential File Comparison\"\nby James W. Hunt and M. Douglas McIlroy, June 1976\nComputing Science Technical Report, Bell Laboratories 41\n\n[Hunt and Szymanski 1977] \"A Fast Algorithm for Computing Longest Common Subsequences\"\nby James W. Hunt and Thomas G. Szymanski, published May 1977\nCommunications of the ACM [Volume 20, Number 5, *pp.* 350-353]\n\n[Rick 2000] \"Simple and fast linear space computation of longest common subsequences\"\nby Claus Rick, received 17 March 2000, Information Processing Letters,\nElsevier Science [Volume 75, *pp.* 275–281]\n\n**Examples**\n\nThe sequences \"1234\" and \"1224533324\" have an LCS of \"1234\":\n\n```\n1234\n1224533324\n\n```\n\nFor a string example, consider the sequences \"thisisatest\" and \"testing123testing\". An LCS would be \"tsitest\":\n\n```\nthisisatest\ntesting123testing\n\n```\n\nIn this puzzle, your code only needs to deal with strings. Write a function which returns an LCS of two strings (case-sensitive). You don't need to show multiple LCS's.\n\nFor more information on this problem please see Wikipedia.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Recursion\n\n**Works with**: rakudo version 2015-09-16\n\nThis solution is similar to the Haskell one. It is slow.\n\n```\nsay lcs(\"thisisatest\", \"testing123testing\");sub lcs(Str $xstr, Str $ystr) {\n    return \"\" unless $xstr && $ystr;\n\n    my ($x, $xs, $y, $ys) = $xstr.substr(0, 1), $xstr.substr(1), $ystr.substr(0, 1), $ystr.substr(1);\n    return $x eq $y\n        ?? $x ~ lcs($xs, $ys)\n        !! max(:by{ $^a.chars }, lcs($xstr, $ys), lcs($xs, $ystr) );\n}\n\nsay lcs(\"thisisatest\", \"testing123testing\");\n\n```\n\n### Dynamic Programming\n\n**Translation of**: Java\n\n```\nsub lcs(Str $xstr, Str $ystr) {\n    my ($xlen, $ylen) = ($xstr, $ystr)>>.chars;\n    my @lengths = map {[(0) xx ($ylen+1)]}, 0..$xlen;\n\n    for $xstr.comb.kv -> $i, $x {\n        for $ystr.comb.kv -> $j, $y {\n            @lengths[$i+1][$j+1] = $x eq $y ?? @lengths[$i][$j]+1 !! (@lengths[$i+1][$j], @lengths[$i][$j+1]).max;\n        }\n    }\n\n    my @x = $xstr.comb;\n    my ($x, $y) = ($xlen, $ylen);\n    my $result = \"\";\n    while $x != 0 && $y != 0 {\n        if @lengths[$x][$y] == @lengths[$x-1][$y] {\n            $x--;\n        }\n        elsif @lengths[$x][$y] == @lengths[$x][$y-1] {\n            $y--;\n        }\n        else {\n            $result = @x[$x-1] ~ $result;\n            $x--;\n            $y--;\n        }\n    }\n\n    return $result;\n}\n\nsay lcs(\"thisisatest\", \"testing123testing\");\n\n```\n\n### Bit Vector\n\nBit parallel dynamic programming with nearly linear complexity O(n). It is fast.\n\n```\nsub lcs(Str $xstr, Str $ystr) {\n    my (@a, @b) := ($xstr, $ystr)».comb;\n    my (%positions, @Vs, $lcs);\n\n    for @a.kv -> $i, $x { %positions{$x} +|= 1 +< ($i % @a) }\n\n    my $S = +^ 0;\n    for (0 ..^ @b) -> $j {\n        my $u = $S +& (%positions{@b[$j]} // 0);\n        @Vs[$j] = $S = ($S + $u) +| ($S - $u)\n    }\n\n    my ($i, $j) = @a-1, @b-1;\n    while ($i ≥ 0 and $j ≥ 0) {\n        unless (@Vs[$j] +& (1 +< $i)) {\n            $lcs [R~]= @a[$i] unless $j and ^@Vs[$j-1] +& (1 +< $i);\n            $j--\n        }\n        $i--\n    }\n    $lcs\n}\n\nsay lcs(\"thisisatest\", \"testing123testing\");\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function that returns the longest common substring of two strings.\n\nUse it within a program that demonstrates sample output from the function, which will consist of the longest common substring between \"thisisatest\" and \"testing123testing\".\n\nNote that substrings are consecutive characters within a string.   This distinguishes them from subsequences, which is any sequence of characters within a string, even if there are extraneous characters in between them.\n\nHence, the longest common subsequence between \"thisisatest\" and \"testing123testing\" is \"tsitest\", whereas the longest common sub*string* is just \"test\".\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet\n\nReferences\n\n* Generalize Suffix Tree\n* Ukkonen’s Suffix Tree Construction"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub createSubstrings( Str $word --> Array ) {\n   my $length = $word.chars ;\n   my @substrings ;\n   for (0..$length - 1) -> $start {\n      for (1..$length - $start) -> $howmany {\n\t @substrings.push( $word.substr( $start , $howmany ) ) ;\n      }\n   }\n   return @substrings ;\n}\n\nsub findLongestCommon( Str $first , Str $second --> Str ) {\n   my @substringsFirst  = createSubstrings( $first ) ;\n   my @substringsSecond = createSubstrings( $second ) ;\n   my $firstset  = set( @substringsFirst ) ;\n   my $secondset = set( @substringsSecond ) ;\n   my $common = $firstset (&) $secondset ;\n   return $common.keys.sort({$^b.chars <=> $^a.chars})[0] ; # or: sort(-*.chars)[0]\n}\n\nsub MAIN( Str $first , Str $second ) {\n   say \"The longest common substring of $first and $second is \" ~\n   \"{findLongestCommon( $first , $second ) } !\" ;\n}\n\n```\n\nOutput:\n\n```\nThe longest common substring of thisisatest and testing123testing is test !\n```\n\n### Functional\n\n```\nsub substrings ($s)       { (flat (0..$_ X 1..$_).grep:{$_ ≥ [+] @_}).map: { $s.substr($^a, $^b) } given $s.chars }\nsub infix:<LCS>($s1, $s2) { ([∩] ($s1, $s2)».&substrings).keys.sort(*.chars).tail }\n\nmy $first  = 'thisisatest';\nmy $second = 'testing123testing';\nsay \"The longest common substring between '$first' and '$second' is '{$first LCS $second}'.\";\n\n```\n\nOutput:\n\n```\nThe longest common substring between 'thisisatest' and 'testing123testing' is 'test'.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function to find the longest common suffix string amongst an array of strings.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.07\n\n```\nsub longest-common-suffix ( *@words ) {\n    return '' unless +@words;\n    my $min = @words».chars.min;\n    for 1 .. * {\n        return @words[0].substr(* - $min) if $_ > $min;\n        next if @words».substr(* - $_).Set == 1;\n        return @words[0].substr(* - $_ + 1);\n    }\n}\n\nsay \"{$_.raku} - LCS: >{longest-common-suffix $_}<\" for\n  <Sunday Monday Tuesday Wednesday Thursday Friday Saturday>,\n  <Sondag Maandag Dinsdag Woensdag Donderdag Vrydag Saterdag dag>,\n  ( 2347, 9312347, 'acx5g2347', 12.02347 ),\n  <longest common suffix>,\n  ('one, Hey!', 'three, Hey!', 'ale, Hey!', 'me, Hey!'),\n  'suffix',\n  ''\n\n```\n\nOutput:\n\n```\n(\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\") - LCS: >day<\n(\"Sondag\", \"Maandag\", \"Dinsdag\", \"Woensdag\", \"Donderdag\", \"Vrydag\", \"Saterdag\", \"dag\") - LCS: >dag<\n(2347, 9312347, \"acx5g2347\", 12.02347) - LCS: >2347<\n(\"longest\", \"common\", \"suffix\") - LCS: ><\n(\"one, Hey!\", \"three, Hey!\", \"ale, Hey!\", \"me, Hey!\") - LCS: >e, Hey!<\n\"suffix\" - LCS: >suffix<\n\"\" - LCS: ><\n```"}]}
{"messages": [{"role": "user", "content": "Calculate and show here a longest increasing subsequence of the list:\n\n:   {\n    3\n    ,\n    2\n    ,\n    6\n    ,\n    4\n    ,\n    5\n    ,\n    1\n    }\n    {\\displaystyle {\\displaystyle \\{3,2,6,4,5,1\\}}}\n\nAnd of the list:\n\n:   {\n    0\n    ,\n    8\n    ,\n    4\n    ,\n    12\n    ,\n    2\n    ,\n    10\n    ,\n    6\n    ,\n    14\n    ,\n    1\n    ,\n    9\n    ,\n    5\n    ,\n    13\n    ,\n    3\n    ,\n    11\n    ,\n    7\n    ,\n    15\n    }\n    {\\displaystyle {\\displaystyle \\{0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15\\}}}\n\nNote that a list may have more than one subsequence that is of the maximum length.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet\n\nRef\n\n1. Dynamic Programming #1: Longest Increasing Subsequence on YouTube\n2. An efficient solution can be based on Patience sorting."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n### Dynamic programming\n\nStraight-forward implementation of the algorithm described in the video.\n\n```\nsub lis(@d) {\n    my @l = [].item xx @d;\n    @l[0].push: @d[0];\n    for 1 ..^ @d -> $i {\n        for ^$i -> $j {\n            if @d[$j] < @d[$i] && @l[$i] < @l[$j] + 1 {\n                @l[$i] = [ @l[$j][] ]\n            }\n        }\n        @l[$i].push: @d[$i];\n    }\n    return max :by(*.elems), @l;\n}\n\nsay lis([3,2,6,4,5,1]);\nsay lis([0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15]);\n\n```\n\nOutput:\n\n```\n[2 4 5]\n[0 2 6 9 11 15]\n```\n\n### Patience sorting\n\n```\nsub lis(@deck is copy) {\n    my @S = [@deck.shift() => Nil].item;\n    for @deck -> $card {\n        with first { @S[$_][*-1].key > $card }, ^@S -> $i {\n            @S[$i].push: $card => @S[$i-1][*-1] // Nil\n        } else {\n            @S.push: [ $card => @S[*-1][*-1] // Nil ].item\n        }\n    }\n    reverse map *.key, (\n        @S[*-1][*-1], *.value ...^ !*.defined\n    )\n}\n\nsay lis <3 2 6 4 5 1>;\nsay lis <0 8 4 12 2 10 6 14 1 9 5 13 3 11 7 15>;\n\n```\n\nOutput:\n\n```\n[2 4 5]\n[0 2 6 9 11 15]\n```"}]}
{"messages": [{"role": "user", "content": "Let given a string s.\nThe goal is to find the longest palindromic substring in s.\n\nRelated tasks\n\n* Palindrome\\_detection\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.09\n\nThis version regularizes (ignores) case and ignores non alphanumeric characters. It is only concerned with finding the *longest* palindromic substrings so does not exhaustively find *all possible* palindromes. If a palindromic substring is found to be part of a longer palindrome, it is not captured separately. Showing the longest 5 palindromic substring groups. Run it with no parameters to operate on the default; pass in a file name to run it against that instead.\n\n```\nmy @chars = ( @*ARGS[0] ?? @*ARGS[0].IO.slurp !! q:to/BOB/ ) .lc.comb: /\\w/;\n    Lyrics to \"Bob\" copyright Weird Al Yankovic\n    https://www.youtube.com/watch?v=JUQDzj6R3p4\n\n    I, man, am regal - a German am I\n    Never odd or even\n    If I had a hi-fi\n    Madam, I'm Adam\n    Too hot to hoot\n    No lemons, no melon\n    Too bad I hid a boot\n    Lisa Bonet ate no basil\n    Warsaw was raw\n    Was it a car or a cat I saw?\n\n    Rise to vote, sir\n    Do geese see God?\n    \"Do nine men interpret?\" \"Nine men,\" I nod\n    Rats live on no evil star\n    Won't lovers revolt now?\n    Race fast, safe car\n    Pa's a sap\n    Ma is as selfless as I am\n    May a moody baby doom a yam?\n\n    Ah, Satan sees Natasha\n    No devil lived on\n    Lonely Tylenol\n    Not a banana baton\n    No \"x\" in \"Nixon\"\n    O, stone, be not so\n    O Geronimo, no minor ego\n    \"Naomi,\" I moan\n    \"A Toyota's a Toyota\"\n    A dog, a panic in a pagoda\n\n    Oh no! Don Ho!\n    Nurse, I spy gypsies - run!\n    Senile felines\n    Now I see bees I won\n    UFO tofu\n    We panic in a pew\n    Oozy rat in a sanitary zoo\n    God! A red nugget! A fat egg under a dog!\n    Go hang a salami, I'm a lasagna hog!\n    BOB\n#\"\n\nmy @cpfoa = flat\n(1 ..^ @chars).race(:1000batch).map: -> \\idx {\n    my @s;\n    for 1, 2 {\n       my int ($rev, $fwd) = $_, 1;\n       loop {\n            quietly last if ($rev > idx) || (@chars[idx - $rev] ne @chars[idx + $fwd]);\n            $rev = $rev + 1;\n            $fwd = $fwd + 1;\n        }\n        @s.push: @chars[idx - $rev ^..^ idx + $fwd].join if $rev + $fwd > 2;\n        last if @chars[idx - 1] ne @chars[idx];\n    }\n    next unless +@s;\n    @s\n}\n\n\"{.key} ({+.value})\\t{.value.unique.sort}\".put for @cpfoa.classify( *.chars ).sort( -*.key ).head(5);\n\n```\n\nOutput:\n\nReturns the length, (the count) and the list:\n\n```\n29 (2)\tdoninemeninterpretninemeninod godarednuggetafateggunderadog\n26 (1)\tgohangasalamiimalasagnahog\n23 (1)\tarwontloversrevoltnowra\n21 (4)\timanamregalagermanami mayamoodybabydoomayam ootnolemonsnomelontoo oozyratinasanitaryzoo\n20 (1)\tratsliveonnoevilstar\n\n```\n\nThis isn't intensively optimised but isn't too shabby either. When run against the first million digits of pi: 1000000 digits of pi text file (Pass in the file path/name at the command line) we get:\n\n```\n13 (1)\t9475082805749\n12 (1)\t450197791054\n11 (8)\t04778787740 09577577590 21348884312 28112721182 41428782414 49612121694 53850405835 84995859948\n10 (9)\t0045445400 0136776310 1112552111 3517997153 5783993875 6282662826 7046006407 7264994627 8890770988\n9 (98)\t019161910 020141020 023181320 036646630 037101730 037585730 065363560 068363860 087191780 091747190 100353001 104848401 111262111 131838131 132161231 156393651 160929061 166717661 182232281 193131391 193505391 207060702 211878112 222737222 223404322 242424242 250171052 258232852 267919762 272636272 302474203 313989313 314151413 314424413 318272813 323212323 330626033 332525233 336474633 355575553 357979753 365949563 398989893 407959704 408616804 448767844 450909054 463202364 469797964 479797974 480363084 489696984 490797094 532121235 546000645 549161945 557040755 559555955 563040365 563828365 598292895 621969126 623707326 636414636 636888636 641949146 650272056 662292266 667252766 681565186 684777486 712383217 720565027 726868627 762727267 769646967 777474777 807161708 819686918 833303338 834363438 858838858 866292668 886181688 895505598 896848698 909565909 918888819 926676629 927202729 929373929 944525449 944848449 953252359 972464279 975595579 979202979 992868299\n```\n\nin right around 7 seconds on my system."}]}
{"messages": [{"role": "user", "content": "Background\n\nThis \"longest string challenge\" is inspired by a problem that used to be given to students learning Icon. Students were expected to try to solve the problem in Icon and another language with which the student was already familiar. The basic problem is quite simple; the challenge and fun part came through the introduction of restrictions. Experience has shown that the original restrictions required some adjustment to bring out the intent of the challenge and make it suitable for Rosetta Code.\n\nBasic problem statement\n\nWrite a program that reads lines from standard input and, upon end of file, writes the longest line to standard output.\nIf there are ties for the longest line, the program writes out all the lines that tie.\nIf there is no input, the program should produce no output.\n\nTask\n\nImplement a solution to the basic problem that adheres to the spirit of the restrictions (see below).\n\nDescribe how you circumvented or got around these 'restrictions' and met the 'spirit' of the challenge. Your supporting description may need to describe any challenges to interpreting the restrictions and how you made this interpretation. You should state any assumptions, warnings, or other relevant points. The central idea here is to make the task a bit more interesting by thinking outside of the box and perhaps by showing off the capabilities of your language in a creative way. Because there is potential for considerable variation between solutions, the description is key to helping others see what you've done.\n\nThis task is likely to encourage a variety of different types of solutions. They should be substantially different approaches.\n\nGiven the input:\n\n```\na\nbb\nccc\nddd\nee\nf\nggg\n\n```\n\nthe output should be (possibly rearranged):\n\n```\nccc\nddd\nggg\n\n```\n\nOriginal list of restrictions\n\n1. No comparison operators may be used.\n2. No arithmetic operations, such as addition and subtraction, may be used.\n3. The only datatypes you may use are integer and string. In particular, you may not use lists.\n4. Do not re-read the input file. Avoid using files as a replacement for lists (this restriction became apparent in the discussion).\n\nIntent of restrictions\n\nBecause of the variety of languages on Rosetta Code and the wide variety of concepts used in them, there needs to be a bit of clarification and guidance here to get to the spirit of the challenge and the intent of the restrictions.\n\nThe basic problem can be solved very conventionally, but that's boring and pedestrian. The original intent here wasn't to unduly frustrate people with interpreting the restrictions, it was to get people to think outside of their particular box and have a bit of fun doing it.\n\nThe guiding principle here should be to be creative in demonstrating some of the capabilities of the programming language being used. If you need to bend the restrictions a bit, explain why and try to follow the intent. If you think you've implemented a 'cheat', call out the fragment yourself and ask readers if they can spot why. If you absolutely can't get around one of the restrictions, explain why in your description.\n\nNow having said that, the restrictions require some elaboration.\n\n* In general, the restrictions are meant to avoid the explicit use of these features.\n* \"No comparison operators may be used\" - At some level there must be some test that allows the solution to get at the length and determine if one string is longer. Comparison operators, in particular any less/greater comparison should be avoided. Representing the length of any string as a number should also be avoided. Various approaches allow for detecting the end of a string. Some of these involve implicitly using equal/not-equal; however, explicitly using equal/not-equal should be acceptable.\n* \"No arithmetic operations\" - Again, at some level something may have to advance through the string. Often there are ways a language can do this implicitly advance a cursor or pointer without explicitly using a +, - , ++, --, add, subtract, etc.\n* The datatype restrictions are amongst the most difficult to reinterpret. In the language of the original challenge strings are atomic datatypes and structured datatypes like lists are quite distinct and have many different operations that apply to them. This becomes a bit fuzzier with languages with a different programming paradigm. The intent would be to avoid using an easy structure to accumulate the longest strings and spit them out. There will be some natural reinterpretation here.\n\nTo make this a bit more concrete, here are a couple of specific examples:\nIn C, a string is an array of chars, so using a couple of arrays as strings is in the spirit while using a second array in a non-string like fashion would violate the intent.\nIn APL or J, arrays are the core of the language so ruling them out is unfair. Meeting the spirit will come down to how they are used.\n\nPlease keep in mind these are just examples and you may hit new territory finding a solution. There will be other cases like these. Explain your reasoning. You may want to open a discussion on the talk page as well.\n\n* The added \"No rereading\" restriction is for practical reasons, re-reading stdin should be broken. I haven't outright banned the use of other files but I've discouraged them as it is basically another form of a list. Somewhere there may be a language that just sings when doing file manipulation and where that makes sense; however, for most there should be a way to accomplish without resorting to an externality.\n\nAt the end of the day for the implementer this should be a bit of fun. As an implementer you represent the expertise in your language, the reader may have no knowledge of your language. For the reader it should give them insight into how people think outside the box in other languages. Comments, especially for non-obvious (to the reader) bits will be extremely helpful. While the implementations may be a bit artificial in the context of this task, the general techniques may be useful elsewhere."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $l = '';  # Sample longest string seen.\nmy $a = '';  # Accumulator to save longest strings.\n\nwhile get() -> $s {\n   my $n = \"$s\\n\";\n   if $n.substr($l.chars) {     # Is new string longer?\n       $a = $l = $n;            # Reset accumulator.\n   }\n   elsif !$l.substr($n.chars) { # Same length?\n      $a ~= $n;                 # Accumulate it.\n   }\n}\nprint $a;\n\n```\n\nGiven the example input, returns:\n\n```\nccc\nddd\nggg\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a string,   find the   **longest substring**   without any repeating characters.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "Detects **any** character when checking for repeated characters, even multi-byte composite characters, control sequences and whitespace.\n\nNote that there is no requirement that the substrings be unique, only that each has no repeated characters internally.\n\nNot going to bother handling arrays since an array is not a string, and the task description **specifically** says 'Given a string'.\n\n```\nsub abbreviate ($_) { .chars > 80 ?? \"(abbreviated)\\n\" ~ .substr(0,35) ~ ' ... ' ~ .substr(*-35) !! $_ }\n\nsub longest ($string) {\n   return 0 => [] unless $string.chars;\n   my ($start, $end, @substr) = 0, 0;\n   while ++$end < $string.chars {\n       my $sub = $string.substr($start, $end - $start);\n       if $sub.contains: my $next = $string.substr: $end, 1 {\n           @substr[$end - $start].push($sub) if $end - $start >= @substr.end;\n           $start += 1 + $sub.index($next);\n       }\n   }\n   @substr[$end - $start].push: $string.substr($start);\n   @substr.pairs.tail\n}\n\n# Testing\nsay \"\\nOriginal string: {abbreviate $_}\\nLongest substring(s) chars: \", .&longest\n\n# Standard tests\nfor flat qww< xyzyabcybdfd xyzyab zzzzz a '' >,\n\n# multibyte Unicode\n< 👒🎩🎓👩‍👩‍👦‍👦🧢🎓👨‍👧‍👧👒👩‍👩‍👦‍👦🎩🎓👒🧢 α⊆϶α϶ >,\n\n# check a file\nslurp 'unixdict.txt';\n\n```\n\nOutput:\n\n```\nOriginal string: xyzyabcybdfd\nLongest substring(s) chars: 5 => [zyabc cybdf]\n\nOriginal string: xyzyab\nLongest substring(s) chars: 4 => [zyab]\n\nOriginal string: zzzzz\nLongest substring(s) chars: 1 => [z z z z z]\n\nOriginal string: a\nLongest substring(s) chars: 1 => [a]\n\nOriginal string: \nLongest substring(s) chars: 0 => []\n\nOriginal string: 👒🎩🎓👩‍👩‍👦‍👦🧢🎓👨‍👧‍👧👒👩‍👩‍👦‍👦🎩🎓👒🧢\nLongest substring(s) chars: 6 => [🧢🎓👨‍👧‍👧👒👩‍👩‍👦‍👦🎩]\n\nOriginal string: α⊆϶α϶\nLongest substring(s) chars: 3 => [α⊆϶ ⊆϶α]\n\nOriginal string: (abbreviated)\n10th\n1st\n2nd\n3rd\n4th\n5th\n6th\n7th\n8t ... rian\nzounds\nzucchini\nzurich\nzygote\n\nLongest substring(s) chars: 15 => [mbowel\ndisgrunt]\n```"}]}
{"messages": [{"role": "user", "content": "The   Look and say sequence   is a recursively defined sequence of numbers studied most notably by   John Conway.\n\nThe   **look-and-say sequence**   is also known as the   **Morris Number Sequence**,   after cryptographer Robert Morris,   and the puzzle   *What is the next number in the sequence 1,   11,   21,   1211,   111221?*   is sometimes referred to as the *Cuckoo's Egg*,   from a description of Morris in Clifford Stoll's book   *The Cuckoo's Egg*.\n\n**Sequence Definition**\n\n* Take a decimal number\n* *Look* at the number, visually grouping consecutive runs of the same digit.\n* *Say* the number, from left to right, group by group; as how many of that digit there are - followed by the digit grouped.\n\n:   This becomes the next number of the sequence.\n\n**An example:**\n\n* Starting with the number 1,   you have *one* 1 which produces 11\n* Starting with 11,   you have *two* 1's.   I.E.:   21\n* Starting with 21,   you have *one* 2, then *one* 1.   I.E.:   (12)(11) which becomes 1211\n* Starting with 1211,   you have *one* 1, *one* 2, then *two* 1's.   I.E.:   (11)(12)(21) which becomes 111221\n\nTask\n\nWrite a program to generate successive members of the look-and-say sequence.\n\nRelated tasks\n\n* Fours is the number of letters in the ...\n* Number names\n* Self-describing numbers\n* Self-referential sequence\n* Spelling of ordinal numbers\n\nSee also\n\n* Look-and-Say Numbers (feat John Conway), A Numberphile Video.\n* This task is related to, and an application of, the Run-length encoding task.\n* Sequence A005150 on The On-Line Encyclopedia of Integer Sequences."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\nIn Raku it is natural to avoid explicit loops; rather we use the sequence operator to define a lazy infinite sequence. We'll print the first 15 values here.\n\n```\n.say for ('1', *.subst(/(.)$0*/, { .chars ~ .[0] }, :g) ... *)[^15];\n```\n\nOutput:\n\n```\n1\n11\n21\n1211\n111221\n312211\n13112221\n1113213211\n31131211131221\n13211311123113112211\n11131221133112132113212221\n3113112221232112111312211312113211\n1321132132111213122112311311222113111221131221\n11131221131211131231121113112221121321132132211331222113112211\n311311222113111231131112132112311321322112111312211312111322212311322113212221\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nLoop over multiple arrays   (or lists or tuples or whatever they're called in\nyour language)   and display the    *i* th    element of each.\n\nUse your language's   \"for each\"   loop if it has one, otherwise iterate\nthrough the collection in order with some other loop.\n\nFor this example, loop over the arrays:\n\n```\n    (a,b,c)\n    (A,B,C) \n    (1,2,3) \n\n```\n\nto produce the output:\n\n```\n    aA1\n    bB2\n    cC3\n\n```\n\nIf possible, also describe what happens when the arrays are of different lengths.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015.12\n\nNote that all of the following work with *any* iterable object, (array, list, range, sequence; anything that does the Iterable role), not just arrays.\n\n### Basic functionality\n\n```\nfor <a b c> Z <A B C> Z 1, 2, 3 -> ($x, $y, $z) {\n   say $x, $y, $z;\n}\n```\n\nThe `Z` operator stops emitting items as soon as the shortest input list is exhausted. However, short lists are easily extended by replicating all or part of the list, or by appending any kind of lazy list generator to supply default values as necessary.\n\nSince `Z` will return a list of lists (in this example, the first list is `('a', 'A', 1)`, parentheses are used around in the lambda signature `($x, $y, $z)` to unpack the list for each iteration.\n\n### Factoring out concatenation\n\nNote that we can also factor out the concatenation by making the Z metaoperator apply the ~ concatenation operator across each triple:\n\n```\n.say for <a b c> Z~ <A B C> Z~ 1, 2, 3;\n```\n\nWe could also use the zip-to-string with the reduction metaoperator:\n\n```\n.say for [Z~] <a b c>, <A B C>, (1,2,3);\n```\n\nWe could also write that out \"long-hand\":\n\n```\n.say for zip :with(&infix:<~>), <a b c>, <A B C>, (1,2,3);\n```\n\nreturns the exact same result so if you aren't comfortable with the concise operators, you have a choice.\n\n### A list and its indices\n\nThe common case of iterating over a list and a list of its indices can be done using the same method:\n\n```\nfor ^Inf Z <a b c d> -> ($i, $letter) { ... }\n```\n\nor by using the `.kv` (key and value) method on the list (and dropping the parentheses because the list returned by `.kv` is a flattened list):\n\n```\nfor <a b c d>.kv -> $i, $letter { ... }\n```\n\n### Iterate until all exhausted\n\nIf you have different sized lists that you want to pull a value from each per iteration, but want to continue until **all** of the lists are exhausted, we have `roundrobin`.\n\n```\n.put for roundrobin <a b c>, 'A'..'G', ^5;\n```\n\nyields:\n\n```\na A 0\nb B 1\nc C 2\nD 3\nE 4\nF\nG\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow a loop which prints random numbers (each number newly generated each loop) from 0 to 19 (inclusive).\n\nIf a number is 10, stop the loop after printing it, and do not generate any further numbers.\n\nOtherwise, generate and print a second random number before restarting the loop.\n\nIf the number 10 is never generated as the first number in a loop, loop forever.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #21 \"Seattle\"\n\n```\nloop {\n    say my $n = (0..19).pick;\n    last if $n == 10;\n    say (0..19).pick;\n}\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow the following output using one loop.\n\n```\n1, 2, 3, 4, 5\n6, 7, 8, 9, 10\n\n```\n\nTry to achieve the result by forcing the next iteration within the loop\nupon a specific condition, if your language allows it.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n**Works with**: Rakudo Star version 2010.08\n\n```\nfor 1 .. 10 {\n    .print;\n    if $_ %% 5 {\n        print \"\\n\";\n        next;\n    }\n    print ', ';\n}\n\n```\n\nor without using a loop:\n\n```\n$_.join(\", \").say for [1..5], [6..10];\n\n```"}]}
{"messages": [{"role": "user", "content": "Start with a value at 0. Loop while value mod 6 is not equal to 0.\nEach time through the loop, add 1 to the value then print it.\nThe loop must execute at least once.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges\n\nReference\n\n* Do while loop Wikipedia."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo Star version 2010.08\n\n```\nmy $val = 0;\nrepeat {\n    say ++$val;\n} while $val % 6;\n```\n\n`repeat ... until condition` is equivalent to `do ... while not condition`.\n\n```\nmy $val = 0;\nrepeat {\n    say ++$val;\n} until $val %% 6;\n```\n\n(Here we've used `%%`, the \"divisible-by\" operator.)\n\nYou can also put the condition before the block, without changing the order of evaluation.\n\n```\nmy $val = 0;\nrepeat while $val % 6 {\n    say ++$val;\n}\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a    *for*    loop which writes a countdown from   **10**   to   **0**.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo Star version 2010.08\n\n```\nfor 10 ... 0 {\n    .say;\n}\n```"}]}
{"messages": [{"role": "user", "content": "“**For**”   loops are used to make some block of code be iterated a number of times, setting a variable or parameter to a monotonically increasing integer value for each execution of the block of code.\n\nCommon extensions of this allow other counting patterns or iterating over abstract structures other than the integers.\n\nTask\n\nShow how two loops may be nested within each other, with the number of iterations performed by the inner for loop being controlled by the outer for loop.\n\nSpecifically print out the following pattern by using one for loop nested in another:\n\n```\n*\n**\n***\n****\n*****\n```\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges\n\nReference\n\n* For loop Wikipedia."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #22 \"Thousand Oaks\"\n\n```\nfor ^5 {\n\n\tfor 0..$_ {\n\t\tprint \"*\";\n\t}\n\t\n\tprint \"\\n\";\n\n}\n```\n\nor using only one for loop:\n\n```\nsay '*' x $_ for 1..5;\n```\n\nor without using any loops at all:\n\n```\n([\\~] \"*\" xx 5).join(\"\\n\").say;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate a   *for-loop*   where the step-value is greater than one.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2010.07\n\nDepending on how you define your terms, this task is either trivial or impossible in Raku. `for` in Raku doesn't have a step value, it's an iteration operator. It iterates through any iterable object passed to it and sets the topic variable to each iterated value in turn. If you close one eye and squint, I guess you could say it has a step value of 1 (or more accurately, Next) and that isn't really changeable. Whatever iterable you pass to it though can have pretty much any value in pretty much any order you desire, so effectively the \"step\" value is completely unconstrained.\n\nExamples of iterables (not exhaustive):\n\n* Things that do a positional role:\n\n:   * Array\n    * List\n    * Range\n    * Sequence\n\n* Things that do an associative role:\n\n:   * Bag\n    * BagHash\n    * Hash\n    * Map\n    * Mix\n    * MixHash\n    * QuantHash\n    * Set\n    * SetHash\n\nProbably the most straightforward way to do this is with a sequence. With at least two values on the left-hand side, the sequence operator (`...`) can infer an arithmetic series. (With at least three values, it can infer a geometric sequence, too.)\n\n```\nfor 2, 4 ... 8 {\n    print \"$_, \";\n}\n \nsay 'whom do we appreciate?';\n```\n\nBut there is nothing constraining the sequence to a constant step. Here's one with a *random* step.\n\n```\n.say for rand, *+rand-.5 ... *.abs>2\n```\n\nSample output:\n\n```\n0.1594860240843563\n-0.11336537297314198\n-0.04195945218519992\n-0.024844489074366427\n-0.20616093727620433\n-0.17589258387167517\n-0.40547336592612593\n0.04561929494516015\n0.4886003890463373\n0.7843094215547495\n0.6413619589945883\n1.0694380727281951\n1.472290164849169\n1.8310404939418325\n2.326272380988639\n\n```\n\nFor that matter, the iterated object doesn't need to contain numbers.\n\n```\n.say for <17/32 π banana 👀 :d(7) 🦋>;\n```"}]}
{"messages": [{"role": "user", "content": "Loop through and print each element in a collection in order.\n\nUse your language's \"for each\" loop if it has one, otherwise iterate through the collection in order with some other loop.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015.10-40\n\n```\nsay $_ for @collection;\n```\n\nRaku leaves off the each from foreach, leaving us with for instead. The variable $\\_ refers to the current element, unless you assign a name to it using ->.\n\n```\nfor @collection -> $currentElement { say $currentElement; }\n```\n\nRaku will do it's best to put the topic at the right spot.\n\n```\n.say for @collection;\nfor @collection { .say };\n```\n\nIteration can also be done with hyperoperators. In this case it's a candidate for autothreading and as such, execution order may vary. The resulting list will be in order.\n\n```\n@collection>>.say;\n@collection>>.=&infix:<+>(2); # increment each element by 2\n```"}]}
{"messages": [{"role": "user", "content": "Sometimes, one may need   (or want)   a loop which\nits   *iterator*   (the index\nvariable)   is modified within the\n  \nloop body    *in addition to the normal incrementation by the   (**do**)   loop structure index*.\n\nGoal\n\nDemonstrate the best way to accomplish this.\n\nTask\n\nWrite a loop which:\n\n:   :   * starts the index (variable) at   **42**\n        * (at iteration time)   increments the index by unity\n        * if the index is prime:\n\n        :   :   * displays the count of primes found (so far) and the prime   (to the terminal)\n                * increments the index such that the new index is now the (old) index plus that prime\n\n        * terminates the loop when   **42**   primes are shown\n\nExtra credit:   because of the primes get rather large, use commas\nwithin the displayed primes to ease comprehension.\n\nShow all output here.\n\nNote\n\nNot all programming languages allow the modification of a\nloop's index.   If that is the case, then use whatever method that\nis appropriate or idiomatic for that language.   Please add a note\nif the loop's index isn't modifiable.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\nHmm.\n\n> Demonstrate the best way to accomplish this.\n\nThe *best* way is probably to not use an explicit loop. Just calculate the sequence directly.\n\n```\n# the actual sequence logic\nmy @seq = grep *.is-prime, (42, { .is-prime ?? $_+<1 !! $_+1 } … *);\n\n# display code\nsay (1+$_).fmt(\"%-4s\"), @seq[$_].flip.comb(3).join(',').flip.fmt(\"%20s\") for ^42;\n\n```\n\nOutput:\n\n```\n1                     43\n2                     89\n3                    179\n4                    359\n5                    719\n6                  1,439\n7                  2,879\n8                  5,779\n9                 11,579\n10                23,159\n11                46,327\n12                92,657\n13               185,323\n14               370,661\n15               741,337\n16             1,482,707\n17             2,965,421\n18             5,930,887\n19            11,861,791\n20            23,723,597\n21            47,447,201\n22            94,894,427\n23           189,788,857\n24           379,577,741\n25           759,155,483\n26         1,518,310,967\n27         3,036,621,941\n28         6,073,243,889\n29        12,146,487,779\n30        24,292,975,649\n31        48,585,951,311\n32        97,171,902,629\n33       194,343,805,267\n34       388,687,610,539\n35       777,375,221,081\n36     1,554,750,442,183\n37     3,109,500,884,389\n38     6,219,001,768,781\n39    12,438,003,537,571\n40    24,876,007,075,181\n41    49,752,014,150,467\n42    99,504,028,301,131\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nPrint out        **SPAM**        followed by a   *newline*   in an infinite loop.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo Star version 2010.08\n\n```\nloop {\n    say 'SPAM';\n}\n```\n\nIn addition, there are various ways of writing lazy, infinite lists in Raku:\n\n```\nprint \"SPAM\\n\" xx *;      # repetition operator\nprint \"SPAM\\n\", ~* ... *; # sequence operator\nmap {say \"SPAM\"}, ^Inf;   # upto operator\n```"}]}
{"messages": [{"role": "user", "content": "Quite often one needs loops which, in the last iteration, execute only part of the loop body.\n\nGoal\n\nDemonstrate the best way to do this.\n\nTask\n\nWrite a loop which writes the comma-separated list\n\n```\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10\n\n```\n\nusing separate output statements for the number\nand the comma from within the body of the loop.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nfor 1 .. 10 {\n    .print;\n    last when 10;\n    print ', ';\n}\n\nprint \"\\n\";\n```"}]}
{"messages": [{"role": "user", "content": "Show a nested loop which searches a two-dimensional array filled with random numbers uniformly distributed over \n\n[\n1\n,\n…\n,\n20\n]\n{\\displaystyle {\\displaystyle [1,\\ldots ,20]}}\n.\n\nThe loops iterate rows and columns of the array printing the elements until the value \n\n20\n{\\displaystyle {\\displaystyle 20}}\n is met.\n\nSpecifically, this task also shows how to break out of nested loops.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-18\n\n```\nmy @a = [ (1..20).roll(10) ] xx *;\n\nLINE: for @a -> @line {\n    for @line -> $elem {\n        print \" $elem\";\n        last LINE if $elem == 20;\n    }\n    print \"\\n\";\n}\nprint \"\\n\";\n\n```\n\nOutput:\n\n```\n 15 6 14 13 14 7 9 16 8 18\n 7 6 18 11 19 13 12 5 18 8\n 17 17 9 5 4 8 17 8 3 11\n 9 20\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nStart an integer value at   **1024**.\n\nLoop while it is greater than zero.\n\nPrint the value (with a newline) and divide it by two each time through the loop.\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nHere is a straightforward translation of the task description:\n\n```\nmy $n = 1024; while $n > 0 { say $n; $n div= 2 }\n```\n\nThe same thing with a C-style loop and a bitwise shift operator:\n\n```\nloop (my $n = 1024; $n > 0; $n +>= 1) { say $n }\n```\n\nAnd here's how you'd *really* write it, using a sequence operator that intuits the division for you:\n\n```\n.say for 1024, 512, 256 ... 1\n```"}]}
{"messages": [{"role": "user", "content": "Some languages allow multiple **loop** ranges, such as the **PL/I** example (snippet) below.\n\n```\n                                       /* all variables are DECLARED as integers. */\n          prod=  1;                    /*start with a product of unity.           */\n           sum=  0;                    /*  \"     \"  \"   sum    \" zero.            */\n             x= +5;\n             y= -5;\n             z= -2;\n           one=  1;\n         three=  3;\n         seven=  7;\n                                       /*(below)  **  is exponentiation:  4**3=64 */\n           do j=   -three  to     3**3        by three   ,\n                   -seven  to   +seven        by   x     ,\n                      555  to      550 - y               ,\n                       22  to      -28        by -three  ,\n                     1927  to     1939                   ,\n                        x  to        y        by   z     ,\n                    11**x  to    11**x + one;\n                                                        /* ABS(n) = absolute value*/\n           sum= sum + abs(j);                           /*add absolute value of J.*/\n           if abs(prod)<2**27 & j¬=0  then prod=prod*j; /*PROD is small enough & J*/\n           end;                                         /*not 0, then multiply it.*/\n                     /*SUM and PROD are used for verification of J incrementation.*/\n         display (' sum= ' ||  sum);                    /*display strings to term.*/\n         display ('prod= ' || prod);                    /*   \"       \"     \"   \"  */\n```\n\nTask\n\nSimulate/translate the above **PL/I** program snippet as best as possible in your\nlanguage,   with particular emphasis on the   **do**   loop construct.\n\nThe   **do**   index must be incremented/decremented in the same order shown.\n\nIf feasible, add commas to the two output numbers (being displayed).\n\nShow all output here.\n\n```\n      A simple PL/I   DO  loop  (incrementing or decrementing)  has the construct of:\n\n            DO variable = start_expression    {TO ending_expression]       {BY increment_expression} ;\n                 ---or---\n            DO variable = start_expression    {BY increment_expression}    {TO ending_expression]    ;  \n\n      where it is understood that all expressions will have a value.  The  variable  is normally a \n      scaler variable,  but need not be  (but for this task, all variables and expressions are declared\n      to be scaler integers).   If the   BY   expression is omitted,  a   BY   value of unity is used.\n      All expressions are evaluated before the   DO   loop is executed,  and those values are used\n      throughout the   DO   loop execution   (even though, for instance,  the value of   Z   may be\n      changed within the   DO   loop.    This isn't the case here for this task.  \n\n      A multiple-range   DO   loop can be constructed by using a comma (,) to separate additional ranges\n      (the use of multiple   TO   and/or   BY   keywords).     This is the construct used in this task.\n \n      There are other forms of   DO   loops in PL/I involving the  WHILE  clause,  but those won't be \n      needed here.    DO  loops without a   TO   clause might need a   WHILE   clause  or some other \n      means of exiting the loop  (such as  LEAVE,  RETURN,  SIGNAL,  GOTO,  or  STOP),  or some other \n      (possible error) condition that causes transfer of control outside the  DO  loop.\n \n      Also, in PL/I, the check if the   DO   loop index value is outside the range is made at the \n      \"head\"  (start)  of the   DO  loop,  so it's possible that the   DO   loop isn't executed,  but \n      that isn't the case for any of the ranges used in this task. \n\n      In the example above, the clause:                    x    to y       by z     \n      will cause the variable   J   to have to following values  (in this order):  5  3  1  -1  -3  -5\n\n      In the example above, the clause:                 -seven  to +seven  by x  \n      will cause the variable   J   to have to following values  (in this order):  -7  -2   3\n\n```\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis task is really conflating two separate things, (at least in Raku). Sequences and loops are two different concepts and may be considered / implemented separately from each other.\n\nYes, you can generate a sequence with a loop, and a loop can use a sequence for an iteration value, but the two are somewhat orthogonal and don't necessarily overlap.\n\nSequences are first class objects in Raku. You can (and typically do) generate a sequence using the (appropriately enough) sequence operator and can assign it to a variable and/or pass it as a parameter; the entire sequence, not just it's individual values. It *may* be used in a looping construct, but it is not necessary to do so.\n\nVarious looping constructs often do use sequences as their iterator but not exclusively, possibly not even in the majority.\n\nDisplaying the j sequence as well since it isn't very large.\n\n```\nsub comma { ($^i < 0 ?? '-' !! '') ~ $i.abs.flip.comb(3).join(',').flip }\n\nmy \\x     =  5;\nmy \\y     = -5;\nmy \\z     = -2;\nmy \\one   =  1;\nmy \\three =  3;\nmy \\seven =  7;\n\nmy $j = flat\n  ( -three, *+three … 3³         ),\n  ( -seven, *+x     …^ * > seven ),\n  ( 555   .. 550 - y             ),\n  ( 22,     *-three …^ * < -28   ),\n  ( 1927  .. 1939                ),\n  ( x,      *+z     …^ * < y     ),\n  ( 11**x .. 11**x + one         );\n\nput 'j sequence: ', $j;\nput '       Sum: ', comma [+] $j».abs;\nput '   Product: ', comma ([\\*] $j.grep: so +*).first: *.abs > 2²⁷;\n\n# Or, an alternate method for generating the 'j' sequence, employing user-defined\n# operators to preserve the 'X to Y by Z' layout of the example code.\n# Note that these operators will only work for monotonic sequences.\n\nsub infix:<to> { $^a ... $^b }\nsub infix:<by> { $^a[0, $^b.abs ... *] }\n\n$j = cache flat\n    -three  to          3**3  by  three ,\n    -seven  to         seven  by      x ,\n       555  to     (550 - y)            ,\n        22  to           -28  by -three ,\n      1927  to          1939  by    one ,\n         x  to             y  by      z ,\n     11**x  to (11**x + one)            ;\n\nput \"\\nLiteral minded variant:\";\nput '       Sum: ', comma [+] $j».abs;\nput '   Product: ', comma ([\\*] $j.grep: so +*).first: *.abs > 2²⁷;\n\n```\n\nOutput:\n\n```\nj sequence: -3 0 3 6 9 12 15 18 21 24 27 -7 -2 3 555 22 19 16 13 10 7 4 1 -2 -5 -8 -11 -14 -17 -20 -23 -26 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 5 3 1 -1 -3 -5 161051 161052\n       Sum: 348,173\n   Product: -793,618,560\n\nLiteral minded variant:\n       Sum: 348,173\n   Product: -793,618,560\n\n```"}]}
{"messages": [{"role": "user", "content": "Some languages have syntax or function(s) to generate a range of numeric values from a start value, a stop value, and an increment.\n\nThe purpose of this task is to select the range syntax/function that would generate at least two increasing numbers when given a stop value more than the start value and a positive increment of less than half the difference.   You are then to use that *same* syntax/function but with different parameters; and show, here, what would happen.\n\nUse these values if possible:\n\n:   :   :   :   :   | start | stop | increment | Comment |\n                    | --- | --- | --- | --- |\n                    | -2 | 2 | 1 | Normal |\n                    | -2 | 2 | 0 | Zero increment |\n                    | -2 | 2 | -1 | Increments away from stop value |\n                    | -2 | 2 | 10 | First increment is beyond stop value |\n                    | 2 | -2 | 1 | Start more than stop: positive increment |\n                    | 2 | 2 | 1 | Start equal stop: positive increment |\n                    | 2 | 2 | -1 | Start equal stop: negative increment |\n                    | 2 | 2 | 0 | Start equal stop: zero increment |\n                    | 0 | 0 | 0 | Start equal stop equal zero: zero increment |\n\nRelated tasks\n\n* Loop over multiple arrays simultaneously\n* Loops/Break\n* Loops/Continue\n* Loops/Do-while\n* Loops/Downward for\n* Loops/For\n* Loops/For with a specified step\n* Loops/Foreach\n* Loops/Increment loop index within loop body\n* Loops/Infinite\n* Loops/N plus one half\n* Loops/Nested\n* Loops/While\n* Loops/with multiple ranges\n* Loops/Wrong ranges"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.08\n\nIt would be odd to call ANY of these sequences \"wrong\" in Raku. Raku specifically has built in capability of working with infinite sequences. Just because a sequence is infinite, doesn't mean you can't define it, work with it or use values from it. Sure, if you try to reify the whole thing you may be waiting a while, but there is nothing preventing you from using a portion of it.\n\nRaku sequence definitions *specifically* allow \"ending points\" that may never occur in the sequence. Since that is the case, you don't even really **need** to specify a stop value. You can just say stop at \"whatever\". Whatever is spelled \"**\\***\" in Raku.\n\nThere is additional syntax you can add to stop at the nearest value, last value previous or first value successor to the \"stop value\" (Note I didn't say less than or greater than the stop value since the sequence can be ascending, descending or non-monotonic).\n\nAlso note: The iterator function for the sequence is literally a function. It is any expression that produces a value. These sequences all use simple arithmatic increments but that is not a limitation of the sequence operator.\n\n```\n# Given sequence definitions\n#   start  stop  inc.   Comment\nfor   -2,    2,    1, # Normal\n      -2,    2,    0, # Zero increment\n      -2,    2,   -1, # Increments away from stop value\n      -2,    2,   10, # First increment is beyond stop value\n       2,   -2,    1, # Start more than stop: positive increment\n       2,    2,    1, # Start equal stop: positive increment\n       2,    2,   -1, # Start equal stop: negative increment\n       2,    2,    0, # Start equal stop: zero increment\n       0,    0,    0, # Start equal stop equal zero: zero increment\n\n# Additional \"problematic\" sequences\n       1,  Inf,    3, # Endpoint literally at infinity\n       0,    π,  τ/8, # Floating point numbers\n     1.4,    *, -7.1  # Whatever\n\n  -> $start, $stop, $inc {\n    my $seq = flat ($start, *+$inc … $stop);\n    printf \"Start: %3s, Stop: %3s, Increment: %3s | \", $start, $stop.Str, $inc;\n    # only show up to the first 15 elements of possibly infinite sequences\n    put $seq[^15].grep: +*.defined\n}\n\n# For that matter the start and end values don't need to be numeric either. Both\n# or either can be a function, list, or other object. Really anything that a\n# \"successor\" function can be defined for and produces a value.\nsay \"\\nDemonstration of some other specialized sequence operator functionality:\";\n# Start with a list, iterate by multiplying the previous 3 terms together\n# and end with a term defined by a function.\nput 1, -.5, 2.sqrt, * × * × * … *.abs < 1e-2;\n\n# Start with an array, iterate by rotating, end when 0 is in the last place.\nsay [0,1,2,3,4,5], *.rotate(-1).Array … !*.tail;\n\n# Iterate strings backwards.\nput 'xp' … 'xf';\n\n```\n\nOutput:\n\n```\nStart:  -2, Stop:   2, Increment:   1 | -2 -1 0 1 2\nStart:  -2, Stop:   2, Increment:   0 | -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2\nStart:  -2, Stop:   2, Increment:  -1 | -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16\nStart:  -2, Stop:   2, Increment:  10 | -2 8 18 28 38 48 58 68 78 88 98 108 118 128 138\nStart:   2, Stop:  -2, Increment:   1 | 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16\nStart:   2, Stop:   2, Increment:   1 | 2\nStart:   2, Stop:   2, Increment:  -1 | 2\nStart:   2, Stop:   2, Increment:   0 | 2\nStart:   0, Stop:   0, Increment:   0 | 0\nStart:   1, Stop: Inf, Increment:   3 | 1 4 7 10 13 16 19 22 25 28 31 34 37 40 43\nStart:   0, Stop: 3.141592653589793, Increment: 0.7853981633974483 | 0 0.7853981633974483 1.5707963267948966 2.356194490192345 3.141592653589793\nStart: 1.4, Stop:   *, Increment: -7.1 | 1.4 -5.7 -12.8 -19.9 -27 -34.1 -41.2 -48.3 -55.4 -62.5 -69.6 -76.7 -83.8 -90.9 -98\n\nDemonstration of some other specialized sequence operator functionality:\n1 -0.5 1.4142135623730951 -0.7071067811865476 0.5000000000000001 -0.5000000000000002 0.176776695296637 -0.04419417382415928 0.0039062500000000095\n([0 1 2 3 4 5] [5 0 1 2 3 4] [4 5 0 1 2 3] [3 4 5 0 1 2] [2 3 4 5 0 1] [1 2 3 4 5 0])\nxp xo xn xm xl xk xj xi xh xg xf\n```"}]}
{"messages": [{"role": "user", "content": "Every square matrix \n\nA\n{\\displaystyle {\\displaystyle A}}\n can be decomposed into a product of a lower triangular matrix \n\nL\n{\\displaystyle {\\displaystyle L}}\n and a upper triangular matrix \n\nU\n{\\displaystyle {\\displaystyle U}}\n,\nas described in LU decomposition.\n\n:   A\n    =\n    L\n    U\n    {\\displaystyle {\\displaystyle A=LU}}\n\nIt is a modified form of Gaussian elimination.\nWhile the Cholesky decomposition only works for symmetric,\npositive definite matrices, the more general LU decomposition\nworks for any square matrix.\n\nThere are several algorithms for calculating L and U.\nTo derive *Crout's algorithm* for a 3x3 example,\nwe have to solve the following system:\n\n:   A\n    =\n\n\n    (\n\n    a\n\n    11\n\n\n    a\n\n    12\n\n\n    a\n\n    13\n\n    a\n\n    21\n\n\n    a\n\n    22\n\n\n    a\n\n    23\n\n    a\n\n    31\n\n\n    a\n\n    32\n\n\n    a\n\n    33\n    )\n    =\n\n\n    (\n\n    l\n\n    11\n\n    0\n\n    0\n\n    l\n\n    21\n\n\n    l\n\n    22\n\n    0\n\n    l\n\n    31\n\n\n    l\n\n    32\n\n\n    l\n\n    33\n    )\n\n\n    (\n\n    u\n\n    11\n\n\n    u\n\n    12\n\n\n    u\n\n    13\n\n\n    0\n\n\n    u\n\n    22\n\n\n    u\n\n    23\n\n\n    0\n\n    0\n\n\n    u\n\n    33\n    )\n    =\n    L\n    U\n    {\\displaystyle {\\displaystyle A={\\begin{pmatrix}a\\_{11}&a\\_{12}&a\\_{13}\\\\a\\_{21}&a\\_{22}&a\\_{23}\\\\a\\_{31}&a\\_{32}&a\\_{33}\\\\\\end{pmatrix}}={\\begin{pmatrix}l\\_{11}&0&0\\\\l\\_{21}&l\\_{22}&0\\\\l\\_{31}&l\\_{32}&l\\_{33}\\\\\\end{pmatrix}}{\\begin{pmatrix}u\\_{11}&u\\_{12}&u\\_{13}\\\\0&u\\_{22}&u\\_{23}\\\\0&0&u\\_{33}\\end{pmatrix}}=LU}}\n\nWe now would have to solve 9 equations with 12 unknowns. To make the system uniquely solvable, usually the diagonal elements of \n\nL\n{\\displaystyle {\\displaystyle L}}\n are set to 1\n\n:   l\n\n    11\n    =\n    1\n    {\\displaystyle {\\displaystyle l\\_{11}=1}}\n:   l\n\n    22\n    =\n    1\n    {\\displaystyle {\\displaystyle l\\_{22}=1}}\n:   l\n\n    33\n    =\n    1\n    {\\displaystyle {\\displaystyle l\\_{33}=1}}\n\nso we get a solvable system of 9 unknowns and 9 equations.\n\n:   A\n    =\n\n\n    (\n\n    a\n\n    11\n\n\n    a\n\n    12\n\n\n    a\n\n    13\n\n    a\n\n    21\n\n\n    a\n\n    22\n\n\n    a\n\n    23\n\n    a\n\n    31\n\n\n    a\n\n    32\n\n\n    a\n\n    33\n    )\n    =\n\n\n    (\n\n    1\n\n    0\n\n    0\n\n    l\n\n    21\n\n    1\n\n    0\n\n    l\n\n    31\n\n\n    l\n\n    32\n\n    1\n    )\n\n\n    (\n\n    u\n\n    11\n\n\n    u\n\n    12\n\n\n    u\n\n    13\n\n\n    0\n\n\n    u\n\n    22\n\n\n    u\n\n    23\n\n\n    0\n\n    0\n\n\n    u\n\n    33\n    )\n    =\n\n\n    (\n\n    u\n\n    11\n\n\n    u\n\n    12\n\n\n    u\n\n    13\n\n    u\n\n    11\n\n    l\n\n    21\n\n\n    u\n\n    12\n\n    l\n\n    21\n    +\n\n    u\n\n    22\n\n\n    u\n\n    13\n\n    l\n\n    21\n    +\n\n    u\n\n    23\n\n    u\n\n    11\n\n    l\n\n    31\n\n\n    u\n\n    12\n\n    l\n\n    31\n    +\n\n    u\n\n    22\n\n    l\n\n    32\n\n\n    u\n\n    13\n\n    l\n\n    31\n    +\n\n    u\n\n    23\n\n    l\n\n    32\n    +\n\n    u\n\n    33\n    )\n    =\n    L\n    U\n    {\\displaystyle {\\displaystyle A={\\begin{pmatrix}a\\_{11}&a\\_{12}&a\\_{13}\\\\a\\_{21}&a\\_{22}&a\\_{23}\\\\a\\_{31}&a\\_{32}&a\\_{33}\\\\\\end{pmatrix}}={\\begin{pmatrix}1&0&0\\\\l\\_{21}&1&0\\\\l\\_{31}&l\\_{32}&1\\\\\\end{pmatrix}}{\\begin{pmatrix}u\\_{11}&u\\_{12}&u\\_{13}\\\\0&u\\_{22}&u\\_{23}\\\\0&0&u\\_{33}\\end{pmatrix}}={\\begin{pmatrix}u\\_{11}&u\\_{12}&u\\_{13}\\\\u\\_{11}l\\_{21}&u\\_{12}l\\_{21}+u\\_{22}&u\\_{13}l\\_{21}+u\\_{23}\\\\u\\_{11}l\\_{31}&u\\_{12}l\\_{31}+u\\_{22}l\\_{32}&u\\_{13}l\\_{31}+u\\_{23}l\\_{32}+u\\_{33}\\end{pmatrix}}=LU}}\n\nSolving for the other \n\nl\n{\\displaystyle {\\displaystyle l}}\n and \n\nu\n{\\displaystyle {\\displaystyle u}}\n, we get the following equations:\n\n:   u\n\n    11\n    =\n\n    a\n\n    11\n    {\\displaystyle {\\displaystyle u\\_{11}=a\\_{11}}}\n:   u\n\n    12\n    =\n\n    a\n\n    12\n    {\\displaystyle {\\displaystyle u\\_{12}=a\\_{12}}}\n:   u\n\n    13\n    =\n\n    a\n\n    13\n    {\\displaystyle {\\displaystyle u\\_{13}=a\\_{13}}}\n\n:   u\n\n    22\n    =\n\n    a\n\n    22\n    −\n\n    u\n\n    12\n\n    l\n\n    21\n    {\\displaystyle {\\displaystyle u\\_{22}=a\\_{22}-u\\_{12}l\\_{21}}}\n:   u\n\n    23\n    =\n\n    a\n\n    23\n    −\n\n    u\n\n    13\n\n    l\n\n    21\n    {\\displaystyle {\\displaystyle u\\_{23}=a\\_{23}-u\\_{13}l\\_{21}}}\n\n:   u\n\n    33\n    =\n\n    a\n\n    33\n    −\n    (\n\n    u\n\n    13\n\n    l\n\n    31\n    +\n\n    u\n\n    23\n\n    l\n\n    32\n    )\n    {\\displaystyle {\\displaystyle u\\_{33}=a\\_{33}-(u\\_{13}l\\_{31}+u\\_{23}l\\_{32})}}\n\nand for \n\nl\n{\\displaystyle {\\displaystyle l}}\n:\n\n:   l\n\n    21\n    =\n\n\n    1\n\n    u\n\n    11\n\n    a\n\n    21\n    {\\displaystyle {\\displaystyle l\\_{21}={\\frac {1}{u\\_{11}}}a\\_{21}}}\n:   l\n\n    31\n    =\n\n\n    1\n\n    u\n\n    11\n\n    a\n\n    31\n    {\\displaystyle {\\displaystyle l\\_{31}={\\frac {1}{u\\_{11}}}a\\_{31}}}\n\n:   l\n\n    32\n    =\n\n\n    1\n\n    u\n\n    22\n    (\n\n    a\n\n    32\n    −\n\n    u\n\n    12\n\n    l\n\n    31\n    )\n    {\\displaystyle {\\displaystyle l\\_{32}={\\frac {1}{u\\_{22}}}(a\\_{32}-u\\_{12}l\\_{31})}}\n\nWe see that there is a calculation pattern, which can be expressed as the following formulas, first for \n\nU\n{\\displaystyle {\\displaystyle U}}\n\n:   u\n\n    i\n    j\n    =\n\n    a\n\n    i\n    j\n    −\n\n    ∑\n\n    k\n    =\n    1\n\n    i\n    −\n    1\n\n    u\n\n    k\n    j\n\n    l\n\n    i\n    k\n    {\\displaystyle {\\displaystyle u\\_{ij}=a\\_{ij}-\\sum \\_{k=1}^{i-1}u\\_{kj}l\\_{ik}}}\n\nand then for \n\nL\n{\\displaystyle {\\displaystyle L}}\n\n:   l\n\n    i\n    j\n    =\n\n\n    1\n\n    u\n\n    j\n    j\n    (\n\n    a\n\n    i\n    j\n    −\n\n    ∑\n\n    k\n    =\n    1\n\n    j\n    −\n    1\n\n    u\n\n    k\n    j\n\n    l\n\n    i\n    k\n    )\n    {\\displaystyle {\\displaystyle l\\_{ij}={\\frac {1}{u\\_{jj}}}(a\\_{ij}-\\sum \\_{k=1}^{j-1}u\\_{kj}l\\_{ik})}}\n\nWe see in the second formula that to get the \n\nl\n\ni\nj\n{\\displaystyle {\\displaystyle l\\_{ij}}}\n below the diagonal, we have to divide by the diagonal element (pivot) \n\nu\n\nj\nj\n{\\displaystyle {\\displaystyle u\\_{jj}}}\n, so we get problems when \n\nu\n\nj\nj\n{\\displaystyle {\\displaystyle u\\_{jj}}}\n is either 0 or very small, which leads to numerical instability.\n\nThe solution to this problem is *pivoting* \n\nA\n{\\displaystyle {\\displaystyle A}}\n, which means rearranging the rows of \n\nA\n{\\displaystyle {\\displaystyle A}}\n, prior to the \n\nL\nU\n{\\displaystyle {\\displaystyle LU}}\n decomposition, in a way that the largest element of each column gets onto the diagonal of \n\nA\n{\\displaystyle {\\displaystyle A}}\n. Rearranging the rows means to multiply \n\nA\n{\\displaystyle {\\displaystyle A}}\n by a permutation matrix \n\nP\n{\\displaystyle {\\displaystyle P}}\n:\n\n:   P\n    A\n    ⇒\n\n    A\n    ′\n    {\\displaystyle {\\displaystyle PA\\Rightarrow A'}}\n\nExample:\n\n:   (\n\n    0\n\n    1\n\n\n    1\n\n    0\n    )\n\n\n    (\n\n    1\n\n    4\n\n\n    2\n\n    3\n    )\n    ⇒\n\n\n    (\n\n    2\n\n    3\n\n\n    1\n\n    4\n    )\n    {\\displaystyle {\\displaystyle {\\begin{pmatrix}0&1\\\\1&0\\end{pmatrix}}{\\begin{pmatrix}1&4\\\\2&3\\end{pmatrix}}\\Rightarrow {\\begin{pmatrix}2&3\\\\1&4\\end{pmatrix}}}}\n\nThe decomposition algorithm is then applied on the rearranged matrix so that\n\n:   P\n    A\n    =\n    L\n    U\n    {\\displaystyle {\\displaystyle PA=LU}}\n\nTask description\n\nThe task is to implement a routine which will take a square nxn matrix \n\nA\n{\\displaystyle {\\displaystyle A}}\n and return a lower triangular matrix \n\nL\n{\\displaystyle {\\displaystyle L}}\n, a upper triangular matrix \n\nU\n{\\displaystyle {\\displaystyle U}}\n and a permutation matrix \n\nP\n{\\displaystyle {\\displaystyle P}}\n,\nso that the above equation is fulfilled.\n\nYou should then test it on the following two examples and include your output.\n\nExample 1\n\n```\nA\n\n1   3   5\n2   4   7\n1   1   0\n\nL\n\n1.00000   0.00000   0.00000\n0.50000   1.00000   0.00000\n0.50000  -1.00000   1.00000\n\nU\n\n2.00000   4.00000   7.00000\n0.00000   1.00000   1.50000\n0.00000   0.00000  -2.00000\n\nP\n\n0   1   0\n1   0   0\n0   0   1\n\n```\n\nExample 2\n\n```\nA\n\n11    9   24    2\n 1    5    2    6\n 3   17   18    1\n 2    5    7    1\n\nL\n\n1.00000   0.00000   0.00000   0.00000\n0.27273   1.00000   0.00000   0.00000\n0.09091   0.28750   1.00000   0.00000\n0.18182   0.23125   0.00360   1.00000\n\nU\n\n11.00000    9.00000   24.00000    2.00000\n 0.00000   14.54545   11.45455    0.45455\n 0.00000    0.00000   -3.47500    5.68750\n 0.00000    0.00000    0.00000    0.51079\n\nP\n\n1   0   0   0\n0   0   1   0\n0   1   0   0\n0   0   0   1\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nTranslation of Ruby.\n\n```\nfor (  [1, 3, 5], # Test Matrices\n       [2, 4, 7],\n       [1, 1, 0]\n    ),\n    (  [11,  9, 24,  2],\n       [ 1,  5,  2,  6],\n       [ 3, 17, 18,  1],\n       [ 2,  5,  7,  1]\n    )\n    -> @test {\n    say-it 'A Matrix', @test;\n    say-it( .[0], @(.[1]) ) for 'P Matrix', 'Aʼ Matrix', 'L Matrix', 'U Matrix' Z, lu @test;\n}\n\nsub lu (@a) {\n    die unless @a.&is-square;\n    my $n  = @a;\n    my @P  = pivotize @a;\n    my @Aʼ = mmult @P, @a;\n    my @L  = matrix-ident $n;\n    my @U  = matrix-zero  $n;\n    for ^$n X ^$n -> ($i,$j) {\n        if $j ≥ $i { @U[$i;$j] =  @Aʼ[$i;$j] - [+] map { @U[$_;$j] × @L[$i;$_] }, ^$i              }\n        else       { @L[$i;$j] = (@Aʼ[$i;$j] - [+] map { @U[$_;$j] × @L[$i;$_] }, ^$j) / @U[$j;$j] }\n    }\n    @P, @Aʼ, @L, @U;\n}\n\nsub pivotize (@m) {\n    my $size = @m;\n    my @id   = matrix-ident $size;\n    for ^$size -> $i {\n        my $max = @m[$i;$i];\n        my $row = $i;\n        for $i ..^ $size -> $j {\n            if @m[$j;$i] > $max {\n                $max = @m[$j;$i];\n                $row = $j;\n            }\n        }\n        @id[$row, $i] = @id[$i, $row] if $row != $i;\n    }\n    @id\n}\n\nsub is-square (@m) { so @m == all @m }\n\nsub matrix-zero ($n, $m = $n) { map { [ flat 0 xx $n ] }, ^$m }\n\nsub matrix-ident ($n) { map { [ flat 0 xx $_, 1, 0 xx $n - 1 - $_ ] }, ^$n }\n\nsub mmult(@a,@b) {\n    my @p;\n    for ^@a X ^@b[0] -> ($r, $c) {\n        @p[$r;$c] += @a[$r;$_] × @b[$_;$c] for ^@b;\n    }\n    @p\n}\n\nsub rat-int ($num) {\n    return $num unless $num ~~ Rat;\n    return $num.narrow if $num.narrow ~~ Int;\n    $num.nude.join: '/';\n\n}\n\nsub say-it ($message, @array) {\n    say \"\\n$message\";\n    $_».&rat-int.fmt(\"%7s\").say for @array;\n}\n\n```\n\nOutput:\n\n```\nA Matrix\n      1       3       5\n      2       4       7\n      1       1       0\n\nP Matrix\n      0       1       0\n      1       0       0\n      0       0       1\n\nAʼ Matrix\n      2       4       7\n      1       3       5\n      1       1       0\n\nL Matrix\n      1       0       0\n    1/2       1       0\n    1/2      -1       1\n\nU Matrix\n      2       4       7\n      0       1     3/2\n      0       0      -2\n\nA Matrix\n     11       9      24       2\n      1       5       2       6\n      3      17      18       1\n      2       5       7       1\n\nP Matrix\n      1       0       0       0\n      0       0       1       0\n      0       1       0       0\n      0       0       0       1\n\nAʼ Matrix\n     11       9      24       2\n      3      17      18       1\n      1       5       2       6\n      2       5       7       1\n\nL Matrix\n      1       0       0       0\n   3/11       1       0       0\n   1/11   23/80       1       0\n   2/11  37/160   1/278       1\n\nU Matrix\n     11       9      24       2\n      0  160/11  126/11    5/11\n      0       0 -139/40   91/16\n      0       0       0  71/139\n\n```"}]}
{"messages": [{"role": "user", "content": "A Lucas-Carmichael number, is a squarefree composite integer **n** such that **p+1** divides **n+1** for all the prime factors **p** of **n**.\n\nTask\n\nWrite a function that generates all the Lucas-Carmichael numbers with **n** prime factors in a given range **[A, B]**.\n\n* Show the smallest Lucas-Carmichael with **n** prime factors, for **n = 3..12**.\n\n* Show the count of Lucas-Carmichael numbers less than **10^n**, for **n = 1..10**.\n\nAlgorithm\n\nAlgorithm for generating Lucas-Carmichael numbers with n prime factors\n\nAlgorithm for generating Lucas-Carmichael numbers with n prime factors\n\nSee also\n\n* OEIS A006972: Lucas-Carmichael numbers: squarefree composite numbers k such that p | k => p+1 | k+1\n\n* OEIS A216928: Least Lucas-Carmichael number with n prime factors\n\n* OEIS A216929: Number of Lucas-Carmichael numbers less than 10^n"}, {"role": "assistant", "content": "**Translation of**: Perl\n\n```\n# 20231224 Raku programming solution\n\nsub primorial($n) { [*] ((2..*).grep: *.is-prime)[^$n] }\nsub divceil($x, $y) { ($x %% $y ?? 0 !! 1) + $x div $y } # ceil(x/y)\n\nsub LC_in_range ($A is copy, $B, $k) {\n\n   my ($max_p, @LC) = Int(sqrt($B + 1) - 1);\n   $A = max(primorial($k + 1) +> 1, $A);\n\n   sub SUB($m, $L, $lo is copy, $k) {\n\n      if $k == 1 {\n\n         my $hi = min($B div $m, $max_p);\n         $lo = max($lo, divceil($A, $m));\n\n         my $t = $L - expmod($m, -1, $L);\n         $t += $L while $t < $lo;\n         return if $t > $hi;\n\n         for $t, $t+$L ... $hi -> $p {\n            if $p.is-prime {\n               my $n = $m * $p;\n               @LC.push($n) if ($n + 1) %% ($p + 1);\n            }\n         }\n         return;\n      }\n\n      for $lo .. Int(($B div $m)**(1/$k)) -> $p {\n         if $p.is-prime and ($m gcd ($p + 1)) == 1 {\n            SUB($m * $p, ($L lcm ($p + 1)), $p + 1, $k - 1)\n         }\n      }\n   };\n\n   SUB(1, 1, 3, $k);\n\n   return @LC.sort;\n}\n\nsub LC_with_n_primes ($n) {\n   return if $n < 3;\n\n   my $y = 2 * ( my $x = primorial($n + 1) +> 1);\n\n   loop {\n      my @LC = LC_in_range($x, $y, $n);\n      return @LC[0] if @LC.Bool;\n      $x = $y + 1;\n      $y = 2 * $x;\n   }\n}\n\nsub LC_count ($A, $B) {\n   my $count = 0;\n   for 3 .. Inf -> $k {\n      last if primorial($k + 1) / 2 > $B;\n      $count += LC_in_range($A, $B, $k).elems\n   }\n   return $count;\n}\n\nsay \"Least Lucas-Carmichael number with n prime factors:\";\n\nfor 3 .. 12 -> $n { printf(\"%2d: %d\\n\", $n, LC_with_n_primes($n)) }\n\nsay \"\\nNumber of Lucas-Carmichael numbers less than 10^n:\";\n\nmy $acc = 0;\nfor 1 .. 10 -> $n {\n   my $c = LC_count(10**($n - 1), 10**$n);\n   printf(\"%2d: %s\\n\", $n, $acc + $c);\n   $acc += $c\n}\n\n```\n\nOutput is the same as Perl."}]}
{"messages": [{"role": "user", "content": "Lucas-Lehmer Test:\n\nfor \n\np\n{\\displaystyle {\\displaystyle p}}\n an odd prime, the Mersenne number \n\n2\n\np\n−\n1\n{\\displaystyle {\\displaystyle 2^{p}-1}}\n is prime if and only if \n\n2\n\np\n−\n1\n{\\displaystyle {\\displaystyle 2^{p}-1}}\n divides \n\nS\n(\np\n−\n1\n)\n{\\displaystyle {\\displaystyle S(p-1)}}\n where \n\nS\n(\nn\n+\n1\n)\n=\n(\nS\n(\nn\n)\n\n)\n\n2\n−\n2\n{\\displaystyle {\\displaystyle S(n+1)=(S(n))^{2}-2}}\n, and \n\nS\n(\n1\n)\n=\n4\n{\\displaystyle {\\displaystyle S(1)=4}}\n.\n\nTask\n\nCalculate all Mersenne primes up to the implementation's\nmaximum precision, or the 47th Mersenne prime   (whichever comes first)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmulti is_mersenne_prime(2) { True }\nmulti is_mersenne_prime(Int $p) {\n    my $m_p = 2 ** $p - 1;\n    my $s = 4;\n    $s = $s.expmod(2, $m_p) - 2 for 3 .. $p;\n    !$s\n}\n\n.say for (2,3,5,7 … *).hyper(:8degree).grep( *.is-prime ).map: { next unless .&is_mersenne_prime; \"M$_\" };\n\n```\n\nOn my system:\n\nLetting it run for about a minute...\n\n```\nM2\nM3\nM5\nM7\nM13\nM17\nM19\nM31\nM61\nM89\nM107\nM127\nM521\nM607\nM1279\nM2203\nM2281\nM3217\nM4253\nM4423\nM9689\nM9941\nM11213\n^C\n\nreal\t0m55.527s\nuser\t6m47.106s\nsys\t0m0.404s\n```\n\nLightly modernized for better parallelization and run on a Ryzen 7950X with 16 cores. Followed examples set by Wren and Phix and didn't do an exhaustive search for larger Mersennes, just verified that known ones indeed were. Pure Raku. No external libraries.\n\n```\nmulti is_mersenne_prime(2) { True }\nmulti is_mersenne_prime(Int $p) {\n    my $m_p = 1 +< $p - 1;\n    my $s = 4;\n    $s = $s.expmod(2, $m_p) - 2 for 3 .. $p;\n    !$s\n}\n\n# Exhaustive search for Mersenne primes up to 4600 - about half a second\nmy $start = now;\n.say for (flat 2, (1..2300).map(* * 2 + 1)).hyper.map: \n  { next unless .&is-prime && .&is_mersenne_prime; \"M$_ {(now - $start).round(.001)} running total seconds\" };\n\n# Cheat and just verify Mersenne primes > 4600 \n.say for (9689, 9941, 11213, 19937, 21701, 23209, 44497, 86243, 110503).hyper(:1batch).map:\n  { next unless .&is_mersenne_prime; \"M$_ {(now - $start).round(.001)} running total seconds\" };\n\n```\n\nOn my system, about 82 seconds:\n\n```\nM2 0.017 running total seconds\nM3 0.018 running total seconds\nM5 0.018 running total seconds\nM7 0.019 running total seconds\nM13 0.019 running total seconds\nM17 0.019 running total seconds\nM19 0.019 running total seconds\nM31 0.019 running total seconds\nM61 0.02 running total seconds\nM89 0.021 running total seconds\nM107 0.022 running total seconds\nM127 0.022 running total seconds\nM521 0.029 running total seconds\nM607 0.039 running total seconds\nM1279 0.084 running total seconds\nM2203 0.096 running total seconds\nM2281 0.164 running total seconds\nM3217 0.173 running total seconds\nM4253 0.336 running total seconds\nM4423 0.457 running total seconds\nM9689 0.868 running total seconds\nM9941 0.878 running total seconds\nM11213 0.953 running total seconds\nM19937 1.828 running total seconds\nM21701 2.054 running total seconds\nM23209 2.324 running total seconds\nM44497 9.186 running total seconds\nM86243 46.836 running total seconds\nM110503 81.91 running total seconds\n```"}]}
{"messages": [{"role": "user", "content": "Note that in the following explanation list indices are assumed to start at *one*.\n\nDefinition of lucky numbers\n\n*Lucky numbers* are positive integers that are formed by:\n\n1. Form a list of all the positive odd integers > 0  \n\n   1\n   ,\n   3\n   ,\n   5\n   ,\n   7\n   ,\n   9\n   ,\n   11\n   ,\n   13\n   ,\n   15\n   ,\n   17\n   ,\n   19\n   ,\n   21\n   ,\n   23\n   ,\n   25\n   ,\n   27\n   ,\n   29\n   ,\n   31\n   ,\n   33\n   ,\n   35\n   ,\n   37\n   ,\n   39...\n   {\\displaystyle {\\displaystyle 1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39...}}\n2. Return the first number from the list (which is **1**).\n3. (Loop begins here)\n   * Note then return the second number from the list (which is **3**).\n   * Discard every third, (as noted), number from the list to form the new list  \n\n     1\n     ,\n     3\n     ,\n     7\n     ,\n     9\n     ,\n     13\n     ,\n     15\n     ,\n     19\n     ,\n     21\n     ,\n     25\n     ,\n     27\n     ,\n     31\n     ,\n     33\n     ,\n     37\n     ,\n     39\n     ,\n     43\n     ,\n     45\n     ,\n     49\n     ,\n     51\n     ,\n     55\n     ,\n     57...\n     {\\displaystyle {\\displaystyle 1,3,7,9,13,15,19,21,25,27,31,33,37,39,43,45,49,51,55,57...}}\n4. (Expanding the loop a few more times...)\n   * Note then return the third number from the list (which is **7**).\n   * Discard every 7th, (as noted), number from the list to form the new list  \n\n     1\n     ,\n     3\n     ,\n     7\n     ,\n     9\n     ,\n     13\n     ,\n     15\n     ,\n     21\n     ,\n     25\n     ,\n     27\n     ,\n     31\n     ,\n     33\n     ,\n     37\n     ,\n     43\n     ,\n     45\n     ,\n     49\n     ,\n     51\n     ,\n     55\n     ,\n     57\n     ,\n     63\n     ,\n     67...\n     {\\displaystyle {\\displaystyle 1,3,7,9,13,15,21,25,27,31,33,37,43,45,49,51,55,57,63,67...}}\n   * Note then return the 4th number from the list (which is **9**).\n   * Discard every 9th, (as noted), number from the list to form the new list  \n\n     1\n     ,\n     3\n     ,\n     7\n     ,\n     9\n     ,\n     13\n     ,\n     15\n     ,\n     21\n     ,\n     25\n     ,\n     31\n     ,\n     33\n     ,\n     37\n     ,\n     43\n     ,\n     45\n     ,\n     49\n     ,\n     51\n     ,\n     55\n     ,\n     63\n     ,\n     67\n     ,\n     69\n     ,\n     73...\n     {\\displaystyle {\\displaystyle 1,3,7,9,13,15,21,25,31,33,37,43,45,49,51,55,63,67,69,73...}}\n   * Take the 5th, i.e. **13**. Remove every 13th.\n   * Take the 6th, i.e. **15**. Remove every 15th.\n   * Take the 7th, i.e. **21**. Remove every 21th.\n   * Take the 8th, i.e. **25**. Remove every 25th.\n5. (Rule for the loop)\n   * Note the \n\n     n\n     {\\displaystyle {\\displaystyle n}}\n     th, which is \n\n     m\n     {\\displaystyle {\\displaystyle m}}\n     .\n   * Remove every \n\n     m\n     {\\displaystyle {\\displaystyle m}}\n     th.\n   * Increment \n\n     n\n     {\\displaystyle {\\displaystyle n}}\n     .\n\nDefinition of even lucky numbers\n\nThis follows the same rules as the definition of lucky numbers above *except for the very first step*:\n\n1. Form a list of all the positive **even** integers > 0  \n\n   2\n   ,\n   4\n   ,\n   6\n   ,\n   8\n   ,\n   10\n   ,\n   12\n   ,\n   14\n   ,\n   16\n   ,\n   18\n   ,\n   20\n   ,\n   22\n   ,\n   24\n   ,\n   26\n   ,\n   28\n   ,\n   30\n   ,\n   32\n   ,\n   34\n   ,\n   36\n   ,\n   38\n   ,\n   40...\n   {\\displaystyle {\\displaystyle 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40...}}\n2. Return the first number from the list (which is **2**).\n3. (Loop begins here)\n   * Note then return the second number from the list (which is **4**).\n   * Discard every 4th, (as noted), number from the list to form the new list  \n\n     2\n     ,\n     4\n     ,\n     6\n     ,\n     10\n     ,\n     12\n     ,\n     14\n     ,\n     18\n     ,\n     20\n     ,\n     22\n     ,\n     26\n     ,\n     28\n     ,\n     30\n     ,\n     34\n     ,\n     36\n     ,\n     38\n     ,\n     42\n     ,\n     44\n     ,\n     46\n     ,\n     50\n     ,\n     52...\n     {\\displaystyle {\\displaystyle 2,4,6,10,12,14,18,20,22,26,28,30,34,36,38,42,44,46,50,52...}}\n4. (Expanding the loop a few more times...)\n   * Note then return the third number from the list (which is **6**).\n   * Discard every 6th, (as noted), number from the list to form the new list  \n\n     2\n     ,\n     4\n     ,\n     6\n     ,\n     10\n     ,\n     12\n     ,\n     18\n     ,\n     20\n     ,\n     22\n     ,\n     26\n     ,\n     28\n     ,\n     34\n     ,\n     36\n     ,\n     38\n     ,\n     42\n     ,\n     44\n     ,\n     50\n     ,\n     52\n     ,\n     54\n     ,\n     58\n     ,\n     60...\n     {\\displaystyle {\\displaystyle 2,4,6,10,12,18,20,22,26,28,34,36,38,42,44,50,52,54,58,60...}}\n   * Take the 4th, i.e. **10**. Remove every 10th.\n   * Take the 5th, i.e. **12**. Remove every 12th.\n5. (Rule for the loop)\n   * Note the \n\n     n\n     {\\displaystyle {\\displaystyle n}}\n     th, which is \n\n     m\n     {\\displaystyle {\\displaystyle m}}\n     .\n   * Remove every \n\n     m\n     {\\displaystyle {\\displaystyle m}}\n     th.\n   * Increment \n\n     n\n     {\\displaystyle {\\displaystyle n}}\n     .\n\nTask requirements\n\n* Write one or two subroutines (functions) to generate *lucky numbers* and *even lucky numbers*\n* Write a command-line interface to allow selection of which kind of numbers and which number(s). Since input is from the command line, tests should be made for the common errors:\n  + missing arguments\n  + too many arguments\n  + number (or numbers) aren't legal\n  + misspelled argument (**lucky** or **evenLucky**)\n* The command line handling should:\n  + support mixed case handling of the (non-numeric) arguments\n  + support printing a particular number\n  + support printing a range of numbers by their index\n  + support printing a range of numbers by their values\n* The resulting list of numbers should be printed on a single line.\n\nThe program should support the arguments:\n\n```\n                             what is displayed  (on a single line)\n       argument(s)              (optional verbiage is encouraged)\n  ╔═══════════════════╦════════════════════════════════════════════════════╗\n  ║  j                ║  Jth       lucky number                            ║\n  ║  j  ,      lucky  ║  Jth       lucky number                            ║\n  ║  j  ,  evenLucky  ║  Jth  even lucky number                            ║\n  ║                   ║                                                    ║\n  ║  j  k             ║  Jth  through  Kth (inclusive)       lucky numbers ║\n  ║  j  k      lucky  ║  Jth  through  Kth (inclusive)       lucky numbers ║\n  ║  j  k  evenLucky  ║  Jth  through  Kth (inclusive)  even lucky numbers ║\n  ║                   ║                                                    ║\n  ║  j -k             ║  all       lucky numbers in the range  j ──► |k|   ║\n  ║  j -k      lucky  ║  all       lucky numbers in the range  j ──► |k|   ║\n  ║  j -k  evenLucky  ║  all  even lucky numbers in the range  j ──► |k|   ║\n  ╚═══════════════════╩════════════════════════════════════════════════════╝\n                           where    |k|    is the absolute value of   k\n\n```\n\nDemonstrate the program by:\n\n* showing the first twenty *lucky* numbers\n* showing the first twenty *even lucky* numbers\n* showing all *lucky* numbers between 6,000 and 6,100 (inclusive)\n* showing all *even lucky* numbers in the same range as above\n* showing the 10,000th *lucky* number (extra credit)\n* showing the 10,000th *even lucky* number (extra credit)\n\nSee also\n\n* This task is related to the Sieve of Eratosthenes task.\n* OEIS Wiki Lucky numbers.\n* Sequence A000959 lucky numbers on The On-Line Encyclopedia of Integer Sequences.\n* Sequence A045954 even lucky numbers or ELN on The On-Line Encyclopedia of Integer Sequences.\n* Entry lucky numbers on The Eric Weisstein's World of Mathematics."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub luck(\\a,\\b) {\n    gather {\n\tmy @taken = take a;\n\tmy @rotor;\n\tmy $i = b;\n\n\tloop {\n\t    loop (my $j = 0; $j < @rotor; $j++) {\n\t\t--@rotor[$j] or last;\n\t    }\n\t    if $j < @rotor {\n\t\t@rotor[$j] = @taken[$j+1];\n\t    }\n\t    else {\n\t\tpush @taken, take $i;\n\t\tpush @rotor, $i - @taken;\n\t    }\n\t    $i += 2;\n\t}\n    }\n}\n\nconstant @lucky = luck(1,3);\nconstant @evenlucky = luck(2,4);\n\nsubset Luck where m:i/^ 'even'? 'lucky' $/;\n\nmulti MAIN (Int $num where * > 0) {\n    say @lucky[$num-1];\n}\n\nmulti MAIN (Int $num where * > 0, ',', Luck $howlucky = 'lucky') {\n    say @::(lc $howlucky)[$num-1];\n}\n\nmulti MAIN (Int $first where * > 0, Int $last where * > 0, Luck $howlucky = 'lucky') {\n    say @::(lc $howlucky)[$first-1 .. $last - 1];\n}\n\nmulti MAIN (Int $min where * > 0, Int $neg-max where * < 0, Luck $howlucky = 'lucky') {\n    say grep * >= $min, (@::(lc $howlucky) ...^ * > abs $neg-max);\n}\n\n```\n\nOutput:\n\n```\n$ ./lucky\nUsage:\n  ./lucky <num>\n  ./lucky <num> , [<howlucky>] \n  ./lucky <first> <last> [<howlucky>] \n  ./lucky <min> <neg-max> [<howlucky>]\n$ ./lucky 20 , lucky\n79\n$ ./lucky 20 , evenlucky\n76\n$ ./lucky 1 20\n1 3 7 9 13 15 21 25 31 33 37 43 49 51 63 67 69 73 75 79\n$ ./lucky 1 20 evenlucky\n2 4 6 10 12 18 20 22 26 34 36 42 44 50 52 54 58 68 70 76\n$ ./lucky 6000 -6100\n6009 6019 6031 6049 6055 6061 6079 6093\n$ ./lucky 6000 -6100 evenLucky\n6018 6020 6022 6026 6036 6038 6050 6058 6074 6090 6092\n$ ./lucky 10000\n115591\n$ ./lucky 10000 , EVENLUCKY\n111842\n```"}]}
{"messages": [{"role": "user", "content": "Ludic numbers   are related to prime numbers as they are generated by a sieve quite like the Sieve of Eratosthenes is used to generate prime numbers.\n\nThe first ludic number is   1.\n\nTo generate succeeding ludic numbers create an array of increasing integers starting from   2.\n\n:   `2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ...`\n\n(Loop)\n\n* Take the first member of the resultant array as the next ludic number   2.\n* Remove every   **2nd**   indexed item from the array (including the first).\n\n:   :   `2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ...`\n\n* (Unrolling a few loops...)\n* Take the first member of the resultant array as the next ludic number   3.\n* Remove every   **3rd**   indexed item from the array (including the first).\n\n:   :   `3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 ...`\n\n* Take the first member of the resultant array as the next ludic number   5.\n* Remove every   **5th**   indexed item from the array (including the first).\n\n:   :   `5 7 11 13 17 19 23 25 29 31 35 37 41 43 47 49 53 55 59 61 65 67 71 73 77 ...`\n\n* Take the first member of the resultant array as the next ludic number   7.\n* Remove every   **7th**   indexed item from the array (including the first).\n\n:   :   `7 11 13 17 23 25 29 31 37 41 43 47 53 55 59 61 67 71 73 77 83 85 89 91 97 ...`\n\n* **...**\n* Take the first member of the current array as the next ludic number   L.\n* Remove every   **Lth**   indexed item from the array (including the first).\n* **...**\n\nTask\n\n* Generate and show here the first 25 ludic numbers.\n* How many ludic numbers are there less than or equal to 1000?\n* Show the 2000..2005th ludic numbers.\n\nStretch goal\n\nShow all triplets of ludic numbers < 250.\n\n* A triplet is any three numbers     \n\n  x\n  ,\n  {\\displaystyle {\\displaystyle x,}}\n     \n\n  x\n  +\n  2\n  ,\n  {\\displaystyle {\\displaystyle x+2,}}\n     \n\n  x\n  +\n  6\n  {\\displaystyle {\\displaystyle x+6}}\n        where all three numbers are also ludic numbers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-18\n\nThis implementation has no arbitrary upper limit, since it can keep adding new rotors on the fly. It just gets slower and slower instead... :-)\n\n```\nconstant @ludic = gather {\n        my @taken = take 1;\n        my @rotor;\n \n        for 2..* -> $i {\n            loop (my $j = 0; $j < @rotor; $j++) {\n                --@rotor[$j] or last;\n            }\n            if $j < @rotor {\n                @rotor[$j] = @taken[$j+1];\n            }\n            else {\n                push @taken, take $i;\n                push @rotor, @taken[$j+1];\n            }\n        }\n    }\n \nsay @ludic[^25];\nsay \"Number of Ludic numbers <= 1000: \", +(@ludic ...^ * > 1000);\nsay \"Ludic numbers 2000..2005: \", @ludic[1999..2004];\n \nmy \\l250 = set @ludic ...^ * > 250;\nsay \"Ludic triples < 250: \", gather\n    for l250.keys.sort -> $a {\n        my $b = $a + 2;\n        my $c = $a + 6;\n        take \"<$a $b $c>\" if $b ∈ l250 and $c ∈ l250;\n    }\n\n```\n\nOutput:\n\n```\n(1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107)\nNumber of Ludic numbers <= 1000: 142\nLudic numbers 2000..2005: (21475 21481 21487 21493 21503 21511)\nLudic triples < 250: (<1 3 7> <5 7 11> <11 13 17> <23 25 29> <41 43 47> <173 175 179> <221 223 227> <233 235 239>)\n```"}]}
{"messages": [{"role": "user", "content": "The Luhn test is used by some credit card companies to distinguish valid credit card numbers from what could be a random selection of digits.\n\nThose companies using credit card numbers that can be validated by the Luhn test have numbers that pass the following test:\n\n1. Reverse the order of the digits in the number.\n2. Take the first, third, ... and every other odd digit in the reversed digits and sum them to form the partial sum s1\n3. Taking the second, fourth ... and every other even digit in the reversed digits:\n\n:   1. Multiply each digit by two and sum the digits if the answer is greater than nine to form partial sums for the even digits\n    2. Sum the partial sums of the even digits to form s2\n\n1. If s1 + s2 ends in zero then the original number is in the form of a valid credit card number as verified by the Luhn test.\n\nFor example, if the trial number is 49927398716:\n\n```\nReverse the digits:\n  61789372994\nSum the odd digits:\n  6 + 7 + 9 + 7 + 9 + 4 = 42 = s1\nThe even digits:\n    1,  8,  3,  2,  9\n  Two times each even digit:\n    2, 16,  6,  4, 18\n  Sum the digits of each multiplication:\n    2,  7,  6,  4,  9\n  Sum the last:\n    2 + 7 + 6 + 4 + 9 = 28 = s2\n\ns1 + s2 = 70 which ends in zero which means that 49927398716 passes the Luhn test\n```\n\nTask\n\nWrite a function/method/procedure/subroutine that will validate a number with the Luhn test, and\n  \nuse it to validate the following numbers:\n\n```\n   49927398716\n   49927398717\n   1234567812345678\n   1234567812345670\n\n```\n\nRelated tasks\n\n* SEDOL\n* ISIN"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-11-29\n\nHere we make use of comb, which splits into individual characters,\nand the sequence operator ..., which can intuit an even or odd sequence from the first two values.\n%% is the divisible-by operator.\n\n```\nsub luhn-test ($number --> Bool) {\n    my @digits = $number.comb.reverse;\n    my $sum = @digits[0,2...*].sum\n            + @digits[1,3...*].map({ |($_ * 2).comb }).sum;\n    return $sum %% 10;\n}\n\n# And we can test it like this:\n\nuse Test;\n\nmy @cc-numbers =\n    '49927398716'       => True,\n    '49927398717'       => False,\n    '1234567812345678'  => False,\n    '1234567812345670'  => True;\n\nplan @cc-numbers.elems;\n\nfor @cc-numbers».kv -> ($cc, $expected-result) {\n    is luhn-test(+$cc), $expected-result,\n        \"$cc {$expected-result ?? 'passes' !! 'does not pass'} the Luhn test.\";\n}\n```\n\nOutput:\n\n```\n1..4\nok 1 - 49927398716 passes the Luhn test.\nok 2 - 49927398717 does not pass the Luhn test.\nok 3 - 1234567812345678 does not pass the Luhn test.\nok 4 - 1234567812345670 passes the Luhn test.\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Lunar arithmetic. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\n**Lunar arithmetic** is a version of arithmetic in which the addition and multiplication on digits are defined as the max and min operations. Thus, in lunar arithmetic,\n\n:   2\n    +\n    7\n    =\n    max\n    {\n    2\n    ,\n    7\n    }\n    =\n    7\n    {\\displaystyle {\\displaystyle 2+7=\\max\\{2,7\\}=7}}\n     and \n\n    2\n    ×\n    7\n    =\n    min\n    {\n    2\n    ,\n    7\n    }\n    =\n    2.\n    {\\displaystyle {\\displaystyle 2\\times 7=\\min\\{2,7\\}=2.}}\n\nThe lunar arithmetic operations on nonnegative multidigit numbers are performed as in usual arithmetic as illustrated in the following examples. The world of lunar arithmetic is restricted to the set of nonnegative integers.\n\n```\n 976 +\n 348\n ----\n 978 (adding digits column-wise)\n\n```\n\n```\n    976 ×\n    348\n   ----\n   876 (multiplying the digits of 976 by 8)\n  444  (multiplying the digits of 976 by 4)\n 333   (multiplying the digits of 976 by 3)\n ------\n 34876 (adding digits column-wise)\n\n```\n\n**A few important properties of lunar arithmetic**\n\n1. The lunar addition and multiplication operations satisfy the Commutative and Associative property laws.\n2. The lunar multiplication distributes over the lunar addition.\n3. The digit 0 is the additive identity under lunar addition.\n4. The digit 9 is the multiplicative identity under lunar multiplication.\n\nNote that lunar arithmetic can be done in any base. This task is restricted to base 10 only.\n\nTask\n\nImplement lunar addition and lunar multiplication routines. Extra kudos for implementing them as operators.\n\nUse those routines (operators) to perform the following:\n\n* Lunar addition and lunar multiplication of the number groups: (976, 348), (23, 321), (232, 35), (123, 32192, 415, 8)\n* Using lunar arithmetic, find the first twenty *distinct* even numbers. \n\n  n\n  +\n  n\n  ≠\n  2\n  ×\n  n\n  {\\displaystyle {\\displaystyle n+n\\neq 2\\times n}}\n   and \n\n  n\n  +\n  n\n  =\n  n\n  {\\displaystyle {\\displaystyle n+n=n}}\n  . The even numbers are numbers of the form \n\n  2\n  ×\n  n\n  {\\displaystyle {\\displaystyle 2\\times n}}\n  .\n* Using lunar arithmetic, find the first twenty square numbers. \n\n  n\n  ×\n  n\n  {\\displaystyle {\\displaystyle n\\times n}}\n* Using lunar arithmetic, find the first twenty factorial numbers. \n\n  n\n  !\n  =\n  1\n  ×\n  2\n  ×\n  ⋯\n  ×\n  n\n  {\\displaystyle {\\displaystyle n!=1\\times 2\\times \\cdots \\times n}}\n\nStretch\n\nThe lunar squares sequence is not monotonic. Squared values are not strictly increasing as the numbers grow larger.\n\n* Find the first number whose lunar square is smaller than the previous.\n\nSee also\n:   OEIS A087019 - Lunar squares\n:   OEIS A189788 - Base-10 lunar factorials\n:   Tropical algebra overloading"}, {"role": "assistant", "content": "That's not a banana. That's a crescent moon.\n\n```\n# The operators\nsub infix:<🌙+> ($a, $b = 0) { # addition\n    +([Zmax] ('0'x$b.chars~$a).comb,('0'x$a.chars~$b).comb).join;\n}\n\nsub infix:<🌙×> ($a, $b = 9) { # multiplication\n    [🌙+] $b.flip.comb.kv.map: -> $k,$v {$a.comb.map(* min $v).join ~ '0'x$k}\n}\n\n# The task\nfor (976, 348), (23, 321), (232, 35), (123, 32192, 415, 8) {\n    say '     Lunar add: ' ~ (.join: ' 🌙+ ') ~ ' == ' ~ (.join: ' 🌙+ ').EVAL;\n    say 'Lunar multiply: ' ~ (.join: ' 🌙× ') ~ ' == ' ~ (.join: ' 🌙× ').EVAL;\n    say '';\n}\n\nsay \"First 20 distinct lunar even numbers:\\n\" ~ (^Inf).map(* 🌙× 2).unique[^20];\nsay \"\\nFirst 20 lunar square numbers:\\n\"      ~ (my @squares = (^Inf).map:{$_ 🌙× $_})[^20];\nsay \"\\nFirst 20 lunar factorial numbers:\\n\"   ~ (1..*).map({[🌙×] 1..$_})[^20];\n\n# Stretch\nsay \"\\nFirst number whose lunar square is smaller than the previous: \" ~\n(1..Inf).first: {@squares[$_ - 1] > @squares[$_]};\n\n```\n\nOutput:\n\n```\n     Lunar add: 976 🌙+ 348 == 978\nLunar multiply: 976 🌙× 348 == 34876\n\n     Lunar add: 23 🌙+ 321 == 323\nLunar multiply: 23 🌙× 321 == 2321\n\n     Lunar add: 232 🌙+ 35 == 235\nLunar multiply: 232 🌙× 35 == 2332\n\n     Lunar add: 123 🌙+ 32192 🌙+ 415 🌙+ 8 == 32498\nLunar multiply: 123 🌙× 32192 🌙× 415 🌙× 8 == 123233232\n\nFirst 20 distinct lunar even numbers:\n0 1 2 10 11 12 20 21 22 100 101 102 110 111 112 120 121 122 200 201\n\nFirst 20 lunar square numbers:\n0 1 2 3 4 5 6 7 8 9 100 111 112 113 114 115 116 117 118 119\n\nFirst 20 lunar factorial numbers:\n1 1 1 1 1 1 1 1 1 10 110 1110 11110 111110 1111110 11111110 111111110 1111111110 11111111110 111111111100\n\nFirst number whose lunar square is smaller than the previous: 1020\n```"}]}
{"messages": [{"role": "user", "content": ":   :   1. Take an integer n, greater than zero.\n        2. Form the next n of its series by reversing the digits of the current n and adding the result to the current n.\n        3. Stop when n becomes palindromic - i.e. the digits of n in reverse order == n.\n\nThe above recurrence relation when applied to most starting numbers n = 1, 2, ... terminates in a palindrome quite quickly.\n\nExample\n\nIf n0 = 12 we get\n\n```\n       12\n       12 +  21 =  33,   a palindrome!\n\n```\n\nAnd if n0 = 55 we get\n\n```\n       55\n       55 +  55 = 110\n      110 + 011 = 121,   a palindrome!\n\n```\n\nNotice that the check for a palindrome happens   *after*   an addition.\n\nSome starting numbers seem to go on forever; the recurrence relation for 196 has been calculated for millions of repetitions forming numbers with millions of digits, without forming a palindrome.\n\nThese numbers that do not end in a palindrome are called **Lychrel numbers**.\n\nFor the purposes of this task a Lychrel number is any starting number that does not form a palindrome within 500 (or more) iterations.\n\nSeed and related Lychrel numbers\n\nAny integer produced in the sequence of a Lychrel number is also a Lychrel number.\n\nIn general, any sequence from one Lychrel number *might* converge to join the sequence from a prior Lychrel number candidate; for example the sequences for the numbers 196 and then 689 begin:\n\n```\n        196\n        196 +    691 =   887\n        887 +    788 =  1675\n       1675 +   5761 =  7436\n       7436 +   6347 = 13783\n      13783 +  38731 = 52514\n      52514 +  41525 = 94039\n       ...\n\n\n        689\n        689 +    986 =  1675\n       1675 +   5761 =  7436\n       ...\n\n```\n\nSo we see that the sequence starting with 689 converges to, and continues with the same numbers as that for 196.\n\nBecause of this we can further split the Lychrel numbers into true **Seed** Lychrel number candidates, and **Related** numbers that produce no palindromes but have integers in their sequence seen as part of the sequence generated from a lower Lychrel number.\n\nTask\n\n* Find the number of seed Lychrel number candidates and related numbers for n in the range 1..10000 inclusive. (With that iteration limit of 500).\n* Print the number of seed Lychrels found; the actual seed Lychrels; and just the *number* of relateds found.\n* Print any seed Lychrel or related number that is itself a palindrome.\n\nShow all output here.\n\nReferences\n\n* What's special about 196? Numberphile video.\n* A023108 Positive integers which apparently never result in a palindrome under repeated applications of the function f(x) = x + (x with digits reversed).\n* Status of the 196 conjecture? Mathoverflow."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nmy %lychrels;\nmy @seeds;\nmy @palindromes;\nmy $count;\nmy $max = 500;\nmy $limit = '10_000';\nmy %seen;\n\nfor 1 .. $limit -> $int {\n    my @test;\n    my $index = 0;\n    if $int.&is-lychrel {\n        %lychrels.push: ($int => @test).invert;\n        @palindromes.push: $int if $int == $int.flip;\n        $count++;\n    }\n\n    sub is-lychrel (Int $l) {\n        if  %seen{$l} or $index++ > $max {\n            %seen{$_} = True for @test;\n            return True;\n        }\n        @test.push: my $m = $l + $l.flip;\n        return False if $m == $m.flip;\n        $m.&is-lychrel;\n    }\n}\n\nfor %lychrels{*}»[0].unique.sort -> $ly {\n    my $next = False;\n    for %lychrels -> $l {\n        for $l.value[1..*] -> $lt {\n            $next = True and last if $ly == $lt;\n            last if $ly < $lt;\n        }\n        last if $next;\n    }\n    next if $next;\n    @seeds.push: $ly;\n}\n\nsay \"   Number of Lychrel seed numbers < $limit: \", +@seeds;\nsay \"             Lychrel seed numbers < $limit: \", join \", \", @seeds;\nsay \"Number of Lychrel related numbers < $limit: \", +$count - @seeds;\nsay \"    Number of Lychrel palindromes < $limit: \", +@palindromes;\nsay \"              Lychrel palindromes < $limit: \", join \", \", @palindromes;\n\n```\n\nOutput:\n\n```\n   Number of Lychrel seed numbers < 10_000: 5\n             Lychrel seed numbers < 10_000: 196, 879, 1997, 7059, 9999\nNumber of Lychrel related numbers < 10_000: 244\n    Number of Lychrel palindromes < 10_000: 3\n              Lychrel palindromes < 10_000: 4994, 8778, 9999\n```"}]}
{"messages": [{"role": "user", "content": "Given a finite alphabet, we can lexicographically order all strings in the alphabet. If two strings have different lengths, then pad the shorter string on the right with the smallest letter. For example, we have 01 > 001, but 01 = 010. As we see, this order is a total preorder, but not a total order, since it identifies different strings.\n\nA Lyndon word is a non-empty string that is *strictly* lower in lexicographic order than all its circular rotations. In particular, if a string is equal to a circular rotation, then it is not a Lyndon word. For example, since 0101 = 0101 (rotation by 2), it is not a Lyndon word.\n\nThe first Lyndon words on the binary alphabet {0, 1} are:\n\n:   0, 1, 01, 001, 011, 0001, 0011, 0111, 00001, 00011, 00101, 00111, 01011, 01111, ...\n\n**Task:** Given a positive number \n\nn\n{\\displaystyle {\\displaystyle n}}\n and an ordered list of alphabet, list all Lyndon words of length at most \n\nn\n{\\displaystyle {\\displaystyle n}}\n, in the lexicographic order.\n\nDuval (1988) provides an efficient algorithm. If \n\nw\n{\\displaystyle {\\displaystyle w}}\n is one of the words in the sequence, then the next word after \n\nw\n{\\displaystyle {\\displaystyle w}}\n can be found by the following steps:\n\n1. Repeat \n\n   w\n   {\\displaystyle {\\displaystyle w}}\n    and truncate it to a new word \n\n   x\n   {\\displaystyle {\\displaystyle x}}\n    of length exactly \n\n   n\n   {\\displaystyle {\\displaystyle n}}\n   .\n2. As long as the final symbol of \n\n   x\n   {\\displaystyle {\\displaystyle x}}\n    is the last symbol in the sorted ordering of the alphabet, remove it, producing a shorter word.\n3. Replace the final remaining symbol of \n\n   x\n   {\\displaystyle {\\displaystyle x}}\n    by its successor in the sorted ordering of the alphabet.\n\nFor example, suppose we have generated the binary Lyndon words of length up to 7, and we have generated up to \n\nw\n=\n00111\n{\\displaystyle {\\displaystyle w=00111}}\n, then the steps are:\n\n1. Repeat and truncate to get \n\n   x\n   =\n   00111\n\n   00\n\n\n   111\n   {\\displaystyle {\\displaystyle x=00111\\;00{\\cancel {111}}}}\n2. Since the last symbol is 0, it is not the final symbol.\n3. Increment the last symbol to obtain \n\n   x\n   =\n   00111\n\n   01\n   {\\displaystyle {\\displaystyle x=00111\\;01}}\n   ."}, {"role": "assistant", "content": "**Translation of**: Julia\n\n```\n# 20240211 Raku programming solution\n\nsub nextword($n, $w, $alphabet) {\n   my $x = ($w x ($n div $w.chars + 1)).substr(0, $n);\n   while $x.Bool && $x.substr(*-1) eq $alphabet.substr(*-1) {\n      $x.substr-rw(*-1) = ''\n   }\n   if $x.Bool {\n      my $next_char_index  = ($alphabet.index($x.substr(*-1)) // 0) + 1;\n      $x.substr-rw(*-1, 1) = $alphabet.substr($next_char_index, 1);\n   }\n   return $x;\n}\n\n.say for sub ($n, $alphabet) {\n   my $w = $alphabet.substr(0, 1);\n   return gather while $w.chars <= $n {\n      take $w;\n      last unless $w = nextword($n, $w, $alphabet);\n   }\n}(5, '01');\n\n```\n\nOutput:\n\nSame as Julia example.\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "The Lempel-Ziv-Welch (LZW) algorithm provides loss-less data compression.\n\nYou can read a complete description of it in the   Wikipedia article   on the subject.   It was patented, but it entered the public domain in 2004."}, {"role": "assistant", "content": "(formerly Perl 6) I just came across this SO question by chance hence the update. Notably the ancestor Perl entry simply works without any further tweak.\n\n**Translation of**: Perl\n\n```\n# 20200421 Updated Raku programming solution ; add unicode support\n\nsub compress(Str $uncompressed --> Seq)  { \n    my $dict-size = 256;\n    my %dictionary = (.chr => .chr for ^$dict-size);\n \n    my $w = \"\";\n    gather {\n  for $uncompressed.encode('utf8').list.chrs.comb -> $c {\n      my $wc = $w ~ $c;\n      if %dictionary{$wc}:exists { $w = $wc }\n      else {\n    take %dictionary{$w};\n    %dictionary{$wc} = +%dictionary;\n    $w = $c;\n      }\n  }\n     \n  take %dictionary{$w} if $w.chars;\n    }\n}\n \nsub decompress(@compressed --> Str) { \n    my $dict-size = 256;\n    my %dictionary = (.chr => .chr for ^$dict-size);\n \n    my $w = shift @compressed;\n    ( Blob.new: flat ( gather {\n  take $w;\n  for @compressed -> $k {\n      my $entry;\n      if %dictionary{$k}:exists { take $entry = %dictionary{$k} }\n      elsif $k == $dict-size    { take $entry = $w ~ $w.substr(0,1) }\n      else                      { die \"Bad compressed k: $k\" }\n     \n      %dictionary{$dict-size++} = $w ~ $entry.substr(0,1);\n      $w = $entry;\n  }\n    }  )».ords ).decode('utf-8')\n}\n \nsay my @compressed = compress('TOBEORNOTTOBEORTOBEORNOT');\nsay decompress(@compressed);\n\n@compressed = compress('こんにちは𝒳𝒴𝒵こんにちは𝒳𝒴𝒵こんにちは𝒳𝒴𝒵');\nsay decompress(@compressed);\n\n```\n\nOutput:\n\n```\n[T O B E O R N O T 256 258 260 265 259 261 263]\nTOBEORNOTTOBEORTOBEORNOT\nこんにちは𝒳𝒴𝒵こんにちは𝒳𝒴𝒵こんにちは𝒳𝒴𝒵\n\n```"}]}
{"messages": [{"role": "user", "content": "Every connected device around the world comes with a unique Media Access Control address, or a   MAC address.\n\nA common task a network administrator may come across is being able to identify a network device's manufacturer when given only a MAC address.\n\nTask\n\nInterface with one (or numerous) APIs that exist on the internet and retrieve the device manufacturer based on a supplied MAC address.\n\nA MAC address that does not return a valid result should return the String \"N/A\".   An error related to the network connectivity or the API should return a null result.\n\nMany implementations on this page use http://api.macvendors.com/ which, as of 19th September 2021, is throttling requests. After only 2 calls, the following response is returned for all subsequent requests. If you are planning to use the same provider or going to run the examples on this page, consider building in a delay between two calls.\n\n**{\"errors\":{\"detail\":\"Too Many Requests\",\"message\":\"Please slow down your requests or upgrade your plan at https://macvendors.com\"}}**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nApparently there is some rate limiting on place now, sleep a bit between requests.\n\n```\nuse HTTP::UserAgent;\n \nmy $ua = HTTP::UserAgent.new;\n \n$ua.timeout = 10; # seconds\n \nmy $server = 'http://api.macvendors.com/';\n \nsub lookup ($mac) {\n    my $response = $ua.get: \"$server+$mac\";\n    sleep 1;\n    return $response.is-success ?? $response.content !! 'N/A';\n \n    CATCH {             # Normally you would report some information about what\n        default { Nil } # went wrong, but the task specifies to ignore errors.\n    }\n}\n \nfor <\nBC:5F:F4\nFC-A1-3E\n10:dd:b1\n00:0d:4b\n23:45:67\n> -> $mac { say lookup $mac }\n\n```\n\nOutput:\n\n```\nASRock Incorporation\nSamsung Electronics Co.,Ltd\nApple, Inc.\nRoku, Inc.\nN/A\n\n```"}]}
{"messages": [{"role": "user", "content": "The task requires poking machine code directly into memory and executing it. The machine code is the architecture-specific opcodes which have the simple task of adding two unsigned bytes together and making the result available to the high-level language.\n\nFor example, the following assembly language program is given for x86 (32 bit) architectures:\n\n```\nmov EAX, [ESP+4]\nadd EAX, [ESP+8]\nret\n\n```\n\nThis would translate into the following opcode bytes:\n\n```\n139 68 36 4 3 68 36 8 195\n\n```\n\nOr in hexadecimal:\n\n```\n8B 44 24 04 03 44 24 08 C3\n\n```\n\nTask\n\nIf different than 32-bit x86, specify the target architecture of the machine code for your example. It may be helpful to also include an assembly version of the machine code for others to reference and understand what is being executed. Then, implement the following in your favorite programming language:\n\n* Poke the necessary opcodes into a memory location.\n* Provide a means to pass two values to the machine code.\n* Execute the machine code with the following arguments: unsigned-byte argument of value 7; unsigned-byte argument of value 12; The result would be 19.\n* Perform any clean up actions that are appropriate for your chosen language (free the pointer or memory allocations, etc.)"}, {"role": "assistant", "content": "I don't know how to translate this C line\n\n```\nc = ((int (*) (int, int))buf)(a, b);\n\n```\n\nso cannot solve the task with an idiomatic solution. I have also tried with Go's approach by adding a helper program but it also doesn't work out. Nonetheless I just present the attempt here so perhaps someone can fix that in 10 seconds.\n\n```\nuse NativeCall;\n\nconstant PROT_READ   = 0x1;   #\nconstant PROT_WRITE  = 0x2;   #\nconstant PROT_EXEC   = 0x4;   # from local /usr/include/bits/mman.h\nconstant MAP_PRIVATE = 0x02;  #\nconstant MAP_ANON    = 0x20;  #\n\nsub mmap(Pointer $addr, size_t $length, int32 $prot, int32 $flags,\n   int32 $fd, size_t $offset --> Pointer) is native { * };\nsub memcpy(Pointer $dest, Pointer $src, size_t $size --> Pointer) is native {*}\nsub munmap(Pointer $addr, size_t $length) is native { * };\n\nsub test (uint8 $a, uint8 $b) {\n   my $code = CArray[uint8].new(\n      0x90, 0x90, 0x6A, 0xC, 0xB8, 0x7, 0x0, 0x0, 0x0, 0x48, 0xC1, 0xE0, 0x20,\n      0x50, 0x8B, 0x44, 0x24, 0x4, 0x3, 0x44, 0x24, 0x8, 0x4C, 0x89, 0xE3, 0x89,\n      0xC3, 0x48, 0xC1, 0xE3, 0x4, 0x80, 0xCB, 0x2, 0x48, 0x83, 0xC4, 0x10, 0xC3   \n   );\n   my $buf =\n      mmap(Pointer, nativesizeof($code), PROT_READ +| PROT_WRITE +| PROT_EXEC,\n      MAP_PRIVATE +| MAP_ANON, -1, 0);\n\n   memcpy($buf, nativecast(Pointer,$code), nativesizeof($code));\n\n   my $c; # = ((int (*) (int, int))buf)(a, b);\n\n   munmap($buf, nativesizeof($code));\n\n   return $c = \"Incomplete Attempt\";\n}\n\nsay test 7, 12;\n\n```\n\nIn the mean time, here is a less desirable approach by writing a wrapper for the C entry, with the 64 bit instructions from PicoLisp ..\n\n**Translation of**: C\n\ntest.c\n\n```\n#include <stdio.h>\n#include <stdlib.h>\n#include <sys/mman.h>\n#include <string.h>\n\nint test (int a, int b)\n{\n  char code[] = {\n     0x90, 0x90, 0x6A, 0xC, 0xB8, 0x7, 0x0, 0x0, 0x0, 0x48, 0xC1, 0xE0, 0x20,\n     0x50, 0x8B, 0x44, 0x24, 0x4, 0x3, 0x44, 0x24, 0x8, 0x4C, 0x89, 0xE3, 0x89,\n     0xC3, 0x48, 0xC1, 0xE3, 0x4, 0x80, 0xCB, 0x2, 0x48, 0x83, 0xC4, 0x10, 0xC3\n  };\n\n  void *buf;\n  int c;\n  /* copy code to executable buffer */\n  buf = mmap (0,sizeof(code),PROT_READ|PROT_WRITE|PROT_EXEC,\n             MAP_PRIVATE|MAP_ANON,-1,0);\n  memcpy (buf, code, sizeof(code));\n  /* run code */\n  c = ((int (*) (int, int))buf)(a, b);\n  /* free buffer */\n  munmap (buf, sizeof(code));\n  return c;\n}\n\n```\n\nmcode.raku\n\n```\n#!/usr/bin/env raku\n\n# 20200501 Raku programming solution\n\nuse NativeCall;\n\nconstant LIBTEST = '/home/user/LibTest.so';\n\nsub test(uint8 $a, uint8 $b) returns uint8 is native(LIBTEST) { * };\n\nsay test 7, 12;\n\n```\n\nOutput:\n\n```\ngcc -Wall -fPIC -shared -o LibTest.so test.c\n\nfile LibTest.so\nLibTest.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=90d2695df9a56b88a57144147fb9288ac07b172f, not stripped\n./mcode.raku\n\n19\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Mad Libs. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nMad Libs is a phrasal template word game where one player prompts another for a list of words to substitute for blanks in a story, usually with funny results.\n\nTask;\n\nWrite a program to create a Mad Libs like story.\n\nThe program should read an arbitrary multiline story from input.\n\nThe story will be terminated with a blank line.\n\nThen, find each replacement to be made within the story, ask the user for a word to replace it with, and make all the replacements.\n\nStop when there are none left and print the final story.\n\nThe input should be an arbitrary story in the form:\n\n```\n<name> went for a walk in the park. <he or she>\nfound a <noun>. <name> decided to take it home.\n\n```\n\nGiven this example, it should then ask for a name, a he or she and a noun (<name> gets replaced both times with the same value).\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-18\n\nSome explanation: S:g[...] = ... is a global substitution that returns its result. % is an anonymous state variable in which we cache any results of a prompt using the //= operator, which assigns only if the left side is undefined. slurp reads an entire file from STDIN or as named in the argument list.\n\n```\nprint S:g[ '<' (.*?) '>' ] = %.{$0} //= prompt \"$0? \" given slurp;\n\n```\n\nSample run:\n\n```\n$ madlibs walk\nname? Phydeaux\nHe or She? She\nnoun? flea\nPhydeaux went for a walk in the park. She\nfound a flea. Phydeaux decided to take it home.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate Magic 8-Ball.\n\nSee details at:   Magic 8-Ball.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nput 'Please enter your question or a blank line to quit.';\n\n[\"It is certain\", \"It is decidedly so\", \"Without a doubt\", \"Yes, definitely\",\n \"You may rely on it\", \"As I see it, yes\", \"Most likely\", \"Outlook good\",\n \"Signs point to yes\", \"Yes\", \"Reply hazy, try again\", \"Ask again later\",\n \"Better not tell you now\", \"Cannot predict now\", \"Concentrate and ask again\",\n \"Don't bet on it\", \"My reply is no\", \"My sources say no\", \"Outlook not so good\",\n \"Very doubtful\"].roll.put while prompt('? : ').chars;\n\n```\n\nOutput very similar to C, Kotlin and zkl examples."}]}
{"messages": [{"role": "user", "content": "A magic square is a square grid containing consecutive integers from 1 to N², arranged so that every row, column and diagonal adds up to the same number. That number is a constant. There is no way to create a valid N x N magic square that does not sum to the associated constant.\n\nEG\n\nA 3 x 3 magic square *always* sums to 15.\n\n```\n    ┌───┬───┬───┐\n    │ 2 │ 7 │ 6 │\n    ├───┼───┼───┤\n    │ 9 │ 5 │ 1 │\n    ├───┼───┼───┤\n    │ 4 │ 3 │ 8 │\n    └───┴───┴───┘\n```\n\nA 4 x 4 magic square *always* sums to 34.\n\nTraditionally, the sequence leaves off terms for n = 0 and n = 1 as the magic squares of order 0 and 1 are trivial; and a term for n = 2 because it is impossible to form a magic square of order 2.\n\nTask\n\n* Starting at order 3, show the first 20 magic constants.\n* Show the 1000th magic constant. (Order 1003)\n* Find and show the order of the smallest N x N magic square whose constant is greater than 10¹ through 10¹⁰.\n\nStretch\n\n* Find and show the order of the smallest N x N magic square whose constant is greater than 10¹¹ through 10²⁰.\n\nSee also\n\n* Wikipedia: Magic constant\n* OEIS: A006003 (Similar sequence, though it includes terms for 0, 1 & 2.)\n* Magic squares of odd order\n* Magic squares of singly even order\n* Magic squares of doubly even order"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers:ver<2.8+>;\n\nmy @magic-constants = lazy (3..∞).hyper.map: { (1 + .²) * $_ / 2 };\n\nput \"First 20 magic constants: \", @magic-constants[^20]».&comma;\nsay \"1000th magic constant: \", @magic-constants[999].&comma;\nsay \"\\nSmallest order magic square with a constant greater than:\";\n\n(1..20).map: -> $p {printf \"10%-2s: %s\\n\", $p.&super, comma 3 + @magic-constants.first( * > exp($p, 10), :k ) }\n\n```\n\nOutput:\n\n```\nFirst 20 magic constants: 15 34 65 111 175 260 369 505 671 870 1,105 1,379 1,695 2,056 2,465 2,925 3,439 4,010 4,641 5,335\n1000th magic constant: 503,006,505\n\nSmallest order magic square with a constant greater than:\n10¹ : 3\n10² : 6\n10³ : 13\n10⁴ : 28\n10⁵ : 59\n10⁶ : 126\n10⁷ : 272\n10⁸ : 585\n10⁹ : 1,260\n10¹⁰: 2,715\n10¹¹: 5,849\n10¹²: 12,600\n10¹³: 27,145\n10¹⁴: 58,481\n10¹⁵: 125,993\n10¹⁶: 271,442\n10¹⁷: 584,804\n10¹⁸: 1,259,922\n10¹⁹: 2,714,418\n10²⁰: 5,848,036\n```"}]}
{"messages": [{"role": "user", "content": "Magic numbers are polydivisible numbers in base 10. A polydivisible number is an **m** digit number where the first **n** digits are evenly divisible by **n** for all **n** from **1** to **m**.\n\nE.G. The number **1868587** is a magic number (is polydivisible in base 10.)\n\n```\n      1 ÷ 1 = 1\n     18 ÷ 2 = 9\n    186 ÷ 3 = 62\n   1868 ÷ 4 = 467\n  18685 ÷ 5 = 3737\n 186858 ÷ 6 = 31143\n1868587 ÷ 7 = 266941\n```\n\nThere is a finite number of magic numbers.\n\nTask\n\n* Write a routine (subroutine, function, procedure, generator, whatever it may be called in your language) to find magic numbers.\n* Use that routine to find and display how many magic numbers exist.\n* Use that routine to find and display the largest possible magic number.\n* Count and display how many magic numbers have 1 digit, 2 digits, 3 digits, ... for all magic numbers.\n* Find and display all of the magic numbers that are minimally pandigital in **1** through **9**. (Contains each digit but only once.)\n* Find and display all of the magic numbers that are minimally pandigital in **0** through **9**.\n\n*Zero (0) may or may not be included as a magic number. For this task, include zero.*\n\nSee also\n\n* Wikipedia: Polydivisible numbers * OEIS:A144688 - \"Magic\" numbers * OEIS:A143671 - Count of \"Magic\" numbers with n digits"}, {"role": "assistant", "content": "```\nmy \\Δ = $ = 1;\nmy @magic = flat 0, [1..9], {last if .not; ++Δ; [(.flat X~ 0..9).grep: * %% Δ]}…*;\n\nput \"There are {@magic.eager.elems} magic numbers in total.\";\nput \"\\nThe largest is {@magic.tail}.\";\nput \"\\nThere are:\";\nput \"{(+.value).fmt: \"%4d\"} with {.key.fmt: \"%2d\"} digit{1 == +.key ?? '' !! 's'}\"\n    for sort @magic.classify: {.chars};\n{\n    my $pan-digital = ($_..9).join.comb.Bag;\n    put \"\\nAll magic numbers that are pan-digital in $_ through 9 with no repeats: \" ~\n    @magic.grep( { .comb.Bag eqv $pan-digital } );\n} for 1, 0;\n\n```\n\nOutput:\n\n```\nThere are 20457 magic numbers in total.\n\nThe largest is 3608528850368400786036725.\n\nThere are:\n  10 with  1 digit\n  45 with  2 digits\n 150 with  3 digits\n 375 with  4 digits\n 750 with  5 digits\n1200 with  6 digits\n1713 with  7 digits\n2227 with  8 digits\n2492 with  9 digits\n2492 with 10 digits\n2225 with 11 digits\n2041 with 12 digits\n1575 with 13 digits\n1132 with 14 digits\n 770 with 15 digits\n 571 with 16 digits\n 335 with 17 digits\n 180 with 18 digits\n  90 with 19 digits\n  44 with 20 digits\n  18 with 21 digits\n  12 with 22 digits\n   6 with 23 digits\n   3 with 24 digits\n   1 with 25 digits\n\nAll magic numbers that are pan-digital in 1 through 9 with no repeats: 381654729\n\nAll magic numbers that are pan-digital in 0 through 9 with no repeats: 3816547290\n```"}]}
{"messages": [{"role": "user", "content": "A magic square is an   **N×N**  square matrix whose numbers consist of consecutive numbers arranged so that the sum of each row and column,   *and*   both diagonals are equal to the same sum   (which is called the *magic number* or *magic constant*).\n\nA magic square of doubly even order has a size that is a multiple of four   (e.g.     **4**, **8**, **12**).\n\nThis means that the subsquares also have an even size, which plays a role in the construction.\n\n|  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- |\n| **1** | **2** | **62** | **61** | **60** | **59** | **7** | **8** |\n| **9** | **10** | **54** | **53** | **52** | **51** | **15** | **16** |\n| **48** | **47** | **19** | **20** | **21** | **22** | **42** | **41** |\n| **40** | **39** | **27** | **28** | **29** | **30** | **34** | **33** |\n| **32** | **31** | **35** | **36** | **37** | **38** | **26** | **25** |\n| **24** | **23** | **43** | **44** | **45** | **46** | **18** | **17** |\n| **49** | **50** | **14** | **13** | **12** | **11** | **55** | **56** |\n| **57** | **58** | **6** | **5** | **4** | **3** | **63** | **64** |\n\nTask\n\nCreate a magic square of   **8 × 8**.\n\nRelated tasks\n\n* Magic squares of odd order\n* Magic squares of singly even order\n\nSee also\n\n* Doubly Even Magic Squares (1728.org)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nSee Magic squares/Raku for a general magic square generator.\n\nOutput:\n\nWith a parameter of 8:\n\n```\n 1  2 62 61 60 59  7  8\n 9 10 54 53 52 51 15 16\n48 47 19 20 21 22 42 41\n40 39 27 28 29 30 34 33\n32 31 35 36 37 38 26 25\n24 23 43 44 45 46 18 17\n49 50 14 13 12 11 55 56\n57 58  6  5  4  3 63 64\n\nThe magic number is 260\n```\n\nWith a parameter of 12:\n\n```\n  1   2   3 141 140 139 138 137 136  10  11  12\n 13  14  15 129 128 127 126 125 124  22  23  24\n 25  26  27 117 116 115 114 113 112  34  35  36\n108 107 106  40  41  42  43  44  45  99  98  97\n 96  95  94  52  53  54  55  56  57  87  86  85\n 84  83  82  64  65  66  67  68  69  75  74  73\n 72  71  70  76  77  78  79  80  81  63  62  61\n 60  59  58  88  89  90  91  92  93  51  50  49\n 48  47  46 100 101 102 103 104 105  39  38  37\n109 110 111  33  32  31  30  29  28 118 119 120\n121 122 123  21  20  19  18  17  16 130 131 132\n133 134 135   9   8   7   6   5   4 142 143 144\n\nThe magic number is 870\n```"}]}
{"messages": [{"role": "user", "content": "A magic square is an   **NxN**   square matrix whose numbers (usually integers) consist of consecutive numbers arranged so that the sum of each row and column,   *and*   both long (main) diagonals are equal to the same sum (which is called the   *magic number*   or   *magic constant*).\n\nThe numbers are usually (but not always) the first   **N**2   positive integers.\n\nA magic square whose rows and columns add up to a magic number but whose main diagonals do not, is known as a *semimagic square*.\n\n|  |  |  |\n| --- | --- | --- |\n| **8** | **1** | **6** |\n| **3** | **5** | **7** |\n| **4** | **9** | **2** |\n\nTask\n\nFor any odd   **N**,   generate a magic square with the integers    **1** ──► **N**,   and show the results here.\n\nOptionally, show the *magic number*.\n\nYou should demonstrate the generator by showing at least a magic square for   **N** = **5**.\n\nRelated tasks\n\n* Magic squares of singly even order\n* Magic squares of doubly even order\n\nSee also\n\n* MathWorld™ entry: Magic\\_square\n* Odd Magic Squares (1728.org)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nSee Magic squares/Raku for a general magic square generator.\n\nOutput:\n\nWith a parameter of 5:\n\n```\n17 24  1  8 15\n23  5  7 14 16\n 4  6 13 20 22\n10 12 19 21  3\n11 18 25  2  9\n\nThe magic number is 65\n```\n\nWith a parameter of 19:\n\n```\n192 213 234 255 276 297 318 339 360   1  22  43  64  85 106 127 148 169 190\n212 233 254 275 296 317 338 359  19  21  42  63  84 105 126 147 168 189 191\n232 253 274 295 316 337 358  18  20  41  62  83 104 125 146 167 188 209 211\n252 273 294 315 336 357  17  38  40  61  82 103 124 145 166 187 208 210 231\n272 293 314 335 356  16  37  39  60  81 102 123 144 165 186 207 228 230 251\n292 313 334 355  15  36  57  59  80 101 122 143 164 185 206 227 229 250 271\n312 333 354  14  35  56  58  79 100 121 142 163 184 205 226 247 249 270 291\n332 353  13  34  55  76  78  99 120 141 162 183 204 225 246 248 269 290 311\n352  12  33  54  75  77  98 119 140 161 182 203 224 245 266 268 289 310 331\n 11  32  53  74  95  97 118 139 160 181 202 223 244 265 267 288 309 330 351\n 31  52  73  94  96 117 138 159 180 201 222 243 264 285 287 308 329 350  10\n 51  72  93 114 116 137 158 179 200 221 242 263 284 286 307 328 349   9  30\n 71  92 113 115 136 157 178 199 220 241 262 283 304 306 327 348   8  29  50\n 91 112 133 135 156 177 198 219 240 261 282 303 305 326 347   7  28  49  70\n111 132 134 155 176 197 218 239 260 281 302 323 325 346   6  27  48  69  90\n131 152 154 175 196 217 238 259 280 301 322 324 345   5  26  47  68  89 110\n151 153 174 195 216 237 258 279 300 321 342 344   4  25  46  67  88 109 130\n171 173 194 215 236 257 278 299 320 341 343   3  24  45  66  87 108 129 150\n172 193 214 235 256 277 298 319 340 361   2  23  44  65  86 107 128 149 170\n\nThe magic number is 3439\n```"}]}
{"messages": [{"role": "user", "content": "A magic square is an **NxN** square matrix whose numbers consist of consecutive numbers arranged so that the sum of each row and column, *and* both diagonals are equal to the same sum (which is called the *magic number* or *magic constant*).\n\nA magic square of singly even order has a size that is a multiple of 4, plus 2 (e.g. 6, 10, 14). This means that the subsquares have an odd size, which plays a role in the construction.\n\nTask\n\nCreate a magic square of 6 x 6.\n\nRelated tasks\n\n* Magic squares of odd order\n* Magic squares of doubly even order\n\nSee also\n\n* Singly Even Magic Squares (1728.org)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nSee Magic squares/Raku for a general magic square generator.\n\nOutput:\n\nWith a parameter of 6:\n\n```\n35  1  6 26 19 24\n 3 32  7 21 23 25\n31  9  2 22 27 20\n 8 28 33 17 10 15\n30  5 34 12 14 16\n 4 36 29 13 18 11\n\nThe magic number is 111\n```\n\nWith a parameter of 10:\n\n```\n 92  99   1   8  15  67  74  51  58  40\n 98  80   7  14  16  73  55  57  64  41\n  4  81  88  20  22  54  56  63  70  47\n 85  87  19  21   3  60  62  69  71  28\n 86  93  25   2   9  61  68  75  52  34\n 17  24  76  83  90  42  49  26  33  65\n 23   5  82  89  91  48  30  32  39  66\n 79   6  13  95  97  29  31  38  45  72\n 10  12  94  96  78  35  37  44  46  53\n 11  18 100  77  84  36  43  50  27  59\n\nThe magic number is 505\n```"}]}
{"messages": [{"role": "user", "content": "A magnanimous number is an integer where there is no place in the number where a + (plus sign) could be added between any two digits to give a non-prime sum.\n\nE.G.\n\n:   * **6425** is a magnanimous number. **6 + 425 == 431** which is prime; **64 + 25 == 89** which is prime; **642 + 5 == 647** which is prime.\n\n:   * **3538** is **not** a magnanimous number. **3 + 538 == 541** which is prime; **35 + 38 == 73** which is prime; but **353 + 8 == 361** which is **not** prime.\n\nTraditionally the single digit numbers 0 through 9 **are** included as magnanimous numbers as there is no place in the number where you can add a plus between two digits at all. (Kind of weaselly but there you are...) Except for the actual value 0, leading zeros are not permitted. Internal zeros are fine though, **1001** -> **1 + 001** (prime), **10 + 01** (prime) **100 + 1** (prime).\n\nThere are only 571 known magnanimous numbers. It is strongly suspected, though not rigorously proved, that there are no magnanimous numbers above **97393713331910**, the largest one known.\n\nTask\n\n:   * Write a routine (procedure, function, whatever) to find **magnanimous numbers**.\n\n:   * Use that function to find and display, here on this page the first **45** magnanimous numbers.\n\n:   * Use that function to find and display, here on this page the **241st** through **250th** magnanimous numbers.\n\n:   * Stretch: Use that function to find and display, here on this page the **391st** through **400th** magnanimous numbers\n\nSee also\n\n* OEIS:A252996 - Magnanimous numbers: numbers such that the sum obtained by inserting a \"+\" anywhere between two digits gives a prime."}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.02\n\n```\nmy @magnanimous = lazy flat ^10, (10 .. 1001).map( {\n    my int $last;\n    (1 ..^ .chars).map: -> \\c { $last = 1 and last unless (.substr(0,c) + .substr(c)).is-prime }\n    next if $last;\n    $_\n} ),\n\n(1002 .. ∞).map: {\n     # optimization for numbers > 1001; First and last digit can not both be even or both be odd\n    next if (.substr(0,1) + .substr(*-1)) %% 2;\n    my int $last;\n    (1 ..^ .chars).map: -> \\c { $last = 1 and last unless (.substr(0,c) + .substr(c)).is-prime }\n    next if $last;\n    $_\n}\n\nput 'First 45 magnanimous numbers';\nput @magnanimous[^45]».fmt('%3d').batch(15).join: \"\\n\";\n\nput \"\\n241st through 250th magnanimous numbers\";\nput @magnanimous[240..249];\n\nput \"\\n391st through 400th magnanimous numbers\";\nput @magnanimous[390..399];\n\n```\n\nOutput:\n\n```\nFirst 45 magnanimous numbers\n  0   1   2   3   4   5   6   7   8   9  11  12  14  16  20\n 21  23  25  29  30  32  34  38  41  43  47  49  50  52  56\n 58  61  65  67  70  74  76  83  85  89  92  94  98 101 110\n\n241st through 250th magnanimous numbers\n17992 19972 20209 20261 20861 22061 22201 22801 22885 24407\n\n391st through 400th magnanimous numbers\n486685 488489 515116 533176 551558 559952 595592 595598 600881 602081\n```"}]}
{"messages": [{"role": "user", "content": "GOST 28147-89 is a standard symmetric encryption based on a Feistel network.\n\nThe structure of the algorithm consists of three levels:\n\n1. encryption modes - simple replacement, application range, imposing a range of feedback and authentication code generation;\n2. cycles - 32-З, 32-Р and 16-З, is a repetition of the main step;\n3. *main step*, a function that takes a 64-bit block of text and one of the eight 32-bit encryption key elements, and uses the replacement table (8x16 matrix of 4-bit values), and returns encrypted block.\n\nTask\n\nImplement the main step of this encryption algorithm."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2012-10-30\n\nImplemented to match explanation on Discussion page:\n\n```\n# sboxes from http://en.wikipedia.org/wiki/GOST_(block_cipher)\nconstant sbox =\n    [4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3],\n    [14, 11, 4, 12, 6, 13, 15, 10, 2, 3, 8, 1, 0, 7, 5, 9],\n    [5, 8, 1, 13, 10, 3, 4, 2, 14, 15, 12, 7, 6, 0, 9, 11],\n    [7, 13, 10, 1, 0, 8, 9, 15, 14, 4, 6, 12, 11, 2, 5, 3],\n    [6, 12, 7, 1, 5, 15, 13, 8, 4, 10, 9, 14, 0, 3, 11, 2],\n    [4, 11, 10, 0, 7, 2, 1, 13, 3, 6, 8, 5, 9, 12, 15, 14],\n    [13, 11, 4, 1, 3, 15, 5, 9, 0, 10, 14, 7, 6, 8, 2, 12],\n    [1, 15, 13, 0, 5, 7, 10, 4, 9, 2, 3, 14, 6, 11, 8, 12];\n \nsub infix:<rol³²>(\\y, \\n) { (y +< n) % 2**32 +| (y +> (32 - n)) }\n \nsub ГОСТ-round(\\R, \\K) {\n    my \\a = (R + K) % 2**32;\n    my \\b = :16[ sbox[$_][(a +> (4 * $_)) % 16] for 7...0 ];\n    b rol³² 11;\n}\n \nsub feistel-step(&F, \\L, \\R, \\K) { R, L +^ F(R, K) }\n \nmy @input = 0x21, 0x04, 0x3B, 0x04, 0x30, 0x04, 0x32, 0x04;\nmy @key   = 0xF9, 0x04, 0xC1, 0xE2;\n \nmy ($L,$R) = @input.reverse.map: { :256[$^a,$^b,$^c,$^d] }\nmy ($K   ) = @key  .reverse.map: { :256[$^a,$^b,$^c,$^d] }\n \n($L,$R) = feistel-step(&ГОСТ-round, $L, $R, $K);\n\nsay [ ($L +< 32 + $R X+> (0, 8 ... 56)) X% 256 ].fmt('%02X');\n\n```\n\nOutput:\n\n```\n1F 88 CF 07 21 04 3B 04\n```"}]}
{"messages": [{"role": "user", "content": "Before writing to a file it is often advisable to make a backup of the original.\nCreating such a backup file is however also not without pitfalls.\n\nIn this task you should create a backup file from an existing file and then write new text to the old file.\nThe following issues should be handled:\n\n* avoid making a copy of the file but instead rename the original and then write a new file with the original filename.\n* if a copy needs to be made, please explain why rename is not possible.\n* keep in mind symlinks, and do not rename or copy the link but the target. (If there is a link `foo -> bar/baz`, then `bar/baz` should be renamed to `bar/baz.backup` and then the new text should be written to `bar/baz`.)\n* it is assumed that you have permission to write in the target location, thus permission errors need not be handled.\n* you may choose the backup filename per preference or given limitations. (It should somehow include the original filename however.)\n* please try to avoid executing external commands, and especially avoid calling a shell script.\n\nSome examples on this page assume that the original file already exists. They might fail if some user is trying to create a new file."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.10\n\n```\n# Back up the given path/filename with a default extension .bk(n)\n# where n is in the range 1 - $limit (default 3).\n# Prints 'File not found' to STDERR if the file does not exist.\n# Will not do anything if limit is set to less than 1.\n# Will not follow symlinks by default.\n\nsub backup (Str $filepath, Int :$limit = 3, Str :$ext = 'bk', Bool :$follow-symlinks = False) {\n    my $abs = $follow-symlinks ?? $filepath.IO.resolve.absolute !! $filepath.IO.absolute;\n    for (1 ..^ $limit).reverse -> $bnum {\n        if \"{$abs}.{$ext}{$bnum}\".IO.e {\n            \"{$abs}.{$ext}{$bnum}\".IO.rename: \"{$abs}.{$ext}{$bnum + 1}\";\n        }\n    }\n    if $abs.IO.e {\n        if $limit > 0 {\n            $abs.IO.rename: \"{$abs}.{$ext}1\";\n            my $in  = \"{$abs}.{$ext}1\".IO.open :r :bin or note $! and return False;\n            my $out = $abs.IO.open :w :bin or note $! and return False;\n            my $buffer-size = 32768; # 32Kb\n            while my $buf = $in.read($buffer-size) { $out.write($buf) };\n            close $in;\n            close $out;\n        }\n    } else {\n        note \"File not found: $abs\" and return False;\n    }\n    $abs # return filepath on success\n}\n\n# back up this program\nbackup $*PROGRAM-NAME;\n\n# Optionally, specify limit, back-up extension pattern and whether to follow symlinks.\n# Optional parameters can be in any order, in any combination.\nbackup 'myfile', :follow-symlinks, :limit(2), :ext('bak');\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a directory and any missing parents.\n\nThis task is named after the posix `mkdir -p` command, and several libraries which implement the same behavior.\n\nPlease implement a function of a single path string (for example `./path/to/dir`) which has the above side-effect.\nIf the directory already exists, return successfully.\nIdeally implementations will work equally well cross-platform (on windows, linux, and OS X).\n\nIt's likely that your language implements such a function as part of its standard library. If so, please also show how such a function would be implemented."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.06\n\nThere is a built-in function for this:\n\n```\nmkdir 'path/to/dir'\n\n```\n\nAlternatively, a custom solution (as per task description) that only uses the built-in mkdir non-recursively. The \"triangle reduce\" meta-operator `[\\ ]` is used get the intermediate results of a left fold with the comma operator on the list of path elements.\n\n```\nfor [\\,] $*SPEC.splitdir(\"../path/to/dir\") -> @path {\n    mkdir $_ unless .e given $*SPEC.catdir(@path).IO;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Man or boy test. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\n**Background**: The **man or boy test** was proposed by computer scientist Donald Knuth as a means of evaluating implementations of the ALGOL 60 programming language. The aim of the test was to distinguish compilers that correctly implemented \"recursion and non-local references\" from those that did not.\n\n> I have written the following simple routine, which may separate the 'man-compilers' from the 'boy-compilers'  \n>  — Donald Knuth\n\n**Task**: Imitate Knuth's example in Algol 60 in another language, as far as possible.\n\n**Details**: Local variables of routines are often kept in activation records (also *call frames*). In many languages, these records are kept on a call stack. In Algol (and e.g. in Smalltalk), they are allocated on a heap instead. Hence it is possible to pass references to routines that still can use and update variables from their call environment, even if the routine where those variables are declared already returned. This difference in implementations is sometimes called the Funarg Problem.\n\nIn Knuth's example, each call to *A* allocates an activation record for the variable *A*. When *B* is called from *A*, any access to *k* now refers to this activation record. Now *B* in turn calls *A*, but passes itself as an argument. This argument remains bound to the activation record. This call to *A* also \"shifts\" the variables *xi* by one place, so eventually the argument *B* (still bound to its particular\nactivation record) will appear as *x4* or *x5* in a call to *A*. If this happens when the expression *x4 + x5* is evaluated, then this will again call *B*, which in turn will update *k* in the activation record it was originally bound to. As this activation record is shared with other instances of calls to *A* and *B*, it will influence the whole computation.\n\nSo all the example does is to set up a convoluted calling structure, where updates to *k* can influence the behavior\nin completely different parts of the call tree.\n\nKnuth used this to test the correctness of the compiler, but one can of course also use it to test that other languages can emulate the Algol behavior correctly. If the handling of activation records is correct, the computed value will be −67.\n\n**Performance and Memory**: Man or Boy is intense and can be pushed to challenge any machine. Memory (both stack and heap) not CPU time is the constraining resource as the recursion creates a proliferation activation records which will quickly exhaust memory and present itself through a stack error. Each language may have ways of adjusting the amount of memory or increasing the recursion depth. Optionally, show how you would make such adjustments.\n\nThe table below shows the result, call depths, and total calls for a range of *k*:\n\n| *k* | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| *A* | 1 | 0 | -2 | 0 | 1 | 0 | 1 | -1 | -10 | -30 | -67 | -138 | -291 | -642 | -1,446 | -3,250 | -7,244 | -16,065 | -35,601 | -78,985 | -175,416 | -389,695 | -865,609 | -1,922,362 | -4,268,854 | -9,479,595 | -21,051,458 | -46,750,171 | -103,821,058 | -230,560,902 | -512,016,658 |\n| *A* called | 1 | 2 | 3 | 4 | 8 | 18 | 38 | 80 | 167 | 347 | 722 | 1,509 | 3,168 | 6,673 | 14,091 | 29,825 | 63,287 | 134,652 | 287,264 | 614,442 | 1,317,533 | 2,831,900 | 6,100,852 | 13,172,239 | 28,499,827 | 61,786,266 | 134,202,509 | 292,011,464 |  |  |  |\n| *A* depth | 1 | 2 | 3 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 512 | 1,024 | 2,048 | 4,096 | 8,192 | 16,384 | 32,768 | 65,536 | 131,072 | 262,144 | 524,288 | 1,048,576 | 2,097,152 | 4,194,304 | 8,388,608 |  |  |  |  |  |  |\n| *B* called | 0 | 1 | 2 | 3 | 7 | 17 | 37 | 79 | 166 | 346 | 721 | 1,508 | 3,167 | 6,672 | 14,090 | 29,824 | 63,286 | 134,651 | 287,263 | 614,441 | 1,317,532 | 2,831,899 | 6,100,851 | 13,172,238 | 28,499,826 |  |  |  |  |  |  |\n| *B* depth | 0 | 1 | 2 | 3 | 7 | 15 | 31 | 63 | 127 | 255 | 511 | 1,023 | 2,047 | 4,095 | 8,191 | 16,383 | 32,767 | 65,535 | 131,071 | 262,143 | 524,287 | 1,048,575 | 2,097,151 | 4,194,303 | 8,388,607 |  |  |  |  |  |  |\n\nRelated tasks\n\n* Jensen's Device"}, {"role": "assistant", "content": "(formerly Perl 6)\nThis solution avoids creating the closure B if $k <= 0 (that is, nearly every time).\n\n```\nsub A($k is copy, &x1, &x2, &x3, &x4, &x5) {\n    $k <= 0\n        ?? x4() + x5()\n        !! (my &B = { A(--$k, &B, &x1, &x2, &x3, &x4) })();\n};\n \nsay A(10, {1}, {-1}, {-1}, {1}, {0});\n\n```\n\nOutput:\n\n```\n-67\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Mandelbrot\\_set. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nGenerate and draw the Mandelbrot set.\n\nNote that there are many algorithms to draw Mandelbrot set and there are many functions which generate it ."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2023.08-3-g2f8234c22\n\nUsing the hyper statement prefix for concurrency, the code below produces a graymap to standard output.\n\nFile:Mandelbrot-raku.jpg\n\n```\nconstant MAX-ITERATIONS = 64;\nmy $width = +(@*ARGS[0] // 800);\nmy $height = $width + $width %% 2;\nsay \"P2\";\nsay \"$width $height\";\nsay MAX-ITERATIONS;\n\nsub cut(Range $r, UInt $n where $n > 1 --> Seq) {\n    $r.min, * + ($r.max - $r.min) / ($n - 1) ... $r.max\n}\n\nmy @re = cut(-2 .. 1/2, $width);\nmy @im = cut( 0 .. 5/4, 1 + ($height div 2)) X* 1i;\n \nsub mandelbrot(Complex $z is copy, Complex $c --> Int) {\n    for 1 .. MAX-ITERATIONS {\n        $z = $z*$z + $c;\n        return $_ if $z.abs > 2;\n    }\n    return 0;\n}\n \nmy @lines = hyper for @im X+ @re {\n  mandelbrot(0i, $_);\n}.rotor($width);\n\n.put for @lines[1..*].reverse;\n.put for @lines;\n```"}]}
{"messages": [{"role": "user", "content": "Given two ranges:\n\n:   :   :   * [\n\n              a\n\n              1\n              ,\n\n              a\n\n              2\n              ]\n              {\\displaystyle {\\displaystyle [a\\_{1},a\\_{2}]}}\n                 and\n            * [\n\n              b\n\n              1\n              ,\n\n              b\n\n              2\n              ]\n              {\\displaystyle {\\displaystyle [b\\_{1},b\\_{2}]}}\n              ;\n            * then a value   \n\n              s\n              {\\displaystyle {\\displaystyle s}}\n                 in range   \n\n              [\n\n              a\n\n              1\n              ,\n\n              a\n\n              2\n              ]\n              {\\displaystyle {\\displaystyle [a\\_{1},a\\_{2}]}}\n            * is linearly mapped to a value   \n\n              t\n              {\\displaystyle {\\displaystyle t}}\n                 in range   \n\n              [\n\n              b\n\n              1\n              ,\n\n              b\n\n              2\n              ]\n              {\\displaystyle {\\displaystyle [b\\_{1},b\\_{2}]}}\n\n  where:\n\n:   :   :   * t\n              =\n\n              b\n\n              1\n              +\n\n              (\n              s\n              −\n\n              a\n\n              1\n              )\n              (\n\n              b\n\n              2\n              −\n\n              b\n\n              1\n              )\n\n              (\n\n              a\n\n              2\n              −\n\n              a\n\n              1\n              )\n              {\\displaystyle {\\displaystyle t=b\\_{1}+{(s-a\\_{1})(b\\_{2}-b\\_{1}) \\over (a\\_{2}-a\\_{1})}}}\n\nTask\n\nWrite a function/subroutine/... that takes two ranges and a real number, and returns the mapping of the real number from the first to the second range.\n\nUse this function to map values from the range    `[0, 10]`    to the range    `[-1, 0].`\n\nExtra credit\n\nShow additional idiomatic ways of performing the mapping, using tools available to the language."}, {"role": "assistant", "content": "(formerly Perl 6)\nReturn a closure that does the mapping without have to supply the ranges every time.\n\n```\nsub getmapper(Range $a, Range  $b) {\n  my ($a1, $a2) = $a.bounds;\n  my ($b1, $b2) = $b.bounds;\n  return -> $s { $b1 + (($s-$a1) * ($b2-$b1) / ($a2-$a1)) }\n}\n\nmy &mapper = getmapper(0 .. 10, -1 .. 0);\nfor ^11 -> $x {say \"$x maps to &mapper($x)\"}\n\n```\n\nOutput:\n\n```\n0 maps to -1\n1 maps to -0.9\n2 maps to -0.8\n3 maps to -0.7\n4 maps to -0.6\n5 maps to -0.5\n6 maps to -0.4\n7 maps to -0.3\n8 maps to -0.2\n9 maps to -0.1\n10 maps to 0\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGenerate contours for a two-dimensional scalar field.\n\nSee: Marching squares"}, {"role": "assistant", "content": "**Translation of**: Phix\n\n```\n# 20220708 Raku programming solution\n\nenum <E N W S>;\nmy (@dx,@dy) := (1,0,-1,0), (0,-1,0,1);\nmy \\example   = ((0, 0, 0, 0, 0),\n                 (0, 0, 0, 0, 0),\n                 (0, 0, 1, 1, 0),\n                 (0, 0, 1, 1, 0),\n                 (0, 0, 0, 1, 0),\n                 (0, 0, 0, 0, 0));\n\nprintf(\"X: %d, Y: %d, Path: %s\\n\", identifyPerimeter(example));\n\nsub identifyPerimeter(\\data) {\n\n   my (\\height,\\width) = { .elems, .first.elems }(data);\n\n   for ^width X ^height -> (\\x,\\y) {\n      if data[y;x] {\n         my ($cx,$cy,$directions,$previous) = x, y;\n         repeat { \n            my $mask;\n            for (0,0,1),(1,0,2),(0,1,4),(1,1,8) -> (\\dx,\\dy,\\b) { \n\t       my ($mx,$my) = $cx+dx,$cy+dy; \n\t       $mask += b if all $mx>1, $my>1, data[$my-1;$mx-1] \n            } \n            given do given $mask {\n               when * ∈ ( 1,  5, 13 ) { N }\n               when * ∈ ( 2,  3,  7 ) { E }\n               when * ∈ ( 4, 12, 14 ) { W }\n               when * ∈ ( 8, 10, 11 ) { S }\n               when * ∈ (     6     ) { $previous == N ?? W !! E }\n               when * ∈ (     9     ) { $previous == E ?? N !! S }\n            } { \n\t       $directions ~= $previous = $_ ; \n\t       ($cx,$cy) <<+=<< (@dx[.value], @dy[.value]) \n\t    } \n         } until $cx==x and $cy==y ; \n         return x, -y, $directions\n      }      \n   }\n   return -1, -1, \"Not found!\"\n}\n\n```\n\nOutput is the same as the Phix entry."}]}
{"messages": [{"role": "user", "content": "This task is about coding a Text Generator using Markov Chain algorithm.\n\nA Markov chain algorithm basically determines the next most probable suffix word for a given prefix.\n\nTo do this, a Markov chain program typically breaks an input text (training text) into a series of words,\nthen by sliding along them in some fixed sized window, storing the first N words as a prefix and then\nthe N + 1 word as a member of a list to choose from randomly for the suffix.\n\nAs an example, take this text with N = 2:\n\n```\nnow he is gone she said he is gone for good\n\n```\n\nthis would build the following table:\n\n```\nPREFIX               SUFFIX\nnow he               is\nhe is                gone, gone\nis gone              she, for\ngone she             said\nshe said             he\nsaid he              is\ngone for             good\nfor good             (empty) if we get at this point, the program stops generating text\n\n```\n\nTo generate the final text choose a random PREFIX, if it has more than one SUFFIX, get one at random,\ncreate the new PREFIX and repeat until you have completed the text.\n\nFollowing our simple example, N = 2, 8 words:\n\n```\nrandom prefix: gone she\nsuffix: said\nnew prefix: she + said\nnew suffix: he\nnew prefix: said + he\nnew suffix: is\n... and so on\n\ngone she said he is gone she said\n\n```\n\nThe bigger the training text, the better the results.\nYou can try this text here: alice\\_oz.txt\n\nCreate a program that is able to handle keys of any size (I guess keys smaller than 2 words would be\npretty random text but...) and create output text also in any length.\nProbably you want to call your program passing those numbers as parameters. Something like: markov( \"text.txt\", 3, 300 )"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2017-01\n\n```\nunit sub MAIN ( :$text=$*IN, :$n=2, :$words=100, );\n\nsub add-to-dict ( $text, :$n=2, ) {\n    my @words = $text.words;\n    my @prefix = @words.rotor: $n => -$n+1;\n\n    (%).push: @prefix Z=> @words[$n .. *]\n}\n\nmy %dict = add-to-dict $text, :$n;\nmy @start-words = %dict.keys.pick.words;\nmy @generated-text = lazy |@start-words, { %dict{ \"@_[ *-$n .. * ]\" }.pick } ...^ !*.defined;\n\nput @generated-text.head: $words;\n\n```\n\n```\n>raku markov.raku <alice_oz.txt --n=3 --words=200\nScarecrow. He can't hurt the straw. Do let me carry that basket for you. I shall not mind it, for I can't get tired. I'll tell you what I think, said the little man. Give me two or three pairs of tiny white kid gloves: she took up the fan and gloves, and, as the Lory positively refused to tell its age, there was no use in saying anything more till the Pigeon had finished. 'As if it wasn't trouble enough hatching the eggs,' said the Pigeon; 'but I must be very careful. When Oz gives me a heart of course I needn't mind so much. They were obliged to camp out that night under a large tree in the wood,' continued the Pigeon, raising its voice to a whisper. He is more powerful than they themselves, they would surely have destroyed me. As it was, I lived in deadly fear of them for many years; so you can see for yourself. Indeed, a jolly little clown came walking toward them, and Dorothy could see that in spite of all her coaxing. Hardly knowing what she did, she picked up a little bit of stick, and held it out to\n\n```"}]}
{"messages": [{"role": "user", "content": "Create a simple version of the board game:   Mastermind.\n\nIt must be possible to:\n\n:   * choose the number of colors will be used in the game (2 - 20)\n    * choose the color code length (4 - 10)\n    * choose the maximum number of guesses the player has (7 - 20)\n    * choose whether or not colors may be repeated in the code\n\nThe (computer program) game should display all the player guesses and the results of that guess.\n\nDisplay (just an idea):\n\n:   :   :   :   :   :   | Feature | Graphic Version | Text Version |\n                        | --- | --- | --- |\n                        | Player guess | Colored circles | Alphabet letters |\n                        | Correct color & position | Black circle | X |\n                        | Correct color | White circle | O |\n                        | None | Gray circle | - |\n\nA text version example:        1.   ADEF   -   XXO- \n  \nTranslates to:\n  \nthe first guess;\n  \nthe four colors (ADEF);\n  \nresult:\n\n:   :   :   :   two correct colors and spot,\n            :   one correct color/wrong spot, one color isn't in the code.\n\nHappy coding!\n\nRelated tasks\n\n* Bulls and cows\n* Bulls and cows/Player\n* Guess the number\n* Guess the number/With Feedback"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.01\n\nBy default, plays classic Mastermind using letters in place of colors. ( 4 chosen from 6, no repeats, 10 guess limit. ) Pass in parameters to modify the game. Enter a string of --length (default 4) letters with or without spaces. Guesses accept lower or upper case.\n\n```\nsub MAIN (\n    Int :$colors  where 1 < * < 21 = 6,  Int :$length  where 3 < * < 11 = 4,\n    Int :$guesses where 7 < * < 21 = 10, Bool :$repeat = False\n  ) {\n    my @valid = ('A' .. 'T')[^$colors];\n    my $puzzle = $repeat ?? @valid.roll($length) !! @valid.pick($length);\n    my @guesses;\n\n    my $black = '●';\n    my $white = '○';\n\n    loop {\n        clearscr();\n        say header();\n        printf \" %{$length * 2}s :: %s\\n\", @guesses[$_][0], @guesses[$_][1] for ^@guesses;\n        say '';\n        lose() if @guesses == $guesses;\n        my $guess = get-guess();\n        next unless $guess.&is-valid;\n        my $score = score($puzzle, $guess);\n        win() if $score eq ($black xx $length).join: ' ';\n        @guesses.push: [$guess, $score];\n    }\n\n    sub header {\n        my $num = $guesses - @guesses;\n        qq:to/END/;\n        Valid letter, but wrong position: ○ - Correct letter and position: ●\n        Guess the {$length} element sequence containing the letters {@valid}\n        Repeats are {$repeat ?? '' !! 'not '}allowed. You have $num guess{ $num == 1 ?? '' !! 'es'} remaining.\n        END\n    }\n\n    sub score ($puzzle, $guess) {\n        my @score;\n        for ^$length {\n            if $puzzle[$_] eq $guess[$_] {\n                @score.push: $black;\n            }\n            elsif $puzzle[$_] eq any(@$guess) {\n                @score.push: $white;\n            }\n            else {\n                @score.push('-');\n            }\n        }\n        @score.sort.reverse.join: ' ';\n    }\n\n    sub clearscr { $*KERNEL ~~ /'win32'/ ?? run('cls') !! run('clear') }\n\n    sub get-guess { (uc prompt 'Your guess?: ').comb(/@valid/) }\n\n    sub is-valid (@guess) { so $length == @guess }\n\n    sub win  { say 'You Win! The correct answer is: ', $puzzle; exit }\n\n    sub lose { say 'Too bad, you ran out of guesses. The solution was: ', $puzzle; exit }\n}\n\n```\n\nSample output:\n\n```\nValid letter, but wrong position: ○ - Correct letter and position: ●\nGuess the 4 element sequence containing the letters A B C D E F\nRepeats are not allowed. You have 5 guesses remaining.\n\n  A B C D :: ○ ○ ○ -\n  C A B E :: ● ○ ○ -\n  D A E F :: ● ○ - -\n  B A E C :: ● ○ ○ -\n  D E B C :: ○ ○ ○ ○\n\nYour guess?: cdeb\nYou Win! The correct answer is: (C D E B)\n```"}]}
{"messages": [{"role": "user", "content": "Problem\n\nUsing the most straightforward algorithm (which we assume here), computing the product of two matrices of dimensions (n1,n2) and (n2,n3) requires n1\\*n2\\*n3 FMA operations. The number of operations required to compute the product of matrices A1, A2... An depends on the order of matrix multiplications, hence on where parens are put. Remember that the matrix product is associative, but not commutative, hence only the parens can be moved.\n\nFor instance, with four matrices, one can compute A(B(CD)), A((BC)D), (AB)(CD), (A(BC))D, (AB)C)D. The number of different ways to put the parens is a Catalan number, and grows exponentially with the number of factors.\n\nHere is an example of computation of the total cost, for matrices A(5,6), B(6,3), C(3,1):\n\n* AB costs 5\\*6\\*3=90 and produces a matrix of dimensions (5,3), then (AB)C costs 5\\*3\\*1=15. The total cost is 105.\n* BC costs 6\\*3\\*1=18 and produces a matrix of dimensions (6,1), then A(BC) costs 5\\*6\\*1=30. The total cost is 48.\n\nIn this case, computing (AB)C requires more than twice as many operations as A(BC). The difference can be much more dramatic in real cases.\n\nTask\n\nWrite a function which, given a list of the successive dimensions of matrices A1, A2... An, of arbitrary length, returns the optimal way to compute the matrix product, and the total cost. Any sensible way to describe the optimal solution is accepted. The input list does not duplicate shared dimensions: for the previous example of matrices A,B,C, one will only pass the list [5,6,3,1] (and *not* [5,6,6,3,3,1]) to mean the matrix dimensions are respectively (5,6), (6,3) and (3,1). Hence, a product of n matrices is represented by a list of n+1 dimensions.\n\nTry this function on the following two lists:\n\n* [1, 5, 25, 30, 100, 70, 2, 1, 100, 250, 1, 1000, 2]\n* [1000, 1, 500, 12, 1, 700, 2500, 3, 2, 5, 14, 10]\n\nTo solve the task, it's possible, but not required, to write a function that enumerates all possible ways to parenthesize the product. This is not optimal because of the many duplicated computations, and this task is a classic application of dynamic programming.\n\nSee also Matrix chain multiplication on Wikipedia."}, {"role": "assistant", "content": "(formerly Perl 6)\nThis example is based on Moritz Lenz's code, written for Carl Mäsak's Perl 6 Coding Contest, in 2010. Slightly simplified, it fulfills the Rosetta Code task as well.\n\n```\nsub matrix-mult-chaining(@dimensions) {\n    my @cp;\n    # @cp has a dual function: \n    # * the upper triangle of the diagonal matrix stores the cost (c) for\n    #   multiplying matrices $i and $j in @cp[$j][$i], where $j > $i\n    # * the lower triangle stores the path (p) that was used for the lowest cost\n    #   multiplication to get from $i to $j.\n\n    # a matrix never needs to be multiplied with itself, so it has cost 0\n    @cp[$_][$_] = 0 for @dimensions.keys;\n    my @path;\n\n    my $n = @dimensions.end;\n    for 1 .. $n -> $chain-length {\n        for 0 .. $n - $chain-length - 1 -> $start {\n            my $end = $start + $chain-length;\n            @cp[$end][$start] = Inf;  # until we find a better connection\n            for $start .. $end - 1 -> $step {\n                my $new-cost = @cp[$step][$start]\n                             + @cp[$end][$step + 1]\n                             + [*] @dimensions[$start, $step+1, $end+1];\n                if $new-cost < @cp[$end][$start] {\n                    @cp[$end][$start] = $new-cost; # cost\n                    @cp[$start][$end] = $step;     # path\n                }\n            }\n       }\n    }\n\n    sub find-path(Int $start, Int $end) {\n        if $start == $end {\n            take 'A' ~ ($start + 1);\n        } else {\n            take '(';\n            find-path($start, @cp[$start][$end]);\n            find-path(@cp[$start][$end] + 1, $end);\n            take ')';\n        }\n    }\n \n   return @cp[$n-1][0], gather { find-path(0, $n - 1) }.join;\n}\n\nsay matrix-mult-chaining(<1 5 25 30 100 70 2 1 100 250 1 1000 2>);\nsay matrix-mult-chaining(<1000 1 500 12 1 700 2500 3 2 5 14 10>);\n\n```\n\nOutput:\n\n```\n(38120 ((((((((A1A2)A3)A4)A5)A6)A7)(A8(A9A10)))(A11A12)))\n(1773740 (A1((((((A2A3)A4)(((A5A6)A7)A8))A9)A10)A11)))\n```"}]}
{"messages": [{"role": "user", "content": "Implement the Matrix Digital Rain visual effect from the movie \"The Matrix\" as described in Wikipedia.\n\nProvided is a reference implementation in Common Lisp to be run in a terminal."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.11\n\nKind-of cheap and cheesy, but what the heck... Probably will only work in a POSIX compatible terminal. Runs until you hit ^C to exit.\n\nThe \"lightning\" effect is actually a bug, but I liked it so I kept it.\n\n```\n# clean up on exit, reset ANSI codes, scroll, re-show the cursor & clear screen\nsignal(SIGINT).tap: { print \"\\e[0m\", \"\\n\" xx 50, \"\\e[H\\e[J\\e[?25h\"; exit(0) }\n\n# a list of glyphs to use\nmy @codes = flat 'Α' .. 'Π', 'Ѐ' .. 'ѵ', 'Ҋ' .. 'ԯ', 'Ϣ' .. 'ϯ', 'ｦ'.. 'ﾝ',\n                 'Ⲁ' .. '⳩', '∀' .. '∗', '℀' .. '℺', '⨀' .. '⫿';\n\n# palette of gradient ANSI foreground colors\nmy @palette = flat  \"\\e[38;2;255;255;255m\", (255,245 … 30).map({\"\\e[38;2;0;$_;0m\"}),\n              \"\\e[38;2;0;25;0m\" xx 75;\n\nmy @screen; # buffer to hold glyphs\nmy @rotate; # palette rotation position buffer\n\nmy ($rows, $cols) = qx/stty size/.words; # get the terminal size\ninit($rows, $cols); # set up the screen buffer and palette offsets\n\nmy $size-check;\n\nprint \"\\e[?25l\\e[48;5;232m\"; # hide the cursor, set the background color\n\nloop {\n     if ++$size-check %% 20 {                         # periodically check for\n         my ($r, $c) = qx/stty size/.words;           # resized terminal and\n         init($r, $c) if $r != $rows or $c != $cols;  # re-initialize screen buffer\n         $size-check = 0\n     }\n     print \"\\e[1;1H\";                                 # set cursor to top left\n     print join '', (^@screen).map: {\n         @rotate[$_] = (@rotate[$_] + 1) % +@palette; # rotate the palettes\n         flat @palette[@rotate[$_]], @screen[$_]      # and print foreground, glyph\n     }\n     @screen[(^@screen).pick] = @codes.roll for ^30;  # replace some random glyphs\n}\n\nsub init ($r, $c) {\n    @screen = @codes.roll($r * $c);\n    ($rows, $cols) = $r, $c;\n    my @offset = (^@palette).pick xx $cols;\n    for ^$rows -> $row {\n        @rotate[$row * $cols ..^ $row * $cols + $cols] = @offset;\n        # for no \"lightning\" effect, add   '1 + '  ↓ here: (1 + $_ % 3)\n        @offset = (^@offset).map: {(@offset[$_] - ($_ % 3)) % +@palette};\n    }\n}\n\n```\n\nSample output:\n\nSee matrix-digital-rain-perl6.png (offsite png image)"}]}
{"messages": [{"role": "user", "content": "Task\n\nMultiply two matrices together.\n\nThey can be of any dimensions, so long as the number of columns of the first matrix is equal to the number of rows of the second matrix."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl 5\n\n**Works with**: Rakudo version 2015-09-22\n\nThere are three ways in which this example differs significantly from the original Perl 5 code. These are not esoteric differences; all three of these features typically find heavy use in Raku.\n\nFirst, we can use a real signature that can bind two arrays as arguments, because the default in Raku is not to flatten arguments unless the signature specifically requests it.\nWe don't need to pass the arrays with backslashes because the binding choice is made lazily\nby the signature itself at run time; in Perl 5 this choice must be made at compile time.\nAlso, we can bind the arrays to formal parameters that are really lexical variable names; in Perl 5 they can only be bound to global array objects (via a typeglob assignment).\n\nSecond, we use the X cross operator in conjunction with a two-parameter closure to avoid writing\nnested loops. The X cross operator, along with Z, the zip operator, is a member of a class of operators that expect lists on both sides, so we call them \"list infix\" operators. We tend to define these operators using capital letters so that they stand out visually from the lists on both sides. The cross operator makes every possible combination of the one value from the first list followed by one value from the second. The right side varies most rapidly, just like an inner loop. (The X and Z operators may both also be used as meta-operators, Xop or Zop, distributing some other operator \"op\" over their generated list. All metaoperators in Raku may be applied to user-defined operators as well.)\n\nThird is the use of prefix ^ to generate a list of numbers in a range. Here it is\nused on an array to generate all the indexes of the array. We have a way of indicating a range by the infix .. operator, and you can put a ^ on either end to exclude that endpoint. We found ourselves writing 0 ..^ @a so often that we made ^@a a shorthand for that. It's pronounced \"upto\". The array is evaluated in a numeric context, so it returns the number of elements it contains, which is exactly what you want for the exclusive limit of the range.\n\n```\nsub mmult(@a,@b) {\n    my @p;\n    for ^@a X ^@b[0] -> ($r, $c) {\n        @p[$r][$c] += @a[$r][$_] * @b[$_][$c] for ^@b;\n    }\n    @p;\n}\n\nmy @a = [1,  1,  1,   1],\n        [2,  4,  8,  16],\n        [3,  9, 27,  81],\n        [4, 16, 64, 256];\n\nmy @b = [  4  , -3  ,  4/3,  -1/4 ],\n        [-13/3, 19/4, -7/3,  11/24],\n        [  3/2, -2  ,  7/6,  -1/4 ],\n        [ -1/6,  1/4, -1/6,   1/24];\n\n.say for mmult(@a,@b);\n```\n\nOutput:\n\n```\n[1 0 0 0]\n[0 1 0 0]\n[0 0 1 0]\n[0 0 0 1]\n```\n\nNote that these are not rounded values, but exact, since all the math was done in rationals.\nHence we need not rely on format tricks to hide floating-point inaccuracies.\n\nJust for the fun of it, here's a functional version that uses no temp variables or side effects.\nSome people will find this more readable and elegant, and others will, well, not.\n\n```\nsub mmult(\\a,\\b) {\n    [\n        for ^a -> \\r {\n            [\n                for ^b[0] -> \\c {\n                    [+] a[r;^b] Z* b[^b;c]\n                }\n            ]\n        }\n    ]\n}\n```\n\nHere we use Z with an \"op\" of \\*, which is a zip with multiply. This, along with the [+] reduction operator, replaces the inner loop. We chose to split the outer X loop back into two loops to make it convenient to collect each subarray value in [...]. It just collects all the returned values from the inner loop and makes an array of them. The outer loop simply returns the outer array.\n\nFor conciseness, the above could be written as:\n\n```\nmulti infix:<×> (@A, @B) {\n\t@A.map: -> @a { do [+] @a Z× @B[*;$_] for ^@B[0] }\n}\n```\n\nWhich overloads the built-in `×` operator for `Positional` operands. You’ll notice we are using `×` inside of the definition; since the arguments there are `Scalar`, it multiplies two numbers. Also, `do` is an alternative to parenthesising the loop for getting its result.\n\n**Works with**: Rakudo version 2022.07-3\n\nHere is a more functional version, expressing the product of two matrices as the cross dot product of the first matrix with the transpose of the second :\n\n```\nsub infix:<·> { [+] @^a Z* @^b }\nsub infix:<×>(@A, @B) { (@A X· [Z] @B).rotor(@B) }\n```"}]}
{"messages": [{"role": "user", "content": "Transpose an arbitrarily sized rectangular Matrix."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n```\n# Transposition can be done with the reduced zip meta-operator\n# on list-of-lists data structures\n\nsay [Z] (<A B C D>, <E F G H>, <I J K L>);\n\n# For native shaped arrays, a more traditional procedure of copying item-by-item\n# Here the resulting matrix is also a native shaped array\n\nmy @a[3;4] =\n  [\n    [<A B C D>],\n    [<E F G H>],\n    [<I J K L>],\n  ];\n\n(my $n, my $m) = @a.shape;\nmy @b[$m;$n];\nfor ^$m X ^$n -> (\\i, \\j) {\n   @b[i;j] = @a[j;i];\n}\n\nsay @b;\n```\n\nOutput:\n\n```\n((A E I) (B F J) (C G K) (D H L))\n[[A E I] [B F J] [C G K] [D H L]]\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDraw a square matrix which has 1's on both diagonals but 0's elsewhere.\n  \n If you can please use GUI\n\n### See also\n\n* Four sides of square\n* Mosaic matrix"}, {"role": "assistant", "content": "```\nsub dual-diagonal($n) { ([1, |(0 xx $n-1)], *.rotate(-1) … *[*-1]).map: { [$_ Z|| .reverse] } }\n\n.say for dual-diagonal(6);\nsay '';\n.say for dual-diagonal(7);\n\n```\n\nOutput:\n\n```\n[1 0 0 0 0 1]\n[0 1 0 0 1 0]\n[0 0 1 1 0 0]\n[0 0 1 1 0 0]\n[0 1 0 0 1 0]\n[1 0 0 0 0 1]\n\n[1 0 0 0 0 0 1]\n[0 1 0 0 0 1 0]\n[0 0 1 0 1 0 0]\n[0 0 0 1 0 0 0]\n[0 0 1 0 1 0 0]\n[0 1 0 0 0 1 0]\n[1 0 0 0 0 0 1]\n```"}]}
{"messages": [{"role": "user", "content": "Most programming languages have a built-in implementation of exponentiation for integers and reals only.\n\nTask\n\nDemonstrate how to implement matrix exponentiation as an operator."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsubset SqMat of Array where { .elems == all(.[]».elems) }\n\nmulti infix:<*>(SqMat $a, SqMat $b) {[\n    for ^$a -> $r {[\n        for ^$b[0] -> $c {\n            [+] ($a[$r][] Z* $b[].map: *[$c])\n        }\n    ]}\n]}\n\nmulti infix:<**> (SqMat $m, Int $n is copy where { $_ >= 0 }) {\n    my $tmp = $m;\n    my $out = [for ^$m -> $i { [ for ^$m -> $j { +($i == $j) } ] } ];\n    loop {\n        $out = $out * $tmp if $n +& 1;\n        last unless $n +>= 1;\n        $tmp = $tmp * $tmp;\n    }\n\n    $out;\n}\n\nmulti show (SqMat $m) {\n    my $size = $m.map( *.list».chars ).flat.max;\n    say .fmt(\"%{$size}s\", ' ') for $m.list;\n}\n\nmy @m = [1, 2, 0],\n        [0, 3, 1],\n        [1, 0, 0];\n\nfor 0 .. 10 -> $order {\n    say \"### Order $order\";\n    show @m ** $order;\n}\n\n```\n\nOutput:\n\n```\n### Order 0\n1 0 0\n0 1 0\n0 0 1\n### Order 1\n1 2 0\n0 3 1\n1 0 0\n### Order 2\n1 8 2\n1 9 3\n1 2 0\n### Order 3\n 3 26  8\n 4 29  9\n 1  8  2\n### Order 4\n11 84 26\n13 95 29\n 3 26  8\n### Order 5\n 37 274  84\n 42 311  95\n 11  84  26\n### Order 6\n 121  896  274\n 137 1017  311\n  37  274   84\n### Order 7\n 395 2930  896\n 448 3325 1017\n 121  896  274\n### Order 8\n 1291  9580  2930\n 1465 10871  3325\n  395  2930   896\n### Order 9\n 4221 31322  9580\n 4790 35543 10871\n 1291  9580  2930\n### Order 10\n 13801 102408  31322\n 15661 116209  35543\n  4221  31322   9580\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind maximum difference between adjacent elements of list.\n\nThe list may have negative values, zero values, real numbers.\n\nList   =    [1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3]\n\nOutput would be   (which could have more verbiage):\n\n```\n  1,8 ==> 7\n  2,9 ==> 7\n  10,3 ==> 7\n\n```"}, {"role": "assistant", "content": "```\nsub max-diff (*@list) {\n   return 0 if +@list < 2;\n   my $max = @list.rotor(2 => -1).max({ (.[0] - .[1]).abs }).map( (* - *).abs )[0];\n   \"$max @ elements { @list.rotor(2 => -1).grep( { (.[0] - .[1]).abs == $max } ).gist }\"\n}\n\n\nsub min-diff (*@list) {\n   return 0 if +@list < 2;\n   my $min = @list.rotor(2 => -1).min({ (.[0] - .[1]).abs }).map( (* - *).abs )[0];\n   \"$min @ elements { @list.rotor(2 => -1).grep( { (.[0] - .[1]).abs == $min } ).gist }\"\n}\n\n\nsub avg-diff (*@list) { (+@list > 1) ?? (@list.sum / +@list) !! 0 }\n\n\n# TESTING\n\nfor (\n      [ 1,8,2,-3,0,1,1,-2.3,0,5.5,8,6,2,9,11,10,3 ]\n     ,[(rand × 1e6) xx 6]\n     ,[ e, i, τ, π, ∞ ]\n     ,[ 1.9+3.7i, 2.07-13.2i, 0.2+-2.2i, 4.6+0i ]\n     ,[ 6 ]\n     ,[]\n     ,[<One Two Three>]\n    )\n-> @list {\n    say 'List: ', ~ @list.raku;\n    for ('  Maximum', &max-diff ,'  Minimum', &min-diff, '  Average', &avg-diff)\n    -> $which, &sub {\n        say \"$which distance between list elements: \" ~ &sub(@list);\n    }\n    say '';\n}\n\n```\n\nOutput:\n\n```\nList: [1, 8, 2, -3, 0, 1, 1, -2.3, 0, 5.5, 8, 6, 2, 9, 11, 10, 3]\n  Maximum distance between list elements: 7 @ elements ((1 8) (2 9) (10 3))\n  Minimum distance between list elements: 0 @ elements ((1 1))\n  Average distance between list elements: 3.658824\n\nList: [480470.3324944039e0, 719954.3173377671e0, 648221.5674277907e0, 340053.78585537826e0, 540629.6741075241e0, 4336.700602958543e0]\n  Maximum distance between list elements: 536292.9735045655 @ elements ((540629.6741075241 4336.700602958543))\n  Minimum distance between list elements: 71732.74990997638 @ elements ((719954.3173377671 648221.5674277907))\n  Average distance between list elements: 455611.06297097047\n\nList: [2.718281828459045e0, <0+1i>, 6.283185307179586e0, 3.141592653589793e0, Inf]\n  Maximum distance between list elements: Inf @ elements ((3.141592653589793 Inf))\n  Minimum distance between list elements: 2.896386731590008 @ elements ((2.718281828459045 0+1i))\n  Average distance between list elements: Inf+0.2i\n\nList: [<1.9+3.7i>, <2.07-13.2i>, <0.2-2.2i>, <4.6+0i>]\n  Maximum distance between list elements: 16.900855007957436 @ elements ((1.9+3.7i 2.07-13.2i))\n  Minimum distance between list elements: 4.919349550499537 @ elements ((0.2-2.2i 4.6+0i))\n  Average distance between list elements: 2.1925-2.925i\n\nList: [6]\n  Maximum distance between list elements: 0\n  Minimum distance between list elements: 0\n  Average distance between list elements: 0\n\nList: []\n  Maximum distance between list elements: 0\n  Minimum distance between list elements: 0\n  Average distance between list elements: 0\n\nList: [\"One\", \"Two\", \"Three\"]\nCannot convert string to number: base-10 number must begin with valid digits or '.' in '⏏Two' (indicated by ⏏)\n  in sub max-diff at listdiff.p6 line 3\n  in block  at listdiff.p6 line 33\n  in block <unit> at listdiff.p6 line 20\n\n```"}]}
{"messages": [{"role": "user", "content": "Starting from the top of a pyramid of numbers like this, you can walk down going one step on the right or on the left, until you reach the bottom row:\n\n```\n                          55\n                        94 48\n                       95 30 96\n                     77 71 26 67\n\n```\n\nOne of such walks is 55 - 94 - 30 - 26.\nYou can compute the total of the numbers you have seen in such walk,\nin this case it's 205.\n\nYour problem is to find the maximum total among all possible paths from the top to the bottom row of the triangle. In the little example above it's 321.\n\nTask\n\nFind the maximum total in the triangle below:\n\n```\n                          55\n                        94 48\n                       95 30 96\n                     77 71 26 67\n                    97 13 76 38 45\n                  07 36 79 16 37 68\n                 48 07 09 18 70 26 06\n               18 72 79 46 59 79 29 90\n              20 76 87 11 32 07 07 49 18\n            27 83 58 35 71 11 25 57 29 85\n           14 64 36 96 27 11 58 56 92 18 55\n         02 90 03 60 48 49 41 46 33 36 47 23\n        92 50 48 02 36 59 42 79 72 20 82 77 42\n      56 78 38 80 39 75 02 71 66 66 01 03 55 72\n     44 25 67 84 71 67 11 61 40 57 58 89 40 56 36\n   85 32 25 85 57 48 84 35 47 62 17 01 01 99 89 52\n  06 71 28 75 94 48 37 10 23 51 06 48 53 18 74 98 15\n27 02 92 23 08 71 76 84 15 52 92 63 81 10 44 10 69 93\n\n```\n\nSuch numbers can be included in the solution code, or read from a \"triangle.txt\" file.\n\nThis task is derived from the Euler Problem #18."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nThe Z+ and Zmax are examples of the zipwith metaoperator. Note also we can use the Zmax metaoperator form because max is define as an infix in Perl 6.\n\n```\nmy $triangle = q|         55\n                        94 48\n                       95 30 96\n                     77 71 26 67\n                    97 13 76 38 45\n                  07 36 79 16 37 68\n                 48 07 09 18 70 26 06\n               18 72 79 46 59 79 29 90\n              20 76 87 11 32 07 07 49 18\n            27 83 58 35 71 11 25 57 29 85\n           14 64 36 96 27 11 58 56 92 18 55\n         02 90 03 60 48 49 41 46 33 36 47 23\n        92 50 48 02 36 59 42 79 72 20 82 77 42\n      56 78 38 80 39 75 02 71 66 66 01 03 55 72\n     44 25 67 84 71 67 11 61 40 57 58 89 40 56 36\n   85 32 25 85 57 48 84 35 47 62 17 01 01 99 89 52\n  06 71 28 75 94 48 37 10 23 51 06 48 53 18 74 98 15\n27 02 92 23 08 71 76 84 15 52 92 63 81 10 44 10 69 93|;\n\n\nmy @rows = $triangle.lines.map: { [.words] }\nwhile @rows > 1 {\n    my @last := @rows.pop;\n    @rows[*-1] = (@rows[*-1][] Z+ (@last Zmax @last[1..*])).List;\n}\nput @rows;\n\n\n# Here's a more FPish version. We define our own operator and the use it in the reduction metaoperator form, [op], which turns any infix into a list operator. \nsub infix:<op>(@a,@b) { (@a Zmax @a[1..*]) Z+ @b }\nput [op] $triangle.lines.reverse.map: { [.words] }\n\n\n# Or, instead of using reverse, one could also define the op as right-associative.\nsub infix:<rop>(@a,@b) is assoc('right') { @a Z+ (@b Zmax @b[1..*]) }\nput [rop] $triangle.lines.map: { [.words] }\n\n```\n\nOutput:\n\n```\n1320\n1320\n1320\n```"}]}
{"messages": [{"role": "user", "content": "The ancient Maya people had two somewhat distinct calendar systems.\n\nIn somewhat simplified terms, one is a cyclical calendar known as **The Calendar Round**,\nthat meshes several sacred and civil cycles; the other is an offset calendar\nknown as **The Long Count**, similar in many ways to the Gregorian calendar.\n\n**The Calendar Round**\n\n**The Calendar Round** has several intermeshing sacred and civil cycles that uniquely identify a specific date in an approximately 52 year cycle.\n\n**The Tzolk’in**\n\nThe sacred cycle in the Mayan calendar round was called the **Tzolk’in**. The **Tzolk'in** has a cycle of 20 day names:\n\n```\n   Imix’\n   Ik’\n   Ak’bal\n   K’an\n   Chikchan\n   Kimi\n   Manik’\n   Lamat\n   Muluk\n   Ok\n   Chuwen\n   Eb\n   Ben\n   Hix\n   Men\n   K’ib’\n   Kaban\n   Etz’nab’\n   Kawak\n   Ajaw\n\n```\n\nIntermeshed with the named days, the **Tzolk’in** has a cycle of 13 numbered days; 1\nthrough 13. Every day has both a number and a name that repeat in a 260 day cycle.\n\nFor example:\n\n```\n   1 Imix’\n   2 Ik’\n   3 Ak’bal\n   ...\n   11 Chuwen\n   12 Eb\n   13 Ben\n   1 Hix\n   2 Men\n   3 K’ib’\n   ... and so on.\n\n```\n\n**The Haab’**\n\nThe Mayan civil calendar is called the **Haab’**. This calendar has 365 days per\nyear, and is sometimes called the ‘vague year.’ It is substantially the same as\nour year, but does not make leap year adjustments, so over long periods of time,\ngets out of synchronization with the seasons. It consists of 18 months with 20 days each,\nand the end of the year, a special month of only 5 days, giving a total of 365.\nThe 5 days of the month of **Wayeb’** (the last month), are usually considered to be\na time of bad luck.\n\nEach month in the **Haab’** has a name. The Mayan names for the civil months are:\n\n```\n   Pop\n   Wo’\n   Sip\n   Sotz’\n   Sek\n   Xul\n   Yaxk’in\n   Mol\n   Ch’en\n   Yax\n   Sak’\n   Keh\n   Mak\n   K’ank’in\n   Muwan\n   Pax\n   K’ayab\n   Kumk’u\n   Wayeb’ (Short, \"unlucky\" month)\n\n```\n\nThe months function very much like ours do. That is, for any given month we\ncount through all the days of that month, and then move on to the next month.\n\nNormally, the day **1 Pop** is considered the first day of the civil year, just as **1 January**\nis the first day of our year. In 2019, **1 Pop** falls on **April 2nd**. But,\nbecause of the leap year in 2020, **1 Pop** falls on **April 1st** in the years 2020-2023.\n\nThe only really unusual aspect of the **Haab’** calendar is that, although there are\n20 (or 5) days in each month, the last day of the month is not called\nthe 20th (5th). Instead, the last day of the month is referred to as the\n‘seating,’ or ‘putting in place,’ of the next month. (Much like how in our\nculture, December 24th is Christmas Eve and December 31st is 'New-Years Eve'.) In\nthe language of the ancient Maya, the word for seating was **chum**, So you might\nhave:\n\n```\n   ...\n   18 Pop (18th day of the first month)\n   19 Pop (19th day of the first month)\n   Chum Wo’ (20th day of the first month)\n   1 Wo’ (1st day of the second month)\n   ... and so on.\n\n```\n\nDates for any particular day are a combination of the **Tzolk’in** sacred date,\nand **Haab’** civil date. When put together we get the **“Calendar Round.”**\n\n**Calendar Round** dates always have two numbers and two names, and they are\nalways written in the same order:\n\n```\n   (1) the day number in the Tzolk’in\n   (2) the day name in the  Tzolk’in\n   (3) the day of the month in the Haab’\n   (4) the month name in the Haab’\n\n```\n\nA calendar round is a repeating cycle with a period of just short of 52\nGregorian calendar years. To be precise: it is 52 x 365 days. (No leap days)\n\n**Lords of the Night**\n\nA third cycle of nine days honored the nine **Lords of the Night**; nine deities\nthat were associated with each day in turn. The names of the nine deities are\nlost; they are now commonly referred to as **G1** through **G9**. The Lord of the Night\nmay or may not be included in a Mayan date, if it is, it is typically\njust the appropriate **G(*x*)** at the end.\n\n**The Long Count**\n\nMayans had a separate independent way of measuring time that did not run in\ncycles. (At least, not on normal human scales.) Instead, much like our yearly\ncalendar, each day just gets a little further from the starting point. For the\nancient Maya, the starting point was the ‘creation date’ of the current world.\nThis date corresponds to our date of August 11, 3114 B.C. Dates are calculated\nby measuring how many days have transpired since this starting date; This is\ncalled **“The Long Count.”** Rather than just an absolute count of days, the long\ncount is broken up into unit blocks, much like our calendar has months, years,\ndecades and centuries.\n\n```\n   The basic unit is a k’in - one day.\n   A 20 day month is a winal.\n   18 winal (360 days) is a tun - sometimes referred to as a short year.\n   20 short years (tun) is a k’atun\n   20 k’atun is a bak’tun\n\n```\n\nThere are longer units too:\n\n```\n   Piktun == 20 Bak’tun (8,000 short years)\n   Kalabtun  == 20 Piktun (160,000 short years)\n   Kinchiltun  == 20 Kalabtun (3,200,000 short years)\n\n```\n\nFor the most part, the Maya only used the blocks of time up to the **bak’tun**. One\n**bak’tun** is around 394 years, much more than a human life span, so that was all\nthey usually needed to describe dates in this era, or this world. It is worth\nnoting, the two calendars working together allow much more accurate and reliable\nnotation for dates than is available in many other calendar systems; mostly due\nto the pragmatic choice to make the calendar simply track days, rather than\ntrying to make it align with seasons and/or try to conflate it with the notion\nof time.\n\n**Mayan Date correlations**\n\nThere is some controversy over finding a correlation point between the Gregorian\nand Mayan calendars. The Gregorian calendar is full of jumps and skips to keep\nthe calendar aligned with the seasons so is much more difficult to work with.\nThe most commonly used correlation\nfactor is The **GMT: 584283**. Julian 584283 is a day count corresponding **Mon, Aug 11, 3114 BCE**\nin the Gregorian calendar, and the final day in the last Mayan long count\ncycle: 13.0.0.0.0 which is referred to as \"the day of creation\" in the Mayan\ncalendar. There is nothing in known Mayan writing or history that suggests that\na long count \"cycle\" resets *every* 13 **bak’tun**. Judging by their other practices,\nit would make much more sense for it to reset at 20, if at all.\n\nThe reason there was much interest at all, outside historical scholars, in\nthe Mayan calendar is that the long count recently (relatively speaking) rolled over to 13.0.0.0.0 (the same as the historic day of creation Long Count date) on Fri,\nDec 21, 2012 (using the most common GMT correlation factor), prompting conspiracy\ntheorists to predict a cataclysmic \"end-of-the-world\" scenario.\n\n**Excerpts taken from, and recommended reading:**\n\n* *From the website of the Foundation for the Advancement of Meso-America Studies, Inc.*   \n  Pitts, Mark. The complete Writing in Maya Glyphs Book 2 – Maya Numbers and the Maya Calendar. 2009. Accessed 2019-01-19.   \n  http://www.famsi.org/research/pitts/MayaGlyphsBook2.pdf\n\n* wikipedia: Maya calendar\n\n* wikipedia: Mesoamerican Long Count calendar\n\n**The Task:**\n\nWrite a reusable routine that takes a Gregorian date and returns the equivalent date in Mayan in the Calendar Round and the Long Count. At a minimum, use the GMT correlation. *If desired, support other correlations.*\n\nUsing the GMT correlation, the following Gregorian and Mayan dates are equivalent:\n\n```\n  Dec 21, 2012 (Gregorian)\n  4 Ajaw 3 K’ank’in G9 (Calendar round)\n  13.0.0.0.0 (Long count)\n\n```\n\nSupport looking up dates for at least 50 years before and after the Mayan Long Count **13 bak’tun** rollover: *Dec 21, 2012*. *(Will require taking into account Gregorian leap days.)*\n\nShow the output here, on this page, for *at least* the following dates:\n\n*(Note that these are in ISO-8601 format: YYYY-MM-DD. There is no requirement to use ISO-8601 format in your program, but if you differ, make a note of the expected format.)*\n\n```\n   2004-06-19\n   2012-12-18\n   2012-12-21\n   2019-01-19\n   2019-03-27\n   2020-02-29\n   2020-03-01\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\n```\nmy @sacred = <Imix’ Ik’ Ak’bal K’an Chikchan Kimi Manik’ Lamat Muluk Ok\n              Chuwen Eb Ben Hix Men K’ib’ Kaban Etz’nab’ Kawak Ajaw>;\n\nmy @civil = <Pop Wo’ Sip Sotz’ Sek Xul Yaxk’in Mol Ch’en Yax Sak’ Keh\n             Mak K’ank’in Muwan’ Pax K’ayab Kumk’u Wayeb’>;\n\nmy %correlation = :GMT({\n    :gregorian(Date.new('2012-12-21')),\n    :round([3,19,263,8]),\n    :long(1872000)\n});\n\nsub mayan-calendar-round ($date) { .&tzolkin, .&haab given $date }\n\nsub offset ($date, $factor = 'GMT') { Date.new($date) - %correlation{$factor}<gregorian> }\n\nsub haab ($date, $factor = 'GMT') {\n    my $index = (%correlation{$factor}<round>[2] + offset $date) % 365;\n    my ($day, $month);\n    if $index > 360 {\n        $day = $index - 360;\n        $month = @civil[18];\n        if $day == 5 {\n            $day = 'Chum';\n            $month = @civil[0];\n        }\n    } else {\n        $day = $index % 20;\n        $month = @civil[$index div 20];\n        if $day == 0 {\n            $day = 'Chum';\n            $month = @civil[(1 + $index) div 20];\n        }\n    }\n    $day, $month\n}\n\nsub tzolkin ($date, $factor = 'GMT') {\n    my $offset = offset $date;\n    1 + ($offset + %correlation{$factor}<round>[0]) % 13,\n    @sacred[($offset + %correlation{$factor}<round>[1]) % 20]\n}\n\nsub lord ($date, $factor = 'GMT') {\n    'G' ~ 1 + (%correlation{$factor}<round>[3] + offset $date) % 9\n}\n\nsub mayan-long-count ($date, $factor = 'GMT') {\n    my $days = %correlation{$factor}<long> + offset $date;\n    reverse $days.polymod(20,18,20,20);\n}\n\n# HEADER\nsay ' Gregorian   Tzolk’in         Haab’             Long           Lord of ';\nsay '   Date       # Name       Day Month            Count         the Night';\nsay '-----------------------------------------------------------------------';\n\n# DATES\n<\n1963-11-21\n2004-06-19\n2012-12-18\n2012-12-21\n2019-01-19\n2019-03-27\n2020-02-29\n2020-03-01\n2071-05-16\n>.map: -> $date {\n    printf \"%10s   %2s %-9s %4s %-10s     %-14s %6s\\n\", Date.new($date),\n      flat mayan-calendar-round($date), mayan-long-count($date).join('.'), lord($date);\n}\n\n```\n\nOutput:\n\n```\n Gregorian   Tzolk’in        Haab’              Long           Lord of \n   Date       # Name       Day Month            Count         the Night\n-----------------------------------------------------------------------\n1963-11-21    3 Eb        Chum Keh            12.17.10.3.12      G9\n2004-06-19    4 Ben         16 Sotz’          12.19.11.6.13      G7\n2012-12-18    1 Kaban     Chum K’ank’in       12.19.19.17.17     G6\n2012-12-21    4 Ajaw         3 K’ank’in       13.0.0.0.0         G9\n2019-01-19    1 Ajaw        13 Muwan’         13.0.6.3.0         G6\n2019-03-27    3 Manik’    Chum Wayeb’         13.0.6.6.7         G1\n2020-02-29    4 Kimi        14 K’ayab         13.0.7.5.6         G7\n2020-03-01    5 Manik’      15 K’ayab         13.0.7.5.7         G8\n2071-05-16    1 Ok          18 Sip            13.2.19.4.10       G9\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nPresent numbers using the Mayan numbering system   (displaying the Mayan numerals in a cartouche).\n\nMayan numbers\n\nNormally, Mayan numbers are written vertically   (top─to─bottom)   with the most significant\nnumeral at the top   (in the sense that decimal numbers are written left─to─right with the most significant\ndigit at the left).   This task will be using a left─to─right (horizontal) format,   mostly for familiarity and\nreadability,   and to conserve screen space (when showing the output) on this task page.\n\nMayan numerals\n\nMayan numerals   (a base─20 \"digit\" or glyph)   are written in two orientations,   this\ntask will be using the \"vertical\" format   (as displayed below).   Using the vertical format makes\nit much easier to draw/construct the Mayan numerals (glyphs) with simple dots (**.**)\nand hyphen (**-**);     (however, round bullets (**•**) and long dashes (**─**)\nmake a better presentation on Rosetta Code).\n\nFurthermore, each Mayan numeral   (for this task)   is to be displayed as a\ncartouche   (enclosed in a box)   to make it easier to parse (read);   the box may be\ndrawn with any suitable (ASCII or Unicode) characters that are presentable/visible in all web browsers.\n\nMayan numerals added to Unicode\n\nMayan numerals (glyphs) were added to the Unicode Standard in June of 2018   (this corresponds with\nversion 11.0).   But since most web browsers don't support them at this time,   this Rosetta Code\ntask will be constructing the glyphs with \"simple\" characters and/or ASCII art.\n\nThe \"zero\" glyph\n\nThe Mayan numbering system has the concept of   **zero**,   and should be shown by a glyph that represents\nan upside─down (sea) shell,   or an egg.   The Greek letter **theta**   (**Θ**)   can be\nused   (which more─or─less, looks like an\negg).   A   *commercial at*   symbol   (**@**)   could make a poor substitute.\n\nMayan glyphs (constructed)\n\nThe Mayan numbering system is\na   [vigesimal (base 20)]   positional numeral system.\n\nThe Mayan numerals   (and some random numbers)   shown in the   *vertical*   format would be shown as\n\n```\n      ╔════╗                      ╔════╗                            ╔════╦════╗\n      ║    ║                      ║    ║                            ║    ║    ║\n      ║    ║                      ║ ∙  ║                            ║    ║    ║\n 1──► ║    ║                11──► ║────║                      21──► ║    ║    ║\n      ║ ∙  ║                      ║────║                            ║ ∙  ║ ∙  ║\n      ╚════╝                      ╚════╝                            ╚════╩════╝\n      ╔════╗                      ╔════╗                            ╔════╦════╗\n      ║    ║                      ║    ║                            ║    ║    ║\n      ║    ║                      ║ ∙∙ ║                            ║    ║    ║\n 2──► ║    ║                12──► ║────║                      22──► ║    ║    ║\n      ║ ∙∙ ║                      ║────║                            ║ ∙  ║ ∙∙ ║\n      ╚════╝                      ╚════╝                            ╚════╩════╝\n      ╔════╗                      ╔════╗                            ╔════╦════╗\n      ║    ║                      ║    ║                            ║    ║    ║\n      ║    ║                      ║∙∙∙ ║                            ║    ║    ║\n 3──► ║    ║                13──► ║────║                      40──► ║    ║    ║\n      ║∙∙∙ ║                      ║────║                            ║ ∙∙ ║ Θ  ║\n      ╚════╝                      ╚════╝                            ╚════╩════╝\n      ╔════╗                      ╔════╗                            ╔════╦════╗\n      ║    ║                      ║    ║                            ║    ║    ║\n      ║    ║                      ║∙∙∙∙║                            ║    ║    ║\n 4──► ║    ║                14──► ║────║                      80──► ║    ║    ║\n      ║∙∙∙∙║                      ║────║                            ║∙∙∙∙║ Θ  ║\n      ╚════╝                      ╚════╝                            ╚════╩════╝\n      ╔════╗                      ╔════╗                            ╔════╦════╗\n      ║    ║                      ║    ║                            ║    ║    ║\n      ║    ║                      ║────║                            ║    ║    ║\n 5──► ║    ║                15──► ║────║                      90──► ║    ║────║\n      ║────║                      ║────║                            ║∙∙∙∙║────║\n      ╚════╝                      ╚════╝                            ╚════╩════╝\n      ╔════╗                      ╔════╗                            ╔════╦════╗\n      ║    ║                      ║ ∙  ║                            ║    ║    ║\n      ║    ║                      ║────║                            ║    ║    ║\n 6──► ║ ∙  ║                16──► ║────║                     100──► ║    ║    ║\n      ║────║                      ║────║                            ║────║ Θ  ║\n      ╚════╝                      ╚════╝                            ╚════╩════╝\n      ╔════╗                      ╔════╗                            ╔════╦════╗\n      ║    ║                      ║ ∙∙ ║                            ║    ║    ║\n      ║    ║                      ║────║                            ║    ║    ║\n 7──► ║ ∙∙ ║                17──► ║────║                     200──► ║────║    ║\n      ║────║                      ║────║                            ║────║ Θ  ║\n      ╚════╝                      ╚════╝                            ╚════╩════╝\n      ╔════╗                      ╔════╗                            ╔════╦════╗\n      ║    ║                      ║∙∙∙ ║                            ║    ║    ║\n      ║    ║                      ║────║                     300──► ║────║    ║\n 8──► ║∙∙∙ ║                18──► ║────║                            ║────║    ║\n      ║────║                      ║────║                            ║────║ Θ  ║\n      ╚════╝                      ╚════╝                            ╚════╩════╝\n      ╔════╗                      ╔════╗                            ╔════╦════╦════╗\n      ║    ║                      ║∙∙∙∙║                            ║    ║    ║    ║\n      ║    ║                      ║────║                     400──► ║    ║    ║    ║\n 9──► ║∙∙∙∙║                19──► ║────║                            ║    ║    ║    ║\n      ║────║                      ║────║                            ║ ∙  ║ Θ  ║ Θ  ║\n      ╚════╝                      ╚════╝                            ╚════╩════╩════╝\n      ╔════╗                      ╔════╦════╗                       ╔════╦════╦════╦════╗\n      ║    ║                      ║    ║    ║                       ║    ║    ║    ║    ║\n      ║    ║                      ║    ║    ║                       ║    ║    ║    ║    ║\n10──► ║────║                20──► ║    ║    ║             16,000──► ║    ║    ║    ║    ║\n      ║────║                      ║ ∙  ║ Θ  ║                       ║ ∙∙ ║ Θ  ║ Θ  ║ Θ  ║\n      ╚════╝                      ╚════╩════╝                       ╚════╩════╩════╩════╝\n\n```\n\nNote that the Mayan numeral   **13**   in   *horizontal*   format would be shown as:\n\n```\n                                  ╔════╗\n                                  ║  ││║\n                                  ║ ∙││║\n                            13──► ║ ∙││║        ◄─── this glyph form won't be used in this Rosetta Code task.\n                                  ║ ∙││║\n                                  ╚════╝\n\n```\n\nOther forms of cartouches (boxes) can be used for this task.\n\nTask requirements\n:   * convert the following decimal numbers to Mayan numbers:\n\n    :   :   * 4,005\n            * 8,017\n            * 326,205\n            * 886,205\n\n    * show a   unique   *interesting/pretty/unusual/intriguing/odd/amusing/weird*   Mayan number\n    * show all output here\n\nRelated tasks\n:   * Roman numerals/Encode   ─── convert numeric values into Roman numerals\n    * Roman numerals/Decode   ─── convert Roman numerals into Arabic numbers\n\nSee also\n:   * The Wikipedia entry:   [Mayan numerals]"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nJust a matter of converting to base twenty, then divmod 5 each digit and map to the appropriate glyph. Most of this is display code to deal with the cartouche requirement.\n\nI actually spent a little time looking into what exactly a Mayan cartouche was supposed to look like. The classic Mayan cartouche was kind of a rounded rectangle with three little semi-circles underneath. Kind of looks like a picture frame. In general, they were only used when expressing significant \"holy\" dates in the Mayan calender.\n\nThese don't particularly resemble the Mayan cartouche, more like mahjong tiles actually. It would have been *so* much easier and more compact if I could have put all the styling into a CSS file instead of inlining it, but oh well, it was entertaining to do.\n\n```\n### Formatting ###\nmy $t-style = '\"border-collapse: separate; text-align: center; border-spacing: 3px 0px;\"';\nmy $c-style = '\"border: solid black 2px;background-color: #fffff0;border-bottom: double 6px;'~\n  'border-radius: 1em;-moz-border-radius: 1em;-webkit-border-radius: 1em;'~\n  'vertical-align: bottom;width: 3.25em;\"';\nmy $joiner = '<br>';\n\nsub display ($num, @digits) { join \"\\n\", \"\\{| style=$t-style\", \"|+ $num\", '|-', (|@digits.map: {\"| style=$c-style | $_\"}), '|}' }\n\n### Logic ###\n\nsub mayan ($int) { $int.polymod(20 xx *).reverse.map: *.polymod(5) }\n\nmy @output = <4005 8017 326205 886205 16160025 1081439556 503491211079>.map: {\n  display $_, .&mayan.map: { [flat '' xx 3, '●' x .[0], '───' xx .[1], ('Θ' if !.[0,1].sum)].tail(4).join: $joiner }\n}\n\nsay @output.join: \"\\n$joiner\\n\";\n\n```\n\nOutput:\n\n4005\n\n|  |  |  |\n| --- | --- | --- |\n| ─── ─── | Θ | ─── |\n\n8017\n\n|  |  |  |  |\n| --- | --- | --- | --- |\n| ● | Θ | Θ | ●● ─── ─── ─── |\n\n326205\n\n|  |  |  |  |  |\n| --- | --- | --- | --- | --- |\n| ●● | Θ | ─── ─── ─── | ─── ─── | ─── |\n\n886205\n\n|  |  |  |  |  |\n| --- | --- | --- | --- | --- |\n| ─── | ─── ─── | ─── ─── ─── | ─── ─── | ─── |\n\n16160025\n\n|  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- |\n| ─── | ● | Θ | Θ | ● | ─── |\n\n1081439556\n\n|  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- |\n| ● ─── ─── ─── | ●● ─── ─── ─── | ●●● ─── ─── ─── | ●●●● ─── ─── ─── | ●●● ─── ─── ─── | ●● ─── ─── ─── | ● ─── ─── ─── |\n\n503491211079\n\n|  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| ●●●● ─── ─── ─── | ●●● ─── ─── | ●● ─── | ● | Θ | ● | ●● ─── | ●●● ─── ─── | ●●●● ─── ─── ─── |\n\nOr, plain old text mode. Not as pretty, but still serviceable.\n\n```\n### Formatting ###\nuse Terminal::Boxer;\nmy $joiner = \"\\n\";\n\nsub display ($num, @digits) { \"$num\\n\" ~ dd-box( :6cw, :4ch, @digits ) }\n\n### Logic ###\n\nsub mayan ($int) { $int.polymod(20 xx *).reverse.map: *.polymod(5) }\n\nmy @output = <4005 8017 326205 886205 16160025 1081439556 503491211079>.map: {\n  display $_, .&mayan.map: { [flat '' xx 3, '●' x .[0], '────' xx .[1], ('Θ' if !.[0,1].sum)].tail(4).join: $joiner }\n}\n\nsay @output.join: $joiner;\n\n```\n\nOutput:\n\n```\n4005\n╔══════╦══════╦══════╗\n║      ║      ║      ║\n║      ║      ║      ║\n║ ──── ║      ║      ║\n║ ──── ║   Θ  ║ ──── ║\n╚══════╩══════╩══════╝\n\n8017\n╔══════╦══════╦══════╦══════╗\n║      ║      ║      ║  ●●  ║\n║      ║      ║      ║ ──── ║\n║      ║      ║      ║ ──── ║\n║   ●  ║   Θ  ║   Θ  ║ ──── ║\n╚══════╩══════╩══════╩══════╝\n\n326205\n╔══════╦══════╦══════╦══════╦══════╗\n║      ║      ║      ║      ║      ║\n║      ║      ║ ──── ║      ║      ║\n║      ║      ║ ──── ║ ──── ║      ║\n║  ●●  ║   Θ  ║ ──── ║ ──── ║ ──── ║\n╚══════╩══════╩══════╩══════╩══════╝\n\n886205\n╔══════╦══════╦══════╦══════╦══════╗\n║      ║      ║      ║      ║      ║\n║      ║      ║ ──── ║      ║      ║\n║      ║ ──── ║ ──── ║ ──── ║      ║\n║ ──── ║ ──── ║ ──── ║ ──── ║ ──── ║\n╚══════╩══════╩══════╩══════╩══════╝\n\n16160025\n╔══════╦══════╦══════╦══════╦══════╦══════╗\n║      ║      ║      ║      ║      ║      ║\n║      ║      ║      ║      ║      ║      ║\n║      ║      ║      ║      ║      ║      ║\n║ ──── ║   ●  ║   Θ  ║   Θ  ║   ●  ║ ──── ║\n╚══════╩══════╩══════╩══════╩══════╩══════╝\n\n1081439556\n╔══════╦══════╦══════╦══════╦══════╦══════╦══════╗\n║   ●  ║  ●●  ║  ●●● ║ ●●●● ║  ●●● ║  ●●  ║   ●  ║\n║ ──── ║ ──── ║ ──── ║ ──── ║ ──── ║ ──── ║ ──── ║\n║ ──── ║ ──── ║ ──── ║ ──── ║ ──── ║ ──── ║ ──── ║\n║ ──── ║ ──── ║ ──── ║ ──── ║ ──── ║ ──── ║ ──── ║\n╚══════╩══════╩══════╩══════╩══════╩══════╩══════╝\n\n503491211079\n╔══════╦══════╦══════╦══════╦══════╦══════╦══════╦══════╦══════╗\n║ ●●●● ║      ║      ║      ║      ║      ║      ║      ║ ●●●● ║\n║ ──── ║  ●●● ║      ║      ║      ║      ║      ║  ●●● ║ ──── ║\n║ ──── ║ ──── ║  ●●  ║      ║      ║      ║  ●●  ║ ──── ║ ──── ║\n║ ──── ║ ──── ║ ──── ║   ●  ║   Θ  ║   ●  ║ ──── ║ ──── ║ ──── ║\n╚══════╩══════╩══════╩══════╩══════╩══════╩══════╩══════╩══════╝\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Maze generation algorithm. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\na maze\n\nTask\n\nGenerate and show a maze, using the simple Depth-first search algorithm.\n\n1. Start at a random cell.\n2. Mark the current cell as visited, and get a list of its neighbors. For each neighbor, starting with a randomly selected neighbor:\n\n   :   If that neighbor hasn't been visited, remove the wall between this cell and that neighbor, and then recurse with that neighbor as the current cell.\n\nRelated tasks\n\n* Maze solving."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-22\n\nSupply a width and height and optionally the x,y grid coords for the starting cell. If no starting cell is supplied, a random one will be selected automatically. 0,0 is the top left corner.\n\n```\nconstant mapping = :OPEN(' '),\n\t\t      :N< ╵ >,\n\t\t      :E< ╶ >,\n\t\t     :NE< └ >,\n\t\t      :S< ╷ >,\n\t\t     :NS< │ >,\n\t\t     :ES< ┌ >,\n\t\t    :NES< ├ >,\n\t\t      :W< ╴ >,\n\t\t     :NW< ┘ >,\n\t\t     :EW< ─ >,\n\t\t    :NEW< ┴ >,\n\t\t     :SW< ┐ >,\n\t\t    :NSW< ┤ >,\n\t\t    :ESW< ┬ >,\n\t\t   :NESW< ┼ >,\n\t\t   :TODO< x >,\n\t          :TRIED< · >;\n \nenum Sym (mapping.map: *.key);\nmy @ch = mapping.map: *.value;\n \nenum Direction <DeadEnd Up Right Down Left>;\n \nsub gen_maze ( $X,\n               $Y,\n               $start_x = (^$X).pick * 2 + 1,\n               $start_y = (^$Y).pick * 2 + 1 )\n{\n    my @maze;\n    push @maze, $[ flat ES, -N, (ESW, EW) xx $X - 1, SW ];\n    push @maze, $[ flat (NS, TODO) xx $X, NS ];\n    for 1 ..^ $Y {\n\tpush @maze, $[ flat NES, EW, (NESW, EW) xx $X - 1, NSW ];\n\tpush @maze, $[ flat (NS, TODO) xx $X, NS ];\n    }\n    push @maze, $[ flat NE, (EW, NEW) xx $X - 1, -NS, NW ];\n    @maze[$start_y][$start_x] = OPEN;\n \n    my @stack;\n    my $current = [$start_x, $start_y];\n    loop {\n        if my $dir = pick_direction( $current ) {\n            @stack.push: $current;\n            $current = move( $dir, $current );\n        }\n        else {\n            last unless @stack;\n            $current = @stack.pop;\n        }\n    }\n    return @maze;\n \n    sub pick_direction([$x,$y]) {\n\tmy @neighbors =\n\t    (Up    if @maze[$y - 2][$x]),\n\t    (Down  if @maze[$y + 2][$x]),\n\t    (Left  if @maze[$y][$x - 2]),\n\t    (Right if @maze[$y][$x + 2]);\n\t@neighbors.pick or DeadEnd;\n    }\n \n    sub move ($dir, @cur) {\n\tmy ($x,$y) = @cur;\n\tgiven $dir {\n\t    when Up    { @maze[--$y][$x] = OPEN; @maze[$y][$x-1] -= E; @maze[$y--][$x+1] -= W; }\n\t    when Down  { @maze[++$y][$x] = OPEN; @maze[$y][$x-1] -= E; @maze[$y++][$x+1] -= W; }\n\t    when Left  { @maze[$y][--$x] = OPEN; @maze[$y-1][$x] -= S; @maze[$y+1][$x--] -= N; }\n\t    when Right { @maze[$y][++$x] = OPEN; @maze[$y-1][$x] -= S; @maze[$y+1][$x++] -= N; }\n\t} \n\t@maze[$y][$x] = 0;\n\t[$x,$y];\n    }\n}\n \nsub display (@maze) {\n    for @maze -> @y {\n\tfor @y.rotor(2) -> ($w, $c) {\n\t    print @ch[abs $w];\n\t    if $c >= 0 { print @ch[$c] x 3 } \n\t    else { print ' ', @ch[abs $c], ' ' }\n\t}\n\tsay @ch[@y[*-1]];\n    }\n}\n \ndisplay gen_maze( 29, 19 );\n\n```\n\nOutput:\n\n```\n┌ ╵ ────────────────────────────┬───────────────────────────────────────────┬───────────┬───────────────────────────┐\n│                               │                                           │           │                           │\n│   ╶───────────┬───────────┐   │   ┌───────────────────────╴   ┌───────┐   ├───╴   ╷   │   ┌───────────┬───┬───╴   │\n│               │           │   │   │                           │       │   │       │   │   │           │   │       │\n│   ┌───────┐   ╵   ┌───┐   ├───┘   │   ┌───────────┬───────────┤   ╶───┤   │   ╶───┴───┤   │   ┌───┐   │   │   ╶───┤\n│   │       │       │   │   │       │   │           │           │       │   │           │   │   │   │   │   │       │\n│   └───╴   └───────┤   │   ╵   ┌───┘   │   ╷   ╶───┤   ┌───┐   │   ╷   │   ├───────╴   │   ╵   │   │   │   └───┐   │\n│                   │   │       │       │   │       │   │   │   │   │   │   │           │       │   │   │       │   │\n├───────┬───────┐   │   ├───────┤   ╶───┤   └───┐   ╵   │   │   ╵   │   ╵   │   ┌───┐   └───┬───┘   │   │   ╷   │   │\n│       │       │   │   │       │       │       │       │   │       │       │   │   │       │       │   │   │   │   │\n│   ╶───┤   ╷   ╵   │   ╵   ╷   └───┐   ├───┐   ├───────┤   └───────┴───────┘   │   └───┐   └───╴   │   ╵   ├───┘   │\n│       │   │       │       │       │   │   │   │       │                       │       │           │       │       │\n├───╴   │   ├───────┴───┐   ├───╴   │   │   │   ╵   ╷   └───┐   ╶───┬───────┬───┘   ┌───┴───────╴   │   ┌───┘   ╷   │\n│       │   │           │   │       │   │   │       │       │       │       │       │               │   │       │   │\n│   ╷   │   │   ╶───┐   └───┤   ╷   │   │   └───────┴───┐   └───╴   │   ╷   ╵   ╷   ╵   ╶───────┬───┤   │   ┌───┴───┤\n│   │   │   │       │       │   │   │   │               │           │   │       │               │   │   │   │       │\n│   │   │   │   ╷   ├───╴   ╵   │   │   │   ┌───────┐   └───────────┤   └───┬───┴───────────┐   ╵   │   │   ╵   ╷   │\n│   │   │   │   │   │           │   │   │   │       │               │       │               │       │   │       │   │\n│   │   │   ├───┘   │   ┌───────┴───┘   │   ╵   ┌───┴───────╴   ╷   ├───┐   │   ╶───────┐   └───┐   │   └───┬───┘   │\n│   │   │   │       │   │               │       │               │   │   │   │           │       │   │       │       │\n│   └───┘   │   ┌───┘   │   ┌───┬───────┼───╴   │   ╶───┬───────┤   ╵   │   └───┬───╴   ├───┐   │   └───┐   │   ╷   │\n│           │   │       │   │   │       │       │       │       │       │       │       │   │   │       │   │   │   │\n│   ┌───────┘   ├───────┤   │   ╵   ╷   │   ┌───┴───┐   │   ╶───┘   ┌───┴───╴   │   ┌───┘   │   │   ┌───┘   │   │   │\n│   │           │       │   │       │   │   │       │   │           │           │   │       │   │   │       │   │   │\n│   └───╴   ╷   │   ╷   │   └───┐   │   ╵   │   ╷   ╵   ├───────┐   │   ╶───────┤   └───┐   │   └───┤   ┌───┘   │   │\n│           │   │   │   │       │   │       │   │       │       │   │           │       │   │       │   │       │   │\n├───────────┤   │   │   └───╴   │   └───────┤   └───────┘   ╷   └───┴───┬───╴   ├───╴   │   └───┐   │   │   ╶───┴───┤\n│           │   │   │           │           │               │           │       │       │       │   │   │           │\n│   ┌───╴   │   │   ├───╴   ┌───┴───────┬───┴───┐   ┌───────┴───────┐   ╵   ┌───┤   ╶───┤   ╷   │   ╵   └───┬───╴   │\n│   │       │   │   │       │           │       │   │               │       │   │       │   │   │           │       │\n│   │   ╶───┘   │   │   ╶───┤   ╶───┐   ╵   ╷   │   └───╴   ┌───╴   └───────┘   ├───╴   │   ├───┴───────┬───┘   ╷   │\n│   │           │   │       │       │       │   │           │                   │       │   │           │       │   │\n│   ├───────┬───┘   ├───────┴───┐   ├───────┤   └───────────┤   ┌───────────┐   │   ┌───┘   │   ╶───┐   ╵   ┌───┘   │\n│   │       │       │           │   │       │               │   │           │   │   │       │       │       │       │\n│   └───╴   │   ╷   │   ╶───┐   ╵   │   ╷   └───────────┐   │   │   ┌───┐   └───┘   │   ╶───┴───┐   └───────┴───────┤\n│           │   │   │       │       │   │               │   │   │   │   │           │           │                   │\n├───────╴   │   └───┴───╴   └───────┴───┴───────────╴   │   └───┘   ╵   └───────────┴───╴   ╷   └───────────────┐   │\n│           │                                           │                                   │                   │   │\n└───────────┴───────────────────────────────────────────┴───────────────────────────────────┴───────────────────┴ │ ┘\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFor a maze generated by this task, write a function\nthat finds (and displays) the shortest path between two cells.\n\nNote that because these mazes are generated by the Depth-first search algorithm, they contain no circular paths,\nand a simple depth-first tree search can be used."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.02\n\n(Includes maze generation code.)\n\n```\nconstant mapping = :OPEN(' '),\n\t\t      :N< ╵ >,\n\t\t      :E< ╶ >,\n\t\t     :NE< └ >,\n\t\t      :S< ╷ >,\n\t\t     :NS< │ >,\n\t\t     :ES< ┌ >,\n\t\t    :NES< ├ >,\n\t\t      :W< ╴ >,\n\t\t     :NW< ┘ >,\n\t\t     :EW< ─ >,\n\t\t    :NEW< ┴ >,\n\t\t     :SW< ┐ >,\n\t\t    :NSW< ┤ >,\n\t\t    :ESW< ┬ >,\n\t\t   :NESW< ┼ >,\n\t\t   :TODO< x >,\n\t          :TRIED< · >;\n \nenum Sym (mapping.map: *.key);\nmy @ch = mapping.map: *.value;\n \nenum Direction <DeadEnd Up Right Down Left>;\n \nsub gen_maze ( $X,\n               $Y,\n               $start_x = (^$X).pick * 2 + 1,\n               $start_y = (^$Y).pick * 2 + 1 )\n{\n    my @maze;\n    push @maze, $[ flat ES, -N, (ESW, EW) xx $X - 1, SW ];\n    push @maze, $[ flat (NS, TODO) xx $X, NS ];\n    for 1 ..^ $Y {\n\tpush @maze, $[ flat NES, EW, (NESW, EW) xx $X - 1, NSW ];\n\tpush @maze, $[ flat (NS, TODO) xx $X, NS ];\n    }\n    push @maze, $[ flat NE, (EW, NEW) xx $X - 1, -NS, NW ];\n    @maze[$start_y][$start_x] = OPEN;\n \n    my @stack;\n    my $current = [$start_x, $start_y];\n    loop {\n        if my $dir = pick_direction( $current ) {\n            @stack.push: $current;\n            $current = move( $dir, $current );\n        }\n        else {\n            last unless @stack;\n            $current = @stack.pop;\n        }\n    }\n    return @maze;\n \n    sub pick_direction([$x,$y]) {\n\tmy @neighbors =\n\t    (Up    if @maze[$y - 2][$x]),\n\t    (Down  if @maze[$y + 2][$x]),\n\t    (Left  if @maze[$y][$x - 2]),\n\t    (Right if @maze[$y][$x + 2]);\n\t@neighbors.pick or DeadEnd;\n    }\n \n    sub move ($dir, @cur) {\n\tmy ($x,$y) = @cur;\n\tgiven $dir {\n\t    when Up    { @maze[--$y][$x] = OPEN; @maze[$y][$x-1] -= E; @maze[$y--][$x+1] -= W; }\n\t    when Down  { @maze[++$y][$x] = OPEN; @maze[$y][$x-1] -= E; @maze[$y++][$x+1] -= W; }\n\t    when Left  { @maze[$y][--$x] = OPEN; @maze[$y-1][$x] -= S; @maze[$y+1][$x--] -= N; }\n\t    when Right { @maze[$y][++$x] = OPEN; @maze[$y-1][$x] -= S; @maze[$y+1][$x++] -= N; }\n\t} \n\t@maze[$y][$x] = 0;\n\t[$x,$y];\n    }\n}\n \nsub display (@maze) {\n    for @maze -> @y {\n\tfor @y.rotor(2) -> ($w, $c) {\n\t    print @ch[abs $w];\n\t    if $c >= 0 { print @ch[$c] x 3 } \n\t    else { print ' ', @ch[abs $c], ' ' }\n\t}\n\tsay @ch[@y[*-1]];\n    }\n}\n \nsub solve (@maze is copy, @from = [1, 1], @to = [@maze[0] - 2, @maze - 2]) {\n    my ($x, $y) = @from;\n    my ($xto, $yto) = @to;\n    my @stack;\n\n    sub drop-crumb($x,$y,$c) { @maze[$y][$x] = -$c }\n    drop-crumb($x,$y,N);\n\n    loop {\n\tmy $dir = pick_direction([$x,$y]);\n\tif $dir {\n\t    ($x, $y) = move($dir, [$x,$y]);\n\t    return @maze if $x == $xto and $y == $yto;\n\t}\n\telse {\n\t    @maze[$y][$x] = -TRIED;\n\t    ($x,$y) = @stack.pop;\n\t    @maze[$y][$x] = -TRIED;\n\t    ($x,$y) = @stack.pop;\n\t}\n    }\n\n    sub pick_direction([$x,$y]) {\n\tmy @neighbors =\n\t    (Up    unless @maze[$y - 1][$x]),\n\t    (Down  unless @maze[$y + 1][$x]),\n\t    (Left  unless @maze[$y][$x - 1]),\n\t    (Right unless @maze[$y][$x + 1]);\n\t@neighbors.pick or DeadEnd;\n    }\n\n    sub move ($dir, @cur) {\n\tmy ($x,$y) = @cur;\n\tgiven $dir {\n\t    when Up    { for ^2 { push @stack, $[$x,$y--]; drop-crumb $x,$y,S; } }\n\t    when Down  { for ^2 { push @stack, $[$x,$y++]; drop-crumb $x,$y,N; } }\n\t    when Left  { for ^2 { push @stack, $[$x--,$y]; drop-crumb $x,$y,E; } }\n\t    when Right { for ^2 { push @stack, $[$x++,$y]; drop-crumb $x,$y,W; } }\n\t} \n\t$x,$y;\n    }\n}\n\ndisplay solve gen_maze( 29, 19 );\n\n```\n\nOutput:\n\n```\n┌ ╵ ────┬───────────────┬───────────────┬───────────────────────────────┬───────────┬───────────────┬───────────────┐\n│ ╵ · · │ ╷ ╴ ╴ ╴ ╴     │               │ ╷ ╴ ╴ · · · · · · · · · · · · │ ╷ ╴ ╴ · · │ · · · · · · · │ · · · · · · · │\n│ ╵ ╶───┘ ╷ ╶───┐ ╵ ╷   │   ╷   ╶───────┤ ╷ ╷ ╵ ╶───────┬───────┐ · ┌───┘ ╷ ╷ ╵ ╷ · │ · ╶───┬───╴ · │ · ╷ · ┌───╴ · │\n│ ╵ ╴ ╴ ╴ ╴ · · │ ╵ │   │   │           │ ╷ │ ╵ ╴ ╴ ╴ ╴ │ ╷ ╴ ╴ │ · │ ╷ ╴ ╴ │ ╵ │ · │ · · · │ · · · │ · │ · │ · · · │\n│ · ┌───────────┤ ╵ │   └───┴───────╴   │ ╷ ├───────┐ ╵ ╵ ╷ ╷ ╵ └───┘ ╷ ┌───┘ ╵ │ · │ · ╷ · │ · ┌───┴───┘ · │ · ╶───┤\n│ · │ ╶ ╶ ╶ ╶ ╷ │ ╵ │                   │ ╷ │       │ ╵ ╴ ╴ │ ╵ ╴ ╴ ╴ ╴ │ ╶ ╶ ╵ │ · │ · │ · │ · │ · · · · · │ · · · │\n│ · │ ╵ ╶───┐ ╷ ╵ ╵ ├───────────────╴   │ ╷ └───╴   └───────┼───┬───────┤ ╵ ┌───┤ · ├───┘ · │ · │ · ╷ · ┌───┴───┐ · │\n│ · │ ╵ ╴ ╴ │ ╶ ╶ ╵ │                   │ ╶ ╶ ╶ ╶ ╶ ╶ ╶ ╶ ╷ │ · │ ╶ ╶ ╷ │ ╵ │ · │ · │ · · · │ · │ · │ · │ · · · │ · │\n│ · └───┐ ╵ ├───────┴───────┐   ╶───────┴───────┬───────╴ ╷ │ · │ ╵ ╷ ╷ │ ╵ │ · │ · │ · ┌───┤ · │ · │ · │ · ╷ · ╵ · │\n│ · · · │ ╵ │ ╷ ╴ ╴ ╴ ╴ ╴ ╴ │                   │ ╷ ╴ ╴ ╴ ╴ │ · │ ╵ │ ╷ │ ╵ │ · │ · │ · │ · │ · │ · │ · │ · │ · · · │\n├───╴ · │ ╵ │ ╷ ╶───────┐ ╵ ├───────────────┐   │ ╷ ╶───┬───┘ · │ ╵ │ ╷ ╵ ╵ │ · ╵ · ╵ · │ · ╵ · └───┘ · │ · ├───────┤\n│ · · · │ ╵ │ ╶ ╶ ╶ ╶ ╷ │ ╵ │ ╷ ╴ ╴ ╴ ╴ ╴ ╴ │   │ ╶ ╶ ╷ │ · · · │ ╵ │ ╶ ╶ ╵ │ · · · · · │ · · · · · · · │ · │ · · · │\n│ · ┌───┤ ╵ └───────╴ ╷ │ ╵ ╵ ╷ ┌───────┐ ╵ │   └───┐ ╷ └───┐ · │ ╵ ├───────┼───────┬───┴───────┬───┬───┘ · ├───╴ · │\n│ · │ · │ ╵ ╴ ╴ ╴ ╴ ╴ ╴ │ ╵ ╴ ╴ │ · · · │ ╵ │       │ ╶ ╶ ╷ │ · │ ╵ │ ╷ ╴ ╴ │ ╷ ╴ ╴ │ ╷ ╴ ╴ ╴ ╴ │ · │ · · · │ · · · │\n│ · ╵ · ├───────────────┴───────┴───┐ · │ ╵ └───────┴───┐ ╷ │ · │ ╵ ╵ ╷ ╷ ╵ ╵ ╷ ╷ ╵ │ ╷ ┌───╴ ╵ │ · │ · ╶───┤ · ╶───┤\n│ · · · │ · · · · · · · · · · · · · │ · │ ╵ ╴ ╴ ╴ ╴ · · │ ╷ │ · │ ╵ ╴ ╴ │ ╵ ╴ ╴ │ ╵ │ ╷ │ ╶ ╶ ╵ │ · │ · · · │ · · · │\n├───┐ · │ · ┌───────────╴ · ┌───┐ · │ · └───┬───╴ ╵ ┌───┘ ╷ │ · ├───────┴───────┤ ╵ ╵ ╷ │ ╵ ╶───┤ · └───┐ · │ · ╷ · │\n│ · │ · │ · │ · · · · · · · │ · │ · │ · · · │ ╶ ╶ ╵ │ ╷ ╴ ╴ │ · │ · · · · · · · │ ╵ ╴ ╴ │ ╵ ╴ ╴ │ · · · │ · │ · │ · │\n│ · │ · └───┘ · ┌───────────┘ · │ · ├───╴ · │ ╵ ┌───┘ ╷ ┌───┘ · │ · ╷ · ┌───╴ · └───────┴───┐ ╵ └───┐ · ╵ · ├───┘ · │\n│ · │ · · · · · │ · · · · · · · │ · │ · · · │ ╵ │ ╷ ╴ ╴ │ · · · │ · │ · │ · · · · · · · · · │ ╵ ╴ ╴ │ · · · │ · · · │\n│ · ├───────╴ · ├───┐ · ┌───┐ · ╵ · │ · ╶───┤ ╵ ╵ ╷ ┌───┘ · ╶───┤ · │ · └───┬───╴ · ┌───────┤ · ╷ ╵ │ · ╶───┘ · ╷ · │\n│ · │ · · · · · │   │ · │ · │ · · · │ · · · │ ╵ ╴ ╴ │ · · · · · │ · │ · · · │ · · · │ ╶ ╶ ╷ │ · │ ╵ │ · · · · · │ · │\n│ · ╵ · ┌───────┘   │ · ╵ · └───────┤ · ╷ · └───────┴───────┐ · ╵ · └───┐ · └───┐ · │ ╵ ╷ ╷ └───┘ ╵ ├───────────┤ · │\n│ · · · │           │ · · · · · · · │ · │ · · · · · · · · · │ · · · · · │ · · · │ · │ ╵ │ ╶ ╶ ╶ ╶ ╵ │ ╷ ╴ ╴ ╴ ╴ │ · │\n│ · ╶───┤   ╶───────┴───┬───────┐ · ├───┘ · ┌───────────┐ · ├───────────┴───╴ · │ · │ ╵ └───────┐ · │ ╷ ┌───╴ ╵ │ · │\n│ · · · │               │ · · · │ · │ · · · │ · · · · · │ · │ · · · · · · · · · │ · │ ╵ ╴ ╴ ╴ ╴ │ · │ ╷ │ ╶ ╶ ╵ │ · │\n├───┐ · ├───────┬───╴   │ · ╷ · │ · │ · ┌───┤ · ╶───────┤ · │ · ╶───────┬───┐ · ├───┴───────┐ ╵ └───┘ ╷ │ ╵ ┌───┴───┤\n│ · │ · │       │       │ · │ · │ · │ · │ · │ · · · · · │ · │ · · · · · │ · │ · │           │ ╵ ╴ ╴ ╴ ╴ │ ╵ │ ╷ ╴ ╴ │\n│ · │ · │   ╷   ╵   ┌───┘ · │ · ╵ · ╵ · │ · ╵ · ┌───┐ · ╵ · └───────╴ · │ · ╵ · │   ┌───╴   └───────┐ · │ ╵ ╵ ╷ ╷ ╵ │\n│ · │ · │   │       │ · · · │ · · · · · │ · · · │ · │ · · · · · · · · · │ · · · │   │               │ · │ ╵ ╴ ╴ │ ╵ │\n│ · │ · │   └───┬───┴───────┴───┬───────┤ · ┌───┘ · ├───────────────────┴───────┤   └───────────┐   └───┴───────┤ ╵ │\n│ · │ · │       │               │       │ · │ · · · │                           │               │               │ ╵ │\n│ · ╵ · ├───┐   │   ╶───────┐   ╵   ╷   │ · ╵ · ╷ · │   ╶───────────────────┐   └───┬───────┐   └───────┬───┐   │ ╵ │\n│ · · · │ · │   │           │       │   │ · · · │ · │                       │       │       │           │   │   │ ╵ │\n│ · ╶───┤ · │   └───────┐   ├───────┤   └───┬───┴───┼───────────┬───────┐   ├───┐   ╵   ╷   ├───────┐   │   │   │ ╵ │\n│ · · · │ · │           │   │       │       │       │           │       │   │   │       │   │       │   │   │   │ ╵ │\n├───╴ · ╵ · └───────┐   ╵   │   ╷   └───╴   ╵   ╷   ╵   ┌───╴   ╵   ╷   ╵   │   └───────┘   ╵   ╷   ╵   │   ╵   ╵ ╵ │\n│ · · · · · · · · · │       │   │               │       │           │       │                   │       │         ╵ │\n└───────────────────┴───────┴───┴───────────────┴───────┴───────────┴───────┴───────────────────┴───────┴──────── │ ┘\n```"}]}
{"messages": [{"role": "user", "content": "From Wikipedia:\n\n```\nThe McNuggets version of the coin problem was introduced by Henri Picciotto,\nwho included it in his algebra textbook co-authored with Anita Wah. Picciotto\nthought of the application in the 1980s while dining with his son at\nMcDonald's, working the problem out on a napkin. A McNugget number is\nthe total number of McDonald's Chicken McNuggets in any number of boxes.\nIn the United Kingdom, the original boxes (prior to the introduction of\nthe Happy Meal-sized nugget boxes) were of 6, 9, and 20 nuggets.\n\n```\n\nTask\n\nCalculate (from 0 up to a limit of 100) the largest non-McNuggets\nnumber (a number *n* which cannot be expressed with *6x + 9y + 20z = n*\nwhere *x*, *y* and *z* are natural numbers)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\nNo hard coded limits, no hard coded values. General purpose 3 value solver. Count values may be any 3 different positive integers, in any order, that are relatively prime.\n\nFinds the smallest count value, then looks for the first run of consecutive count totals able to be generated, that is at least the length of the smallest count size. From then on, every number can be generated by simply adding multiples of the minimum count to each of the totals in that run.\n\n```\nsub Mcnugget-number (*@counts) {\n\n    return '∞' if 1 < [gcd] @counts;\n\n    my $min = min @counts;\n    my @meals;\n    my @min;\n\n    for ^Inf -> $a {\n        for 0..$a -> $b {\n            for 0..$b -> $c {\n                ($a, $b, $c).permutations.map: { @meals[ sum $_ Z* @counts ] = True }\n            }\n        }\n        for @meals.grep: so *, :k {\n            if @min.tail and @min.tail + 1 == $_ {\n                @min.push: $_;\n                last if $min == +@min\n            } else {\n                @min = $_;\n            }\n        }\n        last if $min == +@min\n    }\n    @min[0] ?? @min[0] - 1 !! 0\n}\n\nfor (6,9,20), (6,7,20), (1,3,20), (10,5,18), (5,17,44), (2,4,6), (3,6,15) -> $counts {\n    put \"Maximum non-Mcnugget number using {$counts.join: ', '} is: \",\n        Mcnugget-number(|$counts)\n}\n\n```\n\nOutput:\n\n```\nMaximum non-Mcnugget number using 6, 9, 20 is: 43\nMaximum non-Mcnugget number using 6, 7, 20 is: 29\nMaximum non-Mcnugget number using 1, 3, 20 is: 0\nMaximum non-Mcnugget number using 10, 5, 18 is: 67\nMaximum non-Mcnugget number using 5, 17, 44 is: 131\nMaximum non-Mcnugget number using 2, 4, 6 is: ∞\nMaximum non-Mcnugget number using 3, 6, 15 is: ∞\n```"}]}
{"messages": [{"role": "user", "content": "Find the MD4 message digest of a string of octets.\nUse the ASCII encoded string “Rosetta Code” (without quotes).\nYou may either call an MD4 library, or implement MD4 in your language.\n\n**MD4** is an obsolete hash function that computes a 128-bit message digest that sometimes appears in obsolete protocols.\n\nRFC 1320 specifies the MD4 algorithm. RFC 6150 declares that MD4 is obsolete."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub md4($str) {\n    my buf8 $buf .= new: $str.encode;\n    my $buf-length = $buf.elems;\n    $buf.push: 0x80;\n    $buf.push: 0 until ($buf - (448 div 8)) %% (512 div 8);\n    # raku serializes in little endian by default\n    $buf.write-uint64: $buf.elems, $buf-length*8;\n\n    my (&f, &g, &h, &r) = \n      { $^x +& $^y +| +^$x +& $^z },\n      { $^x +& $^y +| $x +& $^z +| $y +& $z },\n      { $^x +^ $^y +^ $^z },\n      # for some reason we have to type v here\n      -> uint32 $v, $s { $v +< $s +| $v +> (32 - $s) }\n\n    my uint32 ($a, $b, $c, $d) = 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476;\n \n    loop (my $pos = 0; $pos < $buf.elems; $pos+=64) {\n        my ($aa, $bb, $cc, $dd) = $a, $b, $c, $d;\n        for 0, 4, 8, 12 -> $i {\n            $a = r($a + f($b, $c, $d) + $buf.read-uint32($pos+($i+0)*4),  3);\n            $d = r($d + f($a, $b, $c) + $buf.read-uint32($pos+($i+1)*4),  7);\n            $c = r($c + f($d, $a, $b) + $buf.read-uint32($pos+($i+2)*4), 11);\n            $b = r($b + f($c, $d, $a) + $buf.read-uint32($pos+($i+3)*4), 19);\n        }\n        for 0, 1, 2, 3 -> $i {\n            $a = r($a + g($b, $c, $d) + $buf.read-uint32($pos+($i+0 )*4) + 0x5a827999,  3);\n            $d = r($d + g($a, $b, $c) + $buf.read-uint32($pos+($i+4 )*4) + 0x5a827999,  5);\n            $c = r($c + g($d, $a, $b) + $buf.read-uint32($pos+($i+8 )*4) + 0x5a827999,  9);\n            $b = r($b + g($c, $d, $a) + $buf.read-uint32($pos+($i+12)*4) + 0x5a827999, 13);\n        }\n        for 0, 2, 1, 3 -> $i {\n            $a = r($a + h($b, $c, $d) + $buf.read-uint32($pos+($i+0 )*4) + 0x6ed9eba1,  3);\n            $d = r($d + h($a, $b, $c) + $buf.read-uint32($pos+($i+4 )*4) + 0x6ed9eba1,  9);\n            $c = r($c + h($d, $a, $b) + $buf.read-uint32($pos+($i+8 )*4) + 0x6ed9eba1, 11);\n            $b = r($b + h($c, $d, $a) + $buf.read-uint32($pos+($i+12)*4) + 0x6ed9eba1, 15);\n        }\n        ($a,$b,$c,$d) Z[+=] ($aa,$bb,$cc,$dd);\n    }\n \n    reduce { $^buf.write-uint32: $buf.elems, $^x; $buf }, buf8.new, $a, $b, $c, $d; \n}\n \nCHECK {\n  use Test;\n  plan 1;\n  is md4('Rosetta Code').list.fmt('%02X'), 'A5 2B CF C6 A0 D0 D3 00 CD C5 DD BF BE FE 47 8B';\n}\n\n```\n\nOutput:\n\n```\n1..1\nok 1 - \n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nEncode a string using an MD5 algorithm.   The algorithm can be found on   Wikipedia.\n\nOptionally, validate your implementation by running all of the test values in   IETF RFC (1321)   for MD5.\n\nAdditionally,   RFC 1321   provides more precise information on the algorithm than the Wikipedia article.\n\n|  |\n| --- |\n| **Warning:**   MD5 has known weaknesses, including **collisions** and forged signatures.   Users may consider a stronger alternative when doing production-grade cryptography, such as SHA-256 (from the SHA-2 family), or the upcoming SHA-3. |\n\nIf the solution on this page is a library solution, see   MD5/Implementation   for an implementation from scratch."}, {"role": "assistant", "content": "(formerly Perl 6)\nLibrary Digest::MD5\n\n```\nuse Digest::MD5;\nsay Digest::MD5.md5_hex: \"The quick brown fox jumped over the lazy dog's back\";\n\n```"}]}
{"messages": [{"role": "user", "content": "The purpose of this task to code and validate an implementation of the MD5 Message Digest Algorithm by coding the algorithm directly (not using a call to a built-in or external hashing library). For details of the algorithm refer to MD5 on Wikipedia or the MD5 definition in IETF RFC (1321).\n\n* The implementation needs to implement the key functionality namely producing a correct message digest for an input string. It is not necessary to mimic all of the calling modes such as adding to a digest one block at a time over subsequent calls.\n* In addition to coding and verifying your implementation, note any challenges your language presented implementing the solution, implementation choices made, or limitations of your solution.\n* Solutions on this page should implement MD5 directly and NOT use built in (MD5) functions, call outs to operating system calls or library routines written in other languages as is common in the original MD5 task.\n* The following are acceptable:\n  + An original implementation from the specification, reference implementation, or pseudo-code\n  + A translation of a correct implementation from another language\n  + A library routine in the same language; however, the source must be included here.\n\nThe solutions shown here will provide practical illustrations of bit manipulation, unsigned integers, working with little-endian data. Additionally, the task requires an attention to details such as boundary conditions since being out by even 1 bit will produce dramatically different results. Subtle implementation bugs can result in some hashes being correct while others are wrong. Not only is it critical to get the individual sub functions working correctly, even small errors in padding, endianness, or data layout will result in failure.\n\nThe following verification strings and hashes come from RFC 1321:\n\n```\n                            hash code <== string \n   0xd41d8cd98f00b204e9800998ecf8427e <== \"\"  \n   0x0cc175b9c0f1b6a831c399e269772661 <== \"a\"\n   0x900150983cd24fb0d6963f7d28e17f72 <== \"abc\"\n   0xf96b697d7cb7938d525a2f31aaf161d0 <== \"message digest\"\n   0xc3fcd3d76192e4007dfb496cca67e13b <== \"abcdefghijklmnopqrstuvwxyz\"\n   0xd174ab98d277d9f5a5611c2c9f419d9f <== \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\"\n   0x57edf4a22be3c955ac49da2e2107b67a <== \"12345678901234567890123456789012345678901234567890123456789012345678901234567890\"\n```\n\nIn addition, intermediate outputs to aid in developing an implementation can be found here.\n\nThe MD5 Message-Digest Algorithm was developed by RSA Data Security, Inc. in 1991.\n\n|  |\n| --- |\n| **Warning** Rosetta Code is **not** a place you should rely on for examples of code in critical roles, including security. Also, note that MD5 has been *broken* and should not be used in applications requiring security. For these consider SHA2 or the upcoming SHA3. |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2024-06\n\n```\nproto md5($msg) returns Blob is export {*}\nmulti md5(Str $msg) { md5 $msg.encode }\nmulti md5(Blob $msg) {\n  [~] map { buf8.new.write-uint32: 0, $_, LittleEndian },\n    |reduce -> Blob $blob, blob32 $X {\n      blob32.new: $blob Z+\n        reduce -> $b, $i {\n          blob32.new:\n            $b[3],\n            $b[1] +\n              -> uint32 \\x, \\n { (x +< n) +| (x +> (32-n)) }(\n              ($b[0] + (BEGIN Array.new:\n              { ($^x +& $^y) +| (+^$x +& $^z) },\n              { ($^x +& $^z) +| ($^y +& +^$z) },\n              { $^x +^ $^y +^ $^z },\n              { $^y +^ ($^x +| +^$^z) }\n              )[$i div 16](|$b[1..3]) +\n              (BEGIN blob32.new: map &floor ∘ * * 2**32 ∘ &abs ∘ &sin ∘ * + 1, ^64)[$i] +\n              $X[(BEGIN Blob.new: 16 X[R%] flat ($++, 5*$++ + 1, 3*$++ + 5, 7*$++) Xxx 16)[$i]]\n              ) mod 2**32,\n              (BEGIN flat < 7 12 17 22 5 9 14 20 4 11 16 23 6 10 15 21 >.rotor(4) Xxx 4)[$i]\n            ),\n            $b[1],\n            $b[2]\n        }, $blob, |^64;\n    },\n    (BEGIN blob32.new: 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476),\n    |map { blob32.new: @$_ },\n      {\n        $^b.push(blob8.new(@$_).read-uint32(0)) for (@$msg, 0x80, 0x00 xx (-($msg.elems + 1 + 8) % 64))\n            .flat.rotor(4);\n        $b.write-uint64: $b.elems, 8*$msg.elems, LittleEndian;\n        $b;\n      }(buf32.new)\n    .rotor(16);\n}\n\nCHECK {\n  use Test;\n\n  for 'd41d8cd98f00b204e9800998ecf8427e', '',\n      '0cc175b9c0f1b6a831c399e269772661', 'a',\n      '900150983cd24fb0d6963f7d28e17f72', 'abc',\n      'f96b697d7cb7938d525a2f31aaf161d0', 'message digest',\n      'c3fcd3d76192e4007dfb496cca67e13b', 'abcdefghijklmnopqrstuvwxyz',\n      'd174ab98d277d9f5a5611c2c9f419d9f', 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',\n      '57edf4a22be3c955ac49da2e2107b67a', '12345678901234567890123456789012345678901234567890123456789012345678901234567890'\n        -> $expected, $msg {\n          my $digest = md5($msg).list».fmt('%02x').join;\n          is($digest, $expected, \"$digest is MD5 digest of '$msg'\");\n        }\n  done-testing;\n}\n\n```\n\nOutput:\n\n```\n1..7\nok 1 - d41d8cd98f00b204e9800998ecf8427e is MD5 digest of ''\nok 2 - 0cc175b9c0f1b6a831c399e269772661 is MD5 digest of 'a'\nok 3 - 900150983cd24fb0d6963f7d28e17f72 is MD5 digest of 'abc'\nok 4 - f96b697d7cb7938d525a2f31aaf161d0 is MD5 digest of 'message digest'\nok 5 - c3fcd3d76192e4007dfb496cca67e13b is MD5 digest of 'abcdefghijklmnopqrstuvwxyz'\nok 6 - d174ab98d277d9f5a5611c2c9f419d9f is MD5 digest of 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'\nok 7 - 57edf4a22be3c955ac49da2e2107b67a is MD5 digest of '12345678901234567890123456789012345678901234567890123456789012345678901234567890'\n```"}]}
{"messages": [{"role": "user", "content": "The median filter takes in the neighbourhood the median color (see Median filter)\n\n*(to test the function below, you can use these input and output solutions)*"}, {"role": "assistant", "content": "(formerly Perl 6)\nClone of Perl 5, for now.\n\n```\nuse PDL:from<Perl5>;\nuse PDL::Image2D:from<Perl5>;\n\nmy $image = rpic 'plasma.png';\nmy $smoothed = med2d($image, ones(3,3), {Boundary => 'Truncate'});\nwpic $smoothed, 'plasma_median.png';\n\n```\n\nCompare offsite images: plasma.png vs.\nplasma\\_median.png"}]}
{"messages": [{"role": "user", "content": "Task\n\nCalculate Meissel–Mertens constant up to a precision your language can handle.\n\nMotivation\n\nAnalogous to Euler's constant, which is important in determining the sum of reciprocal natural numbers, Meissel-Mertens' constant is important in calculating the sum of reciprocal primes.\n\nExample\n\nWe consider the finite sum of reciprocal natural numbers:\n\n*1 + 1/2 + 1/3 + 1/4 + 1/5 ... 1/n*\n\nthis sum can be well approximated with:\n\n*log(n) + E*\n\nwhere *E* denotes Euler's constant: 0.57721...\n\n*log(n)* denotes the natural logarithm of *n*.\n\nNow consider the finite sum of reciprocal primes:\n\n*1/2 + 1/3 + 1/5 + 1/7 + 1/11 ... 1/p*\n\nthis sum can be well approximated with:\n\n*log( log(p) ) + M*\n\nwhere *M* denotes Meissel-Mertens constant: 0.26149...\n\nSee\n:   * Details in the Wikipedia article:  Meissel–Mertens constant"}, {"role": "assistant", "content": "**Translation of**: FreeBASIC\n\n```\n# 20221011 Raku programming solution\n\nmy $s;\n.is-prime and $s += log(1-1/$_)+1/$_ for 2 .. 10**8;\nsay $s + .57721566490153286\n\n```\n\nOutput:\n\n```\n0.26149721310571383\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow how to explicitly allocate and deallocate blocks of memory in your language.\n\nShow access to different types of memory (i.e., heap, stack, shared, foreign) if applicable."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nLike Perl 5, Raku is intended to run largely stackless, so all allocations are really on the heap, including activation records. Allocations are managed automatically. It is easy enough to allocate a memory buffer of a particular size however, if you really need it:\n\n```\nmy $buffer = Buf.new(0 xx 1024);\n\n```"}]}
{"messages": [{"role": "user", "content": "It is often useful to control the memory layout of fields in a data structure to match an interface control definition, or to interface with hardware. Define a data structure matching the RS-232 Plug Definition. Use the 9-pin definition for brevity.\n\n```\nPin Settings for Plug\n(Reverse order for socket.)\n__________________________________________\n1  2  3  4  5  6  7  8  9  10 11 12 13\n 14 15 16 17 18 19 20 21 22 23 24 25\n_________________\n1  2  3  4  5\n6  7  8  9\n25 pin                        9 pin\n1 - PG   Protective ground\n2 - TD   Transmitted data     3\n3 - RD   Received data        2\n4 - RTS  Request to send      7\n5 - CTS  Clear to send        8\n6 - DSR  Data set ready       6\n7 - SG   Signal ground        5\n8 - CD   Carrier detect       1\n9 - + voltage (testing)\n10 - - voltage (testing)\n11 -\n12 - SCD  Secondary CD\n13 - SCS  Secondary CTS\n14 - STD  Secondary TD\n15 - TC   Transmit clock\n16 - SRD  Secondary RD\n17 - RC   Receiver clock\n18 -\n19 - SRS  Secondary RTS            \n20 - DTR  Data terminal ready      4\n21 - SQD  Signal quality detector\n22 - RI   Ring indicator           9\n23 - DRS  Data rate select\n24 - XTC  External clock\n25 -\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\nThe following is specced to work, but implementation of shaped arrays is not quite complete.\n\n```\nenum T_RS232 <\n    carrier_detect\n    received_data\n    transmitted_data\n    data_terminal_ready\n    signal_ground\n    data_set_ready\n    request_to_send\n    clear_to_send\n    ring_indicator\n>;\n\nmy bit @signal[T_RS232];\n\n@signal[signal_ground] = 1;\n\n```\n\nIn the absence of shaped arrays, you can do the usual bit-twiddling tricks on a native integer of sufficient size. (Such an integer could presumably be mapped directly to a device register.)\n\n```\n$signal +|= 1 +< signal_ground;\n\n```\n\nUsing a native int is likelier to work on a big-endian machine in any case. Another almost-there solution is the mapping of C representational types into Raku for native interfaces, but it does not yet support bit fields."}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a prompt and a list containing a number of strings of which one is to be selected, create a function that:\n\n* prints a textual menu formatted as an index value followed by its corresponding string for each item in the list;\n* prompts the user to enter a number;\n* returns the string corresponding to the selected index number.\n\nThe function should reject input that is not an integer or is out of range by redisplaying the whole menu before asking again for a number. The function should return an empty string if called with an empty list.\n\nFor test purposes use the following four phrases in a list:\n\n```\n   fee fie\n   huff and puff\n   mirror mirror\n   tick tock\n\n```\n\nNote\n\nThis task is fashioned after the action of the Bash select statement."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub menu ( $prompt, @items ) {\n    return '' unless @items.elems;\n    repeat until my $selection ~~ /^ \\d+ $/ && @items[--$selection] {\n        my $i = 1;\n        say \"  {$i++}) $_\" for @items;\n        $selection = prompt $prompt;\n    }\n    return @items[$selection];\n}\n\nmy @choices = 'fee fie', 'huff and puff', 'mirror mirror', 'tick tock';\nmy $prompt = 'Enter the number corresponding to your selection: ';\n\nmy $answer = menu( $prompt, [] );\nsay \"You chose: $answer\" if $answer.chars;\n\n$answer = menu( $prompt, @choices );\nsay \"You chose: $answer\" if $answer.chars;\n\n```"}]}
{"messages": [{"role": "user", "content": "Merge and aggregate datasets\n\nTask\n\nMerge and aggregate two datasets as provided in   **.csv**   files into a new resulting dataset.\n\nUse the appropriate methods and data structures depending on the programming language.\n\nUse the most common libraries only when built-in functionality is not sufficient.\n\nNote\n\nEither load the data from the   **.csv**   files or create the required data structures hard-coded.\n\n**patients.csv**   file contents:\n\n```\nPATIENT_ID,LASTNAME\n1001,Hopper\n4004,Wirth\n3003,Kemeny\n2002,Gosling\n5005,Kurtz\n\n```\n\n**visits.csv**   file contents:\n\n```\nPATIENT_ID,VISIT_DATE,SCORE\n2002,2020-09-10,6.8\n1001,2020-09-17,5.5\n4004,2020-09-24,8.4\n2002,2020-10-08,\n1001,,6.6\n3003,2020-11-12,\n4004,2020-11-05,7.0\n1001,2020-11-19,5.3\n\n```\n\nCreate a resulting dataset in-memory or output it to screen or file, whichever is appropriate for the programming language at hand.\n\nMerge and group per patient id and last name,   get the maximum visit date,   and get the sum and average of the scores per patient to get the resulting dataset.\n\nNote that the visit date is purposefully provided as ISO format,   so that it could also be processed as text and sorted alphabetically to determine the maximum date.\n\n```\n| PATIENT_ID | LASTNAME | LAST_VISIT |  SCORE_SUM | SCORE_AVG |\n| 1001       |  Hopper  | 2020-11-19 |  17.4      | 5.80      |\n| 2002       |  Gosling | 2020-10-08 |   6.8      | 6.80      |\n| 3003       |  Kemeny  | 2020-11-12 |            |           |\n| 4004       |  Wirth   | 2020-11-05 |  15.4      | 7.70      |\n| 5005       |  Kurtz   |            |            |           |\n\n```\n\nNote\n\nThis task is aimed in particular at programming languages that are used in data science and data processing, such as F#, Python, R, SPSS, MATLAB etc.\n\nRelated tasks\n\n* CSV data manipulation\n* CSV to HTML translation\n* Read entire file\n* Read a file line by line"}, {"role": "assistant", "content": "```\nmy @names = map { ( <PATIENT_ID LASTNAME> Z=> .list ).hash },\n    ( 1001, 'Hopper'  ),\n    ( 4004, 'Wirth'   ),\n    ( 3003, 'Kemeny'  ),\n    ( 2002, 'Gosling' ),\n    ( 5005, 'Kurtz'   ),\n;\nmy @visits = map { ( <PATIENT_ID VISIT_DATE SCORE> Z=> .list ).hash },\n    ( 2002, '2020-09-10', 6.8 ),\n    ( 1001, '2020-09-17', 5.5 ),\n    ( 4004, '2020-09-24', 8.4 ),\n    ( 2002, '2020-10-08', Nil ),\n    ( 1001,         Nil , 6.6 ),\n    ( 3003, '2020-11-12', Nil ),\n    ( 4004, '2020-11-05', 7.0 ),\n    ( 1001, '2020-11-19', 5.3 ),\n;\n\nmy %v = @visits.classify: *.<PATIENT_ID>;\n\nmy @result = gather for @names -> %n {\n    my @p = %v{ %n.<PATIENT_ID> }<>;\n\n    my @dates  = @p».<VISIT_DATE>.grep: *.defined;\n    my @scores = @p».<     SCORE>.grep: *.defined;\n\n    take {\n        %n,\n        LAST_VISIT => ( @dates.max          if @dates  ),\n        SCORE_AVG  => ( @scores.sum/@scores if @scores ),\n        SCORE_SUM  => ( @scores.sum         if @scores ),\n    };\n}\n\nmy @out_field_names = <PATIENT_ID LASTNAME LAST_VISIT SCORE_SUM SCORE_AVG>;\nmy @rows = @result.sort(*.<PATIENT_ID>).map(*.{@out_field_names});\nsay .map({$_ // ''}).fmt('%-10s', ' | ') for @out_field_names, |@rows;\n\n```\n\nOutput:\n\n```\nPATIENT_ID | LASTNAME   | LAST_VISIT | SCORE_SUM  | SCORE_AVG \n1001       | Hopper     | 2020-11-19 | 17.4       | 5.8       \n2002       | Gosling    | 2020-10-08 | 6.8        | 6.8       \n3003       | Kemeny     | 2020-11-12 |            |           \n4004       | Wirth      | 2020-11-05 | 15.4       | 7.7       \n5005       | Kurtz      |            |            |           \n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate code that will list (preferably calculate) all of the   *Mersenne primes*   until some limitation is reached.\n\nThe number of   *known*   Mersenne primes is   **51**   (as of June, 2020),   and the largest known Mersenne prime contains contains   **24,862,048**   decimal digits.\n\nAlso see\n\n* the Wikipedia entry:   Mersenne prime.\n* the MathWorld entry;   Mersenne prime.\n* For a list of all the know Mersenne primes:   [https://primes.utm.edu/mersenne/index.html#known list of Mersenne\n* For a general website about primes: prime pages.\n* the OEIS entry: Mersenne primes.\n* the OEIS entry: A000043 Mersenne exponents: primes p such that 2^p - 1 is prime. Then 2^p - 1 is called a Mersenne prime."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.01\n\nWe already have a multitude of tasks that demonstrate **how** to find Mersenne primes; Prime decomposition, Primality by trial division, Trial factoring of a Mersenne number, Lucas-Lehmer test, Miller–Rabin primality\\_test, etc. that all have Raku entries. I'm not sure what I could add here that would be useful.\n\nHmmm.\n\n> *Create code that will list all of the Mersenne primes until some limitation is reached.*\n\nIt doesn't specify to *calculate* them, only to *list* them; why throw away all of the computer **millenia** of processing power that the GIMPS has invested?\n\n```\nuse HTTP::UserAgent;\nuse Gumbo;\n\nmy $table = parse-html(HTTP::UserAgent.new.get('https://www.mersenne.org/primes/').content, :TAG<table>);\n\nsay 'All known Mersenne primes as of ', Date(now);\n\nsay 'M', ++$, \": 2$_ - 1\"\n  for $table[1]».[*][0][*].comb(/'perfect'\\d+/)».subst(/\\D/, '',:g)\n  .trans([<0123456789>.comb] => [<⁰¹²³⁴⁵⁶⁷⁸⁹>.comb]).words;\n\n```\n\nOutput:\n\n```\nAll known Mersenne primes as of 2024-11-07\nM1: 2² - 1\nM2: 2³ - 1\nM3: 2⁵ - 1\nM4: 2⁷ - 1\nM5: 2¹³ - 1\nM6: 2¹⁷ - 1\nM7: 2¹⁹ - 1\nM8: 2³¹ - 1\nM9: 2⁶¹ - 1\nM10: 2⁸⁹ - 1\nM11: 2¹⁰⁷ - 1\nM12: 2¹²⁷ - 1\nM13: 2⁵²¹ - 1\nM14: 2⁶⁰⁷ - 1\nM15: 2¹²⁷⁹ - 1\nM16: 2²²⁰³ - 1\nM17: 2²²⁸¹ - 1\nM18: 2³²¹⁷ - 1\nM19: 2⁴²⁵³ - 1\nM20: 2⁴⁴²³ - 1\nM21: 2⁹⁶⁸⁹ - 1\nM22: 2⁹⁹⁴¹ - 1\nM23: 2¹¹²¹³ - 1\nM24: 2¹⁹⁹³⁷ - 1\nM25: 2²¹⁷⁰¹ - 1\nM26: 2²³²⁰⁹ - 1\nM27: 2⁴⁴⁴⁹⁷ - 1\nM28: 2⁸⁶²⁴³ - 1\nM29: 2¹¹⁰⁵⁰³ - 1\nM30: 2¹³²⁰⁴⁹ - 1\nM31: 2²¹⁶⁰⁹¹ - 1\nM32: 2⁷⁵⁶⁸³⁹ - 1\nM33: 2⁸⁵⁹⁴³³ - 1\nM34: 2¹²⁵⁷⁷⁸⁷ - 1\nM35: 2¹³⁹⁸²⁶⁹ - 1\nM36: 2²⁹⁷⁶²²¹ - 1\nM37: 2³⁰²¹³⁷⁷ - 1\nM38: 2⁶⁹⁷²⁵⁹³ - 1\nM39: 2¹³⁴⁶⁶⁹¹⁷ - 1\nM40: 2²⁰⁹⁹⁶⁰¹¹ - 1\nM41: 2²⁴⁰³⁶⁵⁸³ - 1\nM42: 2²⁵⁹⁶⁴⁹⁵¹ - 1\nM43: 2³⁰⁴⁰²⁴⁵⁷ - 1\nM44: 2³²⁵⁸²⁶⁵⁷ - 1\nM45: 2³⁷¹⁵⁶⁶⁶⁷ - 1\nM46: 2⁴²⁶⁴³⁸⁰¹ - 1\nM47: 2⁴³¹¹²⁶⁰⁹ - 1\nM48: 2⁵⁷⁸⁸⁵¹⁶¹ - 1\nM49: 2⁷⁴²⁰⁷²⁸¹ - 1\nM50: 2⁷⁷²³²⁹¹⁷ - 1\nM51: 2⁸²⁵⁸⁹⁹³³ - 1\nM52: 2¹³⁶²⁷⁹⁸⁴¹ - 1\n```"}]}
{"messages": [{"role": "user", "content": "The Mertens function **M(x)** is the **count** of **square-free integers** up to **x** that have an **even number** of prime factors, **minus** the **count** of those that have an **odd number**.\n\nIt is an extension of the Möbius function. Given the Möbius function **μ(n)**, the Mertens function **M(x)** is the sum of the Möbius numbers from **n == 1** through **n == x**.\n\nTask\n\n:   * Write a routine (function, procedure, whatever) to find the Mertens number for any positive integer **x**.\n\n:   * Use that routine to find and display here, on this page, at least the first 99 terms in a grid layout. (Not just one long line or column of numbers.)\n\n:   * Use that routine to find and display here, on this page, the number of times the Mertens function sequence **is equal to zero** in the range **M(1)** through **M(1000)**.\n\n:   * Use that routine to find and display here, on this page, the number of times the Mertens function sequence **crosses zero** in the range **M(1)** through **M(1000)**. (Crossing defined as this term equal to zero but preceding term **not**.)\n\nSee also\n:   * Wikipedia: Mertens function\n    * Wikipedia: Möbius function\n    * OEIS: A002321 - Mertens's function\n    * OEIS: A028442 - Numbers n such that Mertens's function M(n) is zero\n    * Numberphile - Mertens Conjecture\n    * Stackexchange: compute the mertens function\n\n*This is not code golf.   The stackexchange link is provided as an algorithm reference, not as a guide.*\n\nRelated tasks\n:   * Möbius function"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\nMertens number is not defined for n == 0. Raku arrays are indexed from 0 so store a blank value at position zero to keep x and M(x) aligned.\n\n```\nuse Prime::Factor;\n\nsub μ (Int \\n) {\n    return 0 if n %% 4 or n %% 9 or n %% 25 or n %% 49 or n %% 121;\n    my @p = prime-factors(n);\n    +@p == +@p.unique ?? +@p %% 2 ?? 1 !! -1 !! 0\n}\n\nmy @mertens = lazy [\\+] flat '', 1, (2..*).hyper.map: -> \\n { μ(n) };\n\nput \"Mertens sequence - First 199 terms:\\n\",\n    @mertens[^200]».fmt('%3s').batch(20).join(\"\\n\"),\n    \"\\n\\nEquals zero \", +@mertens[1..1000].grep( !* ),\n    ' times between 1 and 1000', \"\\n\\nCrosses zero \",\n    +@mertens[1..1000].kv.grep( {!$^v and @mertens[$^k]} ),\n    \" times between 1 and 1000\\n\\nFirst Mertens equal to:\";\n\nfor 10, 20, 30 … 100 -> $threshold {\n    printf \"%4d: M(%d)\\n\", -$threshold, @mertens.first: * == -$threshold, :k;\n    printf \"%4d: M(%d)\\n\",  $threshold, @mertens.first: * ==  $threshold, :k;\n}\n\n```\n\nOutput:\n\n```\nMertens sequence - First 199 terms:\n      1   0  -1  -1  -2  -1  -2  -2  -2  -1  -2  -2  -3  -2  -1  -1  -2  -2  -3\n -3  -2  -1  -2  -2  -2  -1  -1  -1  -2  -3  -4  -4  -3  -2  -1  -1  -2  -1   0\n  0  -1  -2  -3  -3  -3  -2  -3  -3  -3  -3  -2  -2  -3  -3  -2  -2  -1   0  -1\n -1  -2  -1  -1  -1   0  -1  -2  -2  -1  -2  -3  -3  -4  -3  -3  -3  -2  -3  -4\n -4  -4  -3  -4  -4  -3  -2  -1  -1  -2  -2  -1  -1   0   1   2   2   1   1   1\n  1   0  -1  -2  -2  -3  -2  -3  -3  -4  -5  -4  -4  -5  -6  -5  -5  -5  -4  -3\n -3  -3  -2  -1  -1  -1  -1  -2  -2  -1  -2  -3  -3  -2  -1  -1  -1  -2  -3  -4\n -4  -3  -2  -1  -1   0   1   1   1   0   0  -1  -1  -1  -2  -1  -1  -2  -1   0\n  0   1   1   0   0  -1   0  -1  -1  -1  -2  -2  -2  -3  -4  -4  -4  -3  -2  -3\n -3  -4  -5  -4  -4  -3  -4  -3  -3  -3  -4  -5  -5  -6  -5  -6  -6  -7  -7  -8\n\nEquals zero 92 times between 1 and 1000\n\nCrosses zero 59 times between 1 and 1000\n\nFirst Mertens equal to:\n -10: M(659)\n  10: M(1393)\n -20: M(2791)\n  20: M(3277)\n -30: M(9717)\n  30: M(8503)\n -40: M(9831)\n  40: M(11770)\n -50: M(24018)\n  50: M(19119)\n -60: M(24105)\n  60: M(31841)\n -70: M(24170)\n  70: M(31962)\n -80: M(42789)\n  80: M(48202)\n -90: M(59026)\n  90: M(48405)\n-100: M(59426)\n 100: M(114717)\n```"}]}
{"messages": [{"role": "user", "content": "Many people have heard of the **Golden ratio**, phi (**φ**). Phi is just one of a series\nof related ratios that are referred to as the \"**Metallic ratios**\".\n\nThe **Golden ratio** was discovered and named by ancient civilizations as it was\nthought to be the most pure and beautiful (like Gold). The **Silver ratio** was was\nalso known to the early Greeks, though was not named so until later as a nod to\nthe **Golden ratio** to which it is closely related. The series has been extended to\nencompass all of the related ratios and was given the general name **Metallic ratios** (or *Metallic means*).\n*Somewhat incongruously as the original Golden ratio referred to the adjective \"golden\" rather than the metal \"gold\".*\n\n**Metallic ratios** are the real roots of the general form equation:\n\n```\n         x2 - bx - 1 = 0 \n\n```\n\nwhere the integer **b** determines which specific one it is.\n\nUsing the quadratic equation:\n\n```\n         ( -b ± √(b2 - 4ac) ) / 2a = x \n\n```\n\nSubstitute in (from the top equation) **1** for **a**, **-1** for **c**, and recognising that -b is negated we get:\n\n```\n         ( b ± √(b2 + 4) ) ) / 2 = x \n\n```\n\nWe only want the real root:\n\n```\n         ( b + √(b2 + 4) ) ) / 2 = x \n\n```\n\nWhen we set **b** to **1**, we get an irrational number: the **Golden ratio**.\n\n```\n         ( 1 + √(12 + 4) ) / 2  =  (1 + √5) / 2 = ~1.618033989... \n\n```\n\nWith **b** set to **2**, we get a different irrational number: the **Silver ratio**.\n\n```\n         ( 2 + √(22 + 4) ) / 2  =  (2 + √8) / 2 = ~2.414213562... \n\n```\n\nWhen the ratio **b** is **3**, it is commonly referred to as the **Bronze** ratio, **4** and **5**\nare sometimes called the **Copper** and **Nickel** ratios, though they aren't as\nstandard. After that there isn't really any attempt at standardized names. They\nare given names here on this page, but consider the names fanciful rather than\ncanonical.\n\nNote that technically, **b** can be **0** for a \"smaller\" ratio than the **Golden ratio**.\nWe will refer to it here as the **Platinum ratio**, though it is kind-of a\ndegenerate case.\n\n**Metallic ratios** where **b** > **0** are also defined by the irrational continued fractions:\n\n```\n         [b;b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b...] \n\n```\n\nSo, The first ten **Metallic ratios** are:\n\n:   :   :   :   :   :   Metallic ratios\n\n                        | Name | **b** | Equation | Value | Continued fraction | OEIS link |\n                        | --- | --- | --- | --- | --- | --- |\n                        | Platinum | 0 | (0 + √4) / 2 | 1 | - | - |\n                        | Golden | 1 | (1 + √5) / 2 | 1.618033988749895... | [1;1,1,1,1,1,1,1,1,1,1...] | OEIS:A001622 |\n                        | Silver | 2 | (2 + √8) / 2 | 2.414213562373095... | [2;2,2,2,2,2,2,2,2,2,2...] | OEIS:A014176 |\n                        | Bronze | 3 | (3 + √13) / 2 | 3.302775637731995... | [3;3,3,3,3,3,3,3,3,3,3...] | OEIS:A098316 |\n                        | Copper | 4 | (4 + √20) / 2 | 4.23606797749979... | [4;4,4,4,4,4,4,4,4,4,4...] | OEIS:A098317 |\n                        | Nickel | 5 | (5 + √29) / 2 | 5.192582403567252... | [5;5,5,5,5,5,5,5,5,5,5...] | OEIS:A098318 |\n                        | Aluminum | 6 | (6 + √40) / 2 | 6.16227766016838... | [6;6,6,6,6,6,6,6,6,6,6...] | OEIS:A176398 |\n                        | Iron | 7 | (7 + √53) / 2 | 7.140054944640259... | [7;7,7,7,7,7,7,7,7,7,7...] | OEIS:A176439 |\n                        | Tin | 8 | (8 + √68) / 2 | 8.123105625617661... | [8;8,8,8,8,8,8,8,8,8,8...] | OEIS:A176458 |\n                        | Lead | 9 | (9 + √85) / 2 | 9.109772228646444... | [9;9,9,9,9,9,9,9,9,9,9...] | OEIS:A176522 |\n\n---\n\nThere are other ways to find the **Metallic ratios**; one, (the focus of this task)\nis through **successive approximations of Lucas sequences**.\n\nA traditional **Lucas sequence** is of the form:\n\n```\n   xn = P * xn-1 - Q * xn-2\n\n```\n\nand starts with the first 2 values **0, 1**.\n\nFor our purposes in this task, to find the metallic ratios we'll use the form:\n\n```\n   xn = b * xn-1 + xn-2\n\n```\n\n( **P** is set to **b** and **Q** is set to **-1**. ) To avoid \"divide by zero\" issues we'll start the sequence with the first two terms **1, 1**. The initial starting value has very little effect on the final ratio or convergence rate. *Perhaps it would be more accurate to call it a Lucas-like sequence.*\n\nAt any rate, when **b = 1** we get:\n\n```\n   xn = xn-1 + xn-2\n\n```\n\n```\n   1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144...\n\n```\n\nmore commonly known as the Fibonacci sequence.\n\nWhen **b = 2**:\n\n```\n   xn = 2 * xn-1 + xn-2\n\n```\n\n```\n   1, 1, 3, 7, 17, 41, 99, 239, 577, 1393...\n\n```\n\nAnd so on.\n\nTo find the ratio by successive approximations, divide the (**n+1**)th term by the\n**n**th. As **n** grows larger, the ratio will approach the **b** metallic ratio.\n\nFor **b = 1** (Fibonacci sequence):\n\n```\n   1/1   = 1\n   2/1   = 2\n   3/2   = 1.5\n   5/3   = 1.666667\n   8/5   = 1.6\n   13/8  = 1.625\n   21/13 = 1.615385\n   34/21 = 1.619048\n   55/34 = 1.617647\n   89/55 = 1.618182\n   etc.\n\n```\n\nIt converges, but pretty slowly. In fact, the **Golden ratio** has the slowest\npossible convergence for any irrational number.\n\nTask\n\nFor each of the first **10 Metallic ratios**; **b** = **0** through **9**:\n\n* Generate the corresponding \"Lucas\" sequence.\n* Show here, on this page, at least the first **15** elements of the \"Lucas\" sequence.\n* Using successive approximations, calculate the value of the ratio accurate to **32** decimal places.\n* Show the **value** of the **approximation** at the required accuracy.\n* Show the **value** of **n** when the approximation reaches the required accuracy (How many iterations did it take?).\n\nOptional, stretch goal - Show the **value** and number of iterations **n**, to approximate the **Golden ratio** to **256** decimal places.\n\nYou may assume that the approximation has been reached when the next iteration does not cause the value (to the desired places) to change.\n\nSee also\n\n* Wikipedia: Metallic mean\n* Wikipedia: Lucas sequence"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nNote: Arrays, Lists and Sequences are zero indexed in Raku.\n\n```\nuse Rat::Precise;\nuse Lingua::EN::Numbers;\n\nsub lucas ($b) { 1, 1, * + $b * * … * }\n\nsub metallic ($seq, $places = 32) {\n    my $n = 0;\n    my $last = 0;\n    loop {\n        my $approx = FatRat.new($seq[$n + 1], $seq[$n]);\n        my $this = $approx.precise($places, :z);\n        last if $this eq $last;\n        $last = $this;\n        $n++;\n    }\n    $last, $n\n}\n\nsub display ($value, $n) {\n    \"Approximated value:\", $value, \"Reached after {$n} iterations: \" ~\n    \"{ordinal-digit $n}/{ordinal-digit $n - 1} element.\"\n}\n\nfor <Platinum Golden Silver Bronze Copper Nickel Aluminum Iron Tin Lead>.kv\n  -> \\b, $name {\n    my $lucas = lucas b;\n    print \"\\nLucas sequence for $name ratio; where b = {b}:\\nFirst 15 elements: \";\n    say join ', ', $lucas[^15];\n    say join ' ', display |metallic($lucas);\n}\n\n# Stretch goal\nsay join \"\\n\", \"\\nGolden ratio to 256 decimal places:\", display |metallic lucas(1), 256;\n\n```\n\nOutput:\n\n```\nLucas sequence for Platinum ratio; where b = 0:\nFirst 15 elements: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1\nApproximated value: 1.00000000000000000000000000000000 Reached after 1 iterations: 1st/0th element.\n\nLucas sequence for Golden ratio; where b = 1:\nFirst 15 elements: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610\nApproximated value: 1.61803398874989484820458683436564 Reached after 78 iterations: 78th/77th element.\n\nLucas sequence for Silver ratio; where b = 2:\nFirst 15 elements: 1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243\nApproximated value: 2.41421356237309504880168872420970 Reached after 44 iterations: 44th/43rd element.\n\nLucas sequence for Bronze ratio; where b = 3:\nFirst 15 elements: 1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564\nApproximated value: 3.30277563773199464655961063373525 Reached after 34 iterations: 34th/33rd element.\n\nLucas sequence for Copper ratio; where b = 4:\nFirst 15 elements: 1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169, 165580141\nApproximated value: 4.23606797749978969640917366873128 Reached after 28 iterations: 28th/27th element.\n\nLucas sequence for Nickel ratio; where b = 5:\nFirst 15 elements: 1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681, 2294335686\nApproximated value: 5.19258240356725201562535524577016 Reached after 25 iterations: 25th/24th element.\n\nLucas sequence for Aluminum ratio; where b = 6:\nFirst 15 elements: 1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337, 20924619775\nApproximated value: 6.16227766016837933199889354443272 Reached after 23 iterations: 23rd/22nd element.\n\nLucas sequence for Iron ratio; where b = 7:\nFirst 15 elements: 1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201, 140155324408\nApproximated value: 7.14005494464025913554865124576352 Reached after 22 iterations: 22nd/21st element.\n\nLucas sequence for Tin ratio; where b = 8:\nFirst 15 elements: 1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001, 741780739449\nApproximated value: 8.12310562561766054982140985597408 Reached after 20 iterations: 20th/19th element.\n\nLucas sequence for Lead ratio; where b = 9:\nFirst 15 elements: 1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049, 3263094477226\nApproximated value: 9.10977222864644365500113714088140 Reached after 20 iterations: 20th/19th element.\n\nGolden ratio to 256 decimal places:\nApproximated value:\n1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144\nReached after 615 iterations: 615th/614th element.\n```"}]}
{"messages": [{"role": "user", "content": "Name and briefly demonstrate any support your language has for metaprogramming. Your demonstration may take the form of cross-references to other tasks on Rosetta Code. When possible, provide links to relevant documentation.\n\nFor the purposes of this task, \"support for metaprogramming\" means any way the user can effectively modify the language's syntax that's built into the language (like Lisp macros) or that's conventionally used with the language (like the C preprocessor). Such facilities need not be very powerful: even user-defined infix operators count. On the other hand, in general, neither operator overloading nor `eval` count. The task author acknowledges that what qualifies as metaprogramming is largely a judgment call."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku makes it very easy to do metaprogramming. It is a basic goal of the language.\n\nIt is trivial to add a new operator. Most Raku operators are written as normal multiple-dispatch functions in the setting (known as a \"prelude\" in other languages, but in Raku the setting is a lexical scope notionally surrounding your compilation unit).\n\nThere is no a built in factorial operator Raku. It was purposely left out to use as a demonstration of how easy it is to add it. :-)\n\n```\nsub postfix:<!> { [*] 1..$^n }\nsay 5!;  # prints 120\n\n```\n\nYou may augment a base class with a new method, as long as you declare that you are going to cheat.\n\nHere we add a new method to do natural sorting to the base class Any. (List and Array are both subclasses of Any)\n\n```\nuse MONKEY-TYPING; # Needed to do runtime augmentation of a base class.\n\naugment class List {\n    method nsort { self.list.sort: {$^a.lc.subst(/(\\d+)/, -> $/ {0 ~ $0.chars.chr ~ $0 }, :g) ~ \"\\x0\" ~ $^a} }\n};\n\nsay ~<a201st a32nd a3rd a144th a17th a2 a95>.nsort;\nsay ~<a201st a32nd a3rd a144th a17th a2 a95>.sort;\n\n```\n\nPrints\n\n```\na2 a3rd a17th a32nd a95 a144th a201st\na144th a17th a2 a201st a32nd a3rd a95\n```\n\nGrammar mixins work in Raku because grammar rules are just methods in grammar classes, and Raku automatically writes a JIT lexer for you whenever you derive a new language. This functionality already works internally in the standard parser—what is not yet implemented is the augment slang hook to allow user code to do this mixin. Raku itself is already parsed using such grammar mixins to provide extensible quoting and regex syntax. For example, every time you pick your own quote characters, you're actually deriving a new Raku dialect that supports those start and stop characters. Likewise any switches to impose single or double-quote semantics, or heredoc semantics, is merely a grammar mixin on the basic Q language.\n\n```\nsay \"Foo = $foo\\n\";  # normal double quotes\nsay Q:qq 【Foo = $foo\\n】; # a more explicit derivation, new quotes\n\n```"}]}
{"messages": [{"role": "user", "content": "The goal of this task is to create a counting semaphore used to control the execution of a set of concurrent units. This task intends to demonstrate coordination of active concurrent units through the use of a passive concurrent unit. The operations for a counting semaphore are *acquire*, *release*, and *count*. Each active concurrent unit should attempt to acquire the counting semaphore before executing its assigned duties. In this case the active concurrent unit should report that it has acquired the semaphore. It should sleep for 2 seconds and then release the semaphore."}, {"role": "assistant", "content": "(formerly Perl 6)\nUses a buffered channel to hand out a limited number of tickets.\n\n```\nclass Semaphore {\n    has $.tickets = Channel.new;\n    method new ($max) {\n        my $s = self.bless; \n        $s.tickets.send(True) xx $max;\n        $s;\n    }\n    method acquire { $.tickets.receive }\n    method release { $.tickets.send(True) }\n}\n\nsub MAIN ($units = 5, $max = 2) {\n    my $sem = Semaphore.new($max);\n\n    my @units = do for ^$units -> $u {\n        start {\n            $sem.acquire; say \"unit $u acquired\";\n            sleep 2;\n            $sem.release; say \"unit $u released\";\n        }\n    }\n    await @units;\n}\n\n```\n\nOutput:\n\n```\nunit 0 acquired\nunit 1 acquired\nunit 0 released\nunit 1 released\nunit 3 acquired\nunit 2 acquired\nunit 3 released\nunit 2 released\nunit 4 acquired\nunit 4 released\n```"}]}
{"messages": [{"role": "user", "content": "The task is to implement a   metronome.\n\nThe metronome should be capable of producing high and low audio beats, accompanied by a visual beat indicator, and the beat pattern and tempo should be configurable.\n\nFor the purpose of this task, it is acceptable to play sound files for production of the beat notes, and an external player may be used.\n\nHowever, the playing of the sounds should not interfere with the timing of the metronome.\n\nThe visual indicator can simply be a blinking red or green area of the screen (depending on whether a high or low beat is being produced), and the metronome can be implemented using a terminal display, or optionally, a graphical display, depending on the language capabilities.\n\nIf the language has no facility to output sound, then it is permissible for this to implemented using just the visual indicator."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis code only uses textual output, but any noise-generating commands may be substituted; as long as they are executed synchronously, and do not run longer than the specified duration, the timing loop will compensate, since the sequence operator is determining a list of absolute times for each sleep to target.\n\n```\nsub MAIN ($beats-per-minute = 72, $beats-per-bar = 4) {\n    my $duration = 60 / $beats-per-minute;\n    my $base-time = now + $duration;\n    my $i;\n\n    for $base-time, $base-time + $duration ... * -> $next-time {\n        if $i++ %% $beats-per-bar {\n            print \"\\nTICK\";\n        }\n        else {\n            print  \" tick\";\n        }\n        sleep $next-time - now;\n    }\n}\n\n```\n\nSample run:\n\n```\n$ metronome 120 6\n\nTICK tick tick tick tick tick\nTICK tick tick tick tick tick\nTICK tick tick tick tick tick\nTICK tick tick tick tick tick\nTICK tick tick^C\n\n```"}]}
{"messages": [{"role": "user", "content": "The Mian–Chowla sequence is an integer sequence defined recursively.\n\nMian–Chowla is an infinite instance of a Sidon sequence, and belongs to the class known as B₂ sequences.\n\nThe sequence starts with:\n\n:   :   a1 = 1\n\nthen for n > 1, an is the smallest positive integer such that every pairwise sum\n\n:   :   ai + aj\n\nis distinct, for all i and j less than or equal to n.\n\nThe Task\n\n:   * Find and display, here, on this page the first 30 terms of the Mian–Chowla sequence.\n    * Find and display, here, on this page the 91st through 100th terms of the Mian–Chowla sequence.\n\nDemonstrating working through the first few terms longhand:\n\n:   :   a1 = 1\n\n:   :   1 + 1 = 2\n\nSpeculatively try a2 = 2\n\n:   :   1 + 1 = 2\n    :   1 + 2 = 3\n    :   2 + 2 = 4\n\nThere are no repeated sums so **2** is the next number in the sequence.\n\nSpeculatively try a3 = 3\n\n:   :   1 + 1 = 2\n    :   1 + 2 = 3\n    :   1 + 3 = 4\n    :   2 + 2 = 4\n    :   2 + 3 = 5\n    :   3 + 3 = 6\n\nSum of **4** is repeated so **3** is rejected.\n\nSpeculatively try a3 = 4\n\n:   :   1 + 1 = 2\n    :   1 + 2 = 3\n    :   1 + 4 = 5\n    :   2 + 2 = 4\n    :   2 + 4 = 6\n    :   4 + 4 = 8\n\nThere are no repeated sums so **4** is the next number in the sequence.\n\nAnd so on...\n\nSee also\n\n:   * OEIS:A005282 Mian-Chowla sequence"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @mian-chowla = 1, |(2..Inf).map: -> $test {\n    state $index = 1;\n    state %sums  = 2 => 1;\n    my $next;\n    my %these;\n    @mian-chowla[^$index].map: { ++$next and last if %sums{$_ + $test}:exists; ++%these{$_ + $test} };\n    next if $next;\n    ++%sums{$test + $test}; \n    %sums.push: %these;\n    ++$index;\n    $test\n};\n\nput \"First 30 terms in the Mian–Chowla sequence:\\n\", @mian-chowla[^30];\nput \"\\nTerms 91 through 100:\\n\", @mian-chowla[90..99];\n\n```\n\nOutput:\n\n```\nFirst 30 terms in the Mian–Chowla sequence:\n1 2 4 8 13 21 31 45 66 81 97 123 148 182 204 252 290 361 401 475 565 593 662 775 822 916 970 1016 1159 1312\n\nTerms 91 through 100:\n22526 23291 23564 23881 24596 24768 25631 26037 26255 27219\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function/procedure/subroutine that is called with an integer value and returns the middle three digits of the integer if possible or a clear indication of an error if this is not possible.\n\nNote: The order of the middle digits should be preserved.\n\nYour function should be tested with the following values; the first line should return valid answers, those of the second line should return clear indications of an error:\n\n```\n123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345\n1, 2, -1, -10, 2002, -2002, 0\n\n```\n\nShow your output on this page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub middle-three($n) {\n    given $n.abs {\n        when .chars < 3  { \"$n is too short\" }\n        when .chars %% 2 { \"$n has an even number of digits\" }\n        default          { \"The three middle digits of $n are: \", .substr: (.chars - 3)/2, 3 }\n    }\n}\n\nsay middle-three($_) for <\n    123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345\n    1 2 -1 -10 2002 -2002 0\n>;\n\n```\n\nOutput:\n\n```\nThe three middle digits of 123 are:  123\nThe three middle digits of 12345 are:  234\nThe three middle digits of 1234567 are:  345\nThe three middle digits of 987654321 are:  654\nThe three middle digits of 10001 are:  000\nThe three middle digits of -10001 are:  000\nThe three middle digits of -123 are:  123\nThe three middle digits of -100 are:  100\nThe three middle digits of 100 are:  100\nThe three middle digits of -12345 are:  234\n1 is too short\n2 is too short\n-1 is too short\n-10 is too short\n2002 has an even number of digits\n-2002 has an even number of digits\n0 is too short\n```\n\nIt is also possible to write a regular expression with a code assertion:\n\n```\nfor [\\~] ^10 { say \"$_ => $()\" if m/^^(\\d+) <(\\d**3)> (\\d+) $$ <?{ $0.chars == $1.chars}> / }\n\n```\n\nOutput:\n\n```\n01234 => 123\n0123456 => 234\n012345678 => 345\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Miller–Rabin primality test. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThe Miller–Rabin primality test or Rabin–Miller primality test is a primality test: an algorithm which determines whether a given number is prime or not.\n\nThe algorithm, as modified by Michael O. Rabin to avoid the generalized Riemann hypothesis, is a probabilistic algorithm.\n\nThe pseudocode, from Wikipedia is:\n\n```\nInput: n > 2, an odd integer to be tested for primality;\n       k, a parameter that determines the accuracy of the test\nOutput: composite if n is composite, otherwise probably prime\nwrite n − 1 as 2s·d with d odd by factoring powers of 2 from n − 1\nLOOP: repeat k times:\n   pick a randomly in the range [2, n − 1]\n   x ← ad mod n\n   if x = 1 or x = n − 1 then do next LOOP\n   repeat s − 1 times:\n      x ← x2 mod n\n      if x = 1 then return composite\n      if x = n − 1 then do next LOOP\n   return composite\nreturn probably prime\n\n```\n\n* The nature of the test involves big numbers, so the use of \"big numbers\" libraries (or similar features of the language of your choice) are suggested, but **not** mandatory.\n* Deterministic variants of the test exist and can be implemented as extra (not mandatory to complete the task)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015-09-22\n\n```\n# the expmod-function from: http://rosettacode.org/wiki/Modular_exponentiation\nsub expmod(Int $a is copy, Int $b is copy, $n) {\n\tmy $c = 1;\n\trepeat while $b div= 2 {\n\t\t($c *= $a) %= $n if $b % 2;\n\t\t($a *= $a) %= $n;\n\t}\n\t$c;\n}\n\nsubset PrimeCandidate of Int where { $_ > 2 and $_ % 2 };\n\nmy Bool multi sub is_prime(Int $n, Int $k)            { return False; }\nmy Bool multi sub is_prime(2, Int $k)                 { return True; }\nmy Bool multi sub is_prime(PrimeCandidate $n, Int $k) {\n\tmy Int $d = $n - 1;\n\tmy Int $s = 0;\n\n\twhile $d %% 2 {\n\t\t$d div= 2;\n\t\t$s++;\n\t}\n\n\tfor (2 ..^ $n).pick($k) -> $a {\n\t\tmy $x = expmod($a, $d, $n);\n\n\t\t# one could just write \"next if $x == 1 | $n - 1\"\n\t\t# but this takes much more time in current rakudo/nom\n\t\tnext if $x == 1 or $x == $n - 1;\n\n\t\tfor 1 ..^ $s {\n\t\t\t$x = $x ** 2 mod $n;\n\t\t\treturn False if $x == 1;\n\t\t\tlast if $x == $n - 1;\n\t\t}\n\t\treturn False if $x !== $n - 1;\n\t}\n\n\treturn True;\n}\n\nsay (1..1000).grep({ is_prime($_, 10) }).join(\", \");\n\n```"}]}
{"messages": [{"role": "user", "content": "Matt Parker of the \"Stand Up Maths channel\" has a   YouTube video   of a card trick that creates a semblance of order from chaos.\n\nThe task is to simulate the trick in a way that mimics the steps shown in the video.\n\n1. Cards.\n\n1. Create a common deck of cards of 52 cards   (which are half red, half black).\n2. Give the pack a good shuffle.\n\n2. Deal from the shuffled deck, you'll be creating three piles.\n\n1. Assemble the cards face down.\n   1. Turn up the   *top card*   and hold it in your hand.\n      1. if the card is   black,   then add the   *next*   card (unseen) to the \"black\" pile.\n      2. If the card is     red,    then add the   *next*   card (unseen) to the   \"red\"  pile.\n   2. Add the   *top card*   that you're holding to the **discard** pile.   (You might optionally show these discarded cards to get an idea of the randomness).\n2. Repeat the above for the rest of the shuffled deck.\n\n3. Choose a random number   (call it **X**)   that will be used to swap cards from the \"red\" and \"black\" piles.\n\n1. Randomly choose   **X**   cards from the   \"red\"  pile (unseen), let's call this the   \"red\"  bunch.\n2. Randomly choose   **X**   cards from the \"black\" pile (unseen), let's call this the \"black\" bunch.\n3. Put the     \"red\"    bunch into the   \"black\" pile.\n4. Put the   \"black\"   bunch into the     \"red\"  pile.\n5. (The above two steps complete the swap of   **X**   cards of the \"red\" and \"black\" piles.   \n    (Without knowing what those cards are --- they could be red or black, nobody knows).\n\n4. Order from randomness?\n\n1. Verify (or not) the mathematician's assertion that:\n\n```\n     The number of black cards in the \"black\" pile equals the number of red cards in the \"red\" pile. \n\n```\n\n(Optionally, run this simulation a number of times, gathering more evidence of the truthfulness of the assertion.)\n\nShow output on this page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.08\n\n```\n# Generate a shuffled deck\nmy @deck = shuffle;\nput 'Shuffled deck:          ', @deck;\n\nmy (@discard, @red, @black);\n# Deal cards following task description\ndeal(@deck, @discard, @red, @black);\n\nput 'Discard pile:           ', @discard;\nput '\"Red\"   pile:           ', @red;\nput '\"Black\" pile:           ', @black;\n\n# swap the same random number of random\n# cards between the red and black piles\nmy $amount = ^(+@red min +@black) .roll;\nput 'Number of cards to swap: ', $amount;\nswap(@red, @black, $amount);\n\nput 'Red pile after swaps:   ', @red;\nput 'Black pile after swaps: ', @black;\n\nsay 'Number of Red   cards in the Red   pile: ', +@red.grep('R');\nsay 'Number of Black cards in the Black pile: ', +@black.grep('B');\n\nsub shuffle { (flat 'R' xx 26, 'B' xx 26).pick: * }\n\nsub deal (@deck, @d, @r, @b) {\n    while @deck.elems {\n        my $top = @deck.shift;\n        if $top eq 'R' {\n            @r.push: @deck.shift;\n        }\n        else {\n            @b.push: @deck.shift;\n        }\n        @d.push: $top;\n    }\n}\n\nsub swap (@r, @b, $a) {\n    my @ri  = ^@r .pick($a);\n    my @bi  = ^@b .pick($a);\n    my @rs  = @r[@ri];\n    my @bs  = @b[@bi];\n    @r[@ri] = @bs;\n    @b[@bi] = @rs;\n}\n\n```\n\nSample output:\n\n```\nShuffled deck:          B B B R B R R R B B R R R B R B R B R R R B R B B R R B B R R B R B R R R R B R R B B B B B B R R B B B\nDiscard pile:           B B B R B R R R R R R R B R B R R R R B R B B B R B\n\"Red\"   pile:           R R B B B R B B B B B R R B B\n\"Black\" pile:           B R R B R R R B B R B\nNumber of cards to swap: 6\nRed pile after swaps:   R R B B R R R R B B B R B B B\nBlack pile after swaps: B R B R R B B B B R B\nNumber of Red   cards in the Red   pile: 7\nNumber of Black cards in the Black pile: 7\n```"}]}
{"messages": [{"role": "user", "content": "There is an n by m grid that has a random number (between 10% to 20% of the total number of tiles, though older implementations may use 20%..60% instead) of randomly placed mines that need to be found.\n\nPositions in the grid are modified by entering their coordinates where the first coordinate is horizontal in the grid and the second vertical. The top left of the grid is position 1,1; the bottom right is at n,m.\n\n* The total number of mines to be found is shown at the beginning of the game.\n* Each mine occupies a single grid point, and its position is initially unknown to the player\n* The grid is shown as a rectangle of characters between moves.\n* You are initially shown all grids as obscured, by a single dot '.'\n* You may mark what you think is the position of a mine which will show as a '?'\n* You can mark what you think is free space by entering its coordinates.\n\n:   * If the point is free space then it is cleared, as are any adjacent points that are also free space- this is repeated recursively for subsequent adjacent free points unless that point is marked as a mine or is a mine.\n\n    :   * Points marked as a mine show as a '?'.\n        * Other free points show as an integer count of the number of adjacent true mines in its immediate neighborhood, or as a single space ' ' if the free point is not adjacent to any true mines.\n\n* Of course you lose if you try to clear space that has a hidden mine.\n* You win when you have correctly identified all mines.\n\nThe Task is to **create a program that allows you to play minesweeper on a 6 by 4 grid, and that assumes all user input is formatted correctly** and so checking inputs for correct form may be omitted.\nYou may also omit all GUI parts of the task and work using text input and output.\n\nNote: Changes may be made to the method of clearing mines to more closely follow a particular implementation of the game so long as such differences and the implementation that they more accurately follow are described.\n\nC.F: wp:Minesweeper (computer game)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-23\n\n```\nenum Tile-Type <Empty Mine>;\n \nclass Tile {\n    has Tile-Type $.type;\n    has $.face is rw;\n    method Str { with $!face { ~$!face } else { '.' } }\n}\n \nclass Field {\n    has @.grid;\n    has Int $.width;\n    has Int $.height;\n    has Int $.mine-spots;\n    has Int $.empty-spots;\n \n    method new (Int $height, Int $width, Rat $mines-ratio=0.1) {\n \n        my $mine-spots = round $width*$height*$mines-ratio;\n        my $empty-spots = $width*$height - $mine-spots;\n \n        my @grid;\n        for ^$height X ^$width -> ($y, $x) {\n            @grid[$y][$x] = Tile.new(type => Empty);\n        }\n        for (^$height).pick($mine-spots) Z (^$width).pick($mine-spots) -> ($y, $x) {\n            @grid[$y][$x] = Tile.new( type => Mine);\n        }\n        self.bless(:$height, :$width, :@grid, :$mine-spots, :$empty-spots);\n    }\n \n    method open( $y, $x) {\n        return if @!grid[$y][$x].face.defined;\n \n        self.end-game(\"KaBoom\") if @!grid[$y][$x].type ~~ Mine;\n \n        my @neighbors = gather do\n\t    take [$y+.[0],$x+.[1]]\n\t\tif 0 <= $y + .[0] < $!height && 0 <= $x + .[1] < $!width\n\t\t for [-1,-1],[+0,-1],[+1,-1],\n\t\t     [-1,+0],        [+1,+0],\n\t\t     [-1,+1],[+0,+1],[+1,+1];\n \n        my $mines = +@neighbors.grep: { @!grid[.[0]][.[1]].type ~~ Mine };\n\n        $!empty-spots--;\n        @!grid[$y][$x].face = $mines || ' ';\n \n        if $mines == 0 {\n            self.open(.[0], .[1]) for @neighbors;\n        }\n        self.end-game(\"You won\") if $!empty-spots == 0;\n    }\n \n    method end-game(Str $msg ) {\n        for ^$!height X ^$!width -> ($y, $x) {\n            @!grid[$y][$x].face = '*' if @!grid[$y][$x].type ~~ Mine\n        }\n        die $msg;\n    }\n \n    method mark ( $y, $x) {\n        if !@!grid[$y][$x].face.defined {\n            @!grid[$y][$x].face = \"⚐\";\n            $!mine-spots-- if @!grid[$y][$x].type ~~ Mine;\n        }\n\telsif !@!grid[$y][$x].face eq \"⚐\" {\n            undefine @!grid[$y][$x].face;\n            $!mine-spots++ if @!grid[$y][$x].type ~~ Mine;\n        }\n        self.end-game(\"You won\") if $!mine-spots == 0;\n    }\n \n    constant @digs = |('a'..'z') xx *;\n\n    method Str {\n        [~] flat '  ', @digs[^$!width], \"\\n\",\n\t         ' ┌', '─' xx $!width, \"┐\\n\",\n\t    join '', do for ^$!height -> $y {\n\t      $y, '│', @!grid[$y][*],   \"│\\n\"; },\n\t         ' └', '─' xx $!width, '┘';\n\t}\n \n    method valid ($y, $x) {\n        0 <= $y < $!height && 0 <= $x < $!width\n    }\n}\n\nsub a2n($a) { $a.ord > 64 ?? $a.ord % 32 - 1 !! +$a }\n\nmy $f = Field.new(6,10);\n \nloop {\n    say ~$f;\n    my @w = prompt(\"[open loc|mark loc|loc]: \").words;\n    last unless @w;\n    unshift @w, 'open' if @w < 2;\n    my ($x,$y) = $0, $1 if @w[1] ~~ /(<alpha>)(<digit>)|$1=<digit>$0=<alpha>/;\n    $x = a2n($x);\n    given @w[0] {\n\twhen !$f.valid($y,$x) { say \"invalid coordinates\" }\n\twhen /^o/ { $f.open($y,$x)   }\n\twhen /^m/ { $f.mark($y,$x)   }\n\tdefault     { say \"invalid cmd\" }\n    }\n    CATCH {\n\tsay \"$_: end of game.\";\n\tlast;\n    }\n}\n \nsay ~$f;\n\n```"}]}
{"messages": [{"role": "user", "content": "Given:\n\n* A starting, positive integer (greater than one), N.\n* A selection of possible integer perfect divisors, D.\n* And a selection of possible subtractors, S.\n\nThe goal is find the minimum number of steps necessary to reduce N down to one.\n\nAt any step, the number may be:\n\n* Divided by any member of D if it is perfectly divided by D, (remainder zero).\n* OR have one of S subtracted from it, if N is greater than the member of S.\n\nThere may be many ways to reduce the initial N down to 1. Your program needs to:\n\n* Find the *minimum* number of *steps* to reach 1.\n* Show **one** way of getting fron N to 1 in those minimum steps.\n\nExamples\n\nNo divisors, D. a single subtractor of 1.\n\n:   Obviousely N will take N-1 subtractions of 1 to reach 1\n\nSingle divisor of 2; single subtractor of 1:\n\n:   N = 7 Takes 4 steps N -1=> 6, /2=> 3, -1=> 2, /2=> 1\n:   N = 23 Takes 7 steps N -1=>22, /2=>11, -1=>10, /2=> 5, -1=> 4, /2=> 2, /2=> 1\n\nDivisors 2 and 3; subtractor 1:\n\n:   N = 11 Takes 4 steps N -1=>10, -1=> 9, /3=> 3, /3=> 1\n\nTask\n\nUsing the possible divisors D, of 2 and 3; together with a possible subtractor S, of 1:\n\n:   1. Show the number of steps and possible way of diminishing the numbers 1 to 10 down to 1.\n:   2. Show a count of, and the numbers that: have the maximum minimal\\_steps\\_to\\_1, in the range 1 to 2,000.\n\nUsing the possible divisors D, of 2 and 3; together with a possible subtractor S, of 2:\n\n:   3. Show the number of steps and possible way of diminishing the numbers 1 to 10 down to 1.\n:   4. Show a count of, and the numbers that: have the maximum minimal\\_steps\\_to\\_1, in the range 1 to 2,000.\n\nOptional stretch goal\n:   2a, and 4a: As in 2 and 4 above, but for N in the range 1 to 20\\_000\n\nReference\n\n* Learn Dynamic Programming (Memoization & Tabulation) Video of similar task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\n```\nuse Lingua::EN::Numbers;\n\nfor [2,3], 1, 2000,\n    [2,3], 1, 50000,\n    [2,3], 2, 2000,\n    [2,3], 2, 50000\n  -> @div, $sub, $limit {\n    my %min = 1 => {:op(''), :v(1), :s(0)};\n    (2..$limit).map( -> $n {\n       my @ops;\n       @ops.push: ($n / $_, \"/$_\") if $n %% $_ for @div;\n       @ops.push: ($n - $sub, \"-$sub\") if $n > $sub;\n       my $op = @ops.min( {%min{.[0]}<s>} );\n       %min{$n} = {:op($op[1]), :v($op[0]), :s(1 + %min{$op[0]}<s>)};\n    });\n\n    my $max = %min.max( {.value<s>} ).value<s>;\n    my @max = %min.grep( {.value.<s> == $max} )».key.sort(+*);\n\n    if $limit == 2000 {\n        say \"\\nDivisors: {@div.perl}, subtract: $sub\";\n        steps(1..10);\n    }\n    say \"\\nUp to {comma $limit} found {+@max} number{+@max == 1 ?? '' !! 's'} \" ~\n        \"that require{+@max == 1 ?? 's' !! ''} at least $max steps.\";\n    steps(@max);\n\n    sub steps (*@list) {\n        for @list -> $m {\n            my @op;\n            my $n = $m;\n            while %min{$n}<s> {\n                @op.push: \"{%min{$n}<op>}=>{%min{$n}<v>}\";\n                $n = %min{$n}<v>;\n            }\n            say \"($m) {%min{$m}<s>} steps: \", @op.join(', ');\n        }\n    }\n}\n\n```\n\nOutput:\n\n```\nDivisors: [2, 3], subtract: 1\n(1) 0 steps: \n(2) 1 steps: /2=>1\n(3) 1 steps: /3=>1\n(4) 2 steps: /2=>2, /2=>1\n(5) 3 steps: -1=>4, /2=>2, /2=>1\n(6) 2 steps: /2=>3, /3=>1\n(7) 3 steps: -1=>6, /2=>3, /3=>1\n(8) 3 steps: /2=>4, /2=>2, /2=>1\n(9) 2 steps: /3=>3, /3=>1\n(10) 3 steps: -1=>9, /3=>3, /3=>1\n\nUp to 2,000 found 16 numbers that require at least 14 steps.\n(863) 14 steps: -1=>862, -1=>861, /3=>287, -1=>286, -1=>285, /3=>95, -1=>94, -1=>93, /3=>31, -1=>30, /3=>10, -1=>9, /3=>3, /3=>1\n(1079) 14 steps: -1=>1078, /2=>539, -1=>538, /2=>269, -1=>268, /2=>134, /2=>67, -1=>66, /2=>33, /3=>11, -1=>10, -1=>9, /3=>3, /3=>1\n(1295) 14 steps: -1=>1294, /2=>647, -1=>646, /2=>323, -1=>322, /2=>161, -1=>160, /2=>80, /2=>40, /2=>20, /2=>10, -1=>9, /3=>3, /3=>1\n(1439) 14 steps: -1=>1438, -1=>1437, /3=>479, -1=>478, -1=>477, /3=>159, /3=>53, -1=>52, /2=>26, /2=>13, -1=>12, /2=>6, /2=>3, /3=>1\n(1511) 14 steps: -1=>1510, /2=>755, -1=>754, /2=>377, -1=>376, /2=>188, /2=>94, -1=>93, /3=>31, -1=>30, /3=>10, -1=>9, /3=>3, /3=>1\n(1583) 14 steps: -1=>1582, /2=>791, -1=>790, -1=>789, /3=>263, -1=>262, -1=>261, /3=>87, /3=>29, -1=>28, -1=>27, /3=>9, /3=>3, /3=>1\n(1607) 14 steps: -1=>1606, /2=>803, -1=>802, /2=>401, -1=>400, /2=>200, /2=>100, /2=>50, /2=>25, -1=>24, /2=>12, /2=>6, /2=>3, /3=>1\n(1619) 14 steps: -1=>1618, /2=>809, -1=>808, /2=>404, /2=>202, /2=>101, -1=>100, /2=>50, /2=>25, -1=>24, /2=>12, /2=>6, /2=>3, /3=>1\n(1691) 14 steps: -1=>1690, /2=>845, -1=>844, -1=>843, /3=>281, -1=>280, -1=>279, /3=>93, /3=>31, -1=>30, /3=>10, -1=>9, /3=>3, /3=>1\n(1727) 14 steps: -1=>1726, -1=>1725, /3=>575, -1=>574, -1=>573, /3=>191, -1=>190, -1=>189, /3=>63, /3=>21, /3=>7, -1=>6, /2=>3, /3=>1\n(1823) 14 steps: -1=>1822, /2=>911, -1=>910, -1=>909, /3=>303, /3=>101, -1=>100, /2=>50, /2=>25, -1=>24, /2=>12, /2=>6, /2=>3, /3=>1\n(1871) 14 steps: -1=>1870, -1=>1869, /3=>623, -1=>622, -1=>621, /3=>207, /3=>69, /3=>23, -1=>22, /2=>11, -1=>10, -1=>9, /3=>3, /3=>1\n(1895) 14 steps: -1=>1894, /2=>947, -1=>946, /2=>473, -1=>472, /2=>236, /2=>118, -1=>117, /3=>39, /3=>13, -1=>12, /2=>6, /2=>3, /3=>1\n(1907) 14 steps: -1=>1906, /2=>953, -1=>952, /2=>476, /2=>238, /2=>119, -1=>118, -1=>117, /3=>39, /3=>13, -1=>12, /2=>6, /2=>3, /3=>1\n(1919) 14 steps: -1=>1918, -1=>1917, /3=>639, /3=>213, /3=>71, -1=>70, /2=>35, -1=>34, /2=>17, -1=>16, /2=>8, /2=>4, /2=>2, /2=>1\n(1943) 14 steps: -1=>1942, /2=>971, -1=>970, /2=>485, -1=>484, /2=>242, /2=>121, -1=>120, /2=>60, /2=>30, /3=>10, -1=>9, /3=>3, /3=>1\n\nUp to 50,000 found 3 numbers that require at least 22 steps.\n(25919) 22 steps: -1=>25918, /2=>12959, -1=>12958, /2=>6479, -1=>6478, /2=>3239, -1=>3238, /2=>1619, -1=>1618, /2=>809, -1=>808, /2=>404, /2=>202, /2=>101, -1=>100, /2=>50, /2=>25, -1=>24, /2=>12, /2=>6, /2=>3, /3=>1\n(31103) 22 steps: -1=>31102, /2=>15551, -1=>15550, /2=>7775, -1=>7774, /2=>3887, -1=>3886, /2=>1943, -1=>1942, /2=>971, -1=>970, /2=>485, -1=>484, /2=>242, /2=>121, -1=>120, /2=>60, /2=>30, /3=>10, -1=>9, /3=>3, /3=>1\n(38879) 22 steps: -1=>38878, /2=>19439, -1=>19438, /2=>9719, -1=>9718, /2=>4859, -1=>4858, /2=>2429, -1=>2428, /2=>1214, /2=>607, -1=>606, /2=>303, /3=>101, -1=>100, /2=>50, /2=>25, -1=>24, /2=>12, /2=>6, /2=>3, /3=>1\n\nDivisors: [2, 3], subtract: 2\n(1) 0 steps: \n(2) 1 steps: /2=>1\n(3) 1 steps: /3=>1\n(4) 2 steps: /2=>2, /2=>1\n(5) 2 steps: -2=>3, /3=>1\n(6) 2 steps: /2=>3, /3=>1\n(7) 3 steps: -2=>5, -2=>3, /3=>1\n(8) 3 steps: /2=>4, /2=>2, /2=>1\n(9) 2 steps: /3=>3, /3=>1\n(10) 3 steps: /2=>5, -2=>3, /3=>1\n\nUp to 2,000 found 1 number that requires at least 17 steps.\n(1699) 17 steps: -2=>1697, -2=>1695, /3=>565, -2=>563, -2=>561, /3=>187, -2=>185, -2=>183, /3=>61, -2=>59, -2=>57, /3=>19, -2=>17, -2=>15, /3=>5, -2=>3, /3=>1\n\nUp to 50,000 found 1 number that requires at least 26 steps.\n(45925) 26 steps: -2=>45923, -2=>45921, /3=>15307, -2=>15305, -2=>15303, /3=>5101, -2=>5099, -2=>5097, /3=>1699, -2=>1697, -2=>1695, /3=>565, -2=>563, -2=>561, /3=>187, -2=>185, -2=>183, /3=>61, -2=>59, -2=>57, /3=>19, -2=>17, -2=>15, /3=>5, -2=>3, /3=>1\n```"}]}
{"messages": [{"role": "user", "content": "Generate the sequence **a(n)** when each element is the minimum integer multiple **m** such that the digit sum of **n** times **m** is equal to **n**.\n\nTask\n\n* Find the first 40 elements of the sequence.\n\nStretch\n\n* Find the next 30 elements of the sequence.\n\nSee also\n\n* OEIS:A131382 - Minimal number m such that Sum\\_digits(n\\*m)=n"}, {"role": "assistant", "content": "```\nsub min-mult-dsum ($n) { (1..∞).first: (* × $n).comb.sum == $n }\n\nsay .fmt(\"%2d: \") ~ .&min-mult-dsum for flat 1..40, 41..70;\n\n```\n\nOutput:\n\n```\n 1: 1\n 2: 1\n 3: 1\n 4: 1\n 5: 1\n 6: 1\n 7: 1\n 8: 1\n 9: 1\n10: 19\n11: 19\n12: 4\n13: 19\n14: 19\n15: 13\n16: 28\n17: 28\n18: 11\n19: 46\n20: 199\n21: 19\n22: 109\n23: 73\n24: 37\n25: 199\n26: 73\n27: 37\n28: 271\n29: 172\n30: 1333\n31: 289\n32: 559\n33: 1303\n34: 847\n35: 1657\n36: 833\n37: 1027\n38: 1576\n39: 1282\n40: 17497\n41: 4339\n42: 2119\n43: 2323\n44: 10909\n45: 11111\n46: 12826\n47: 14617\n48: 14581\n49: 16102\n50: 199999\n51: 17449\n52: 38269\n53: 56413\n54: 37037\n55: 1108909\n56: 142498\n57: 103507\n58: 154981\n59: 150661\n60: 1333333\n61: 163918\n62: 322579\n63: 315873\n64: 937342\n65: 1076923\n66: 1030303\n67: 880597\n68: 1469116\n69: 1157971\n70: 12842857\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show on this page the minimum number of cells after, before, above and below   **N×N**   squares,   where   **N = 10**."}, {"role": "assistant", "content": "```\nsub distance-to-edge (\\N) {\n   my $c = ceiling N / 2;\n   my $f = floor   N / 2;\n   my @ul = ^$c .map: -> $x { [ ^$c .map: { min($x, $_) } ] }\n   @ul[$_].append: reverse @ul[$_; ^$f] for ^$c;\n   @ul.push: [ reverse @ul[$_] ] for reverse ^$f;\n   @ul\n}\n \nfor 0, 1, 2, 6, 9, 23 {\n    my @dte = .&distance-to-edge;\n    my $max = chars max flat @dte».Slip;\n \n    say \"\\n$_ x $_ distance to nearest edge:\";\n    .fmt(\"%{$max}d\").say for @dte;\n}\n\n```\n\nOutput:\n\n```\n0 x 0 distance to nearest edge:\n\n1 x 1 distance to nearest edge:\n0\n\n2 x 2 distance to nearest edge:\n0 0\n0 0\n\n6 x 6 distance to nearest edge:\n0 0 0 0 0 0\n0 1 1 1 1 0\n0 1 2 2 1 0\n0 1 2 2 1 0\n0 1 1 1 1 0\n0 0 0 0 0 0\n\n9 x 9 distance to nearest edge:\n0 0 0 0 0 0 0 0 0\n0 1 1 1 1 1 1 1 0\n0 1 2 2 2 2 2 1 0\n0 1 2 3 3 3 2 1 0\n0 1 2 3 4 3 2 1 0\n0 1 2 3 3 3 2 1 0\n0 1 2 2 2 2 2 1 0\n0 1 1 1 1 1 1 1 0\n0 0 0 0 0 0 0 0 0\n\n23 x 23 distance to nearest edge:\n 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0\n 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0\n 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0\n 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0\n 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0\n 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0\n 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0\n 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0\n 0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0\n 0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0\n 0  1  2  3  4  5  6  7  8  9 10 11 10  9  8  7  6  5  4  3  2  1  0\n 0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0\n 0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0\n 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0\n 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0\n 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0\n 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0\n 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0\n 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0\n 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0\n 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0\n 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven three lists:\n\n* Numbers1 = [5,45,23,21,67]\n* Numbers2 = [43,22,78,46,38]\n* Numbers3 = [9,98,12,98,53]\n\nthen:\n\n1. Select the minimum of Numbers[n], Numbers2[n] and Numbers3[n], where **n <= 5** (one based).\n2. Add minimum to a new list (Numbers).\n3. Show Numbers on this page."}, {"role": "assistant", "content": "```\nsay [Zmin] (5,45,23,21,67), (43,22,78,46,38), (9,98,12,98,53);\n\n```\n\nOutput:\n\n```\n(5 22 12 21 38)\n```"}]}
{"messages": [{"role": "user", "content": "Every positive integer has infinitely many base-10 multiples that only use the digits **0** and **1**. The goal of this task is to find and display the **minimum** multiple that has this property.\n\nThis is simple to do, but can be challenging to do efficiently.\n\nTo avoid repeating long, unwieldy phrases, the operation \"minimum positive multiple of a positive integer n in base 10 that only uses the digits 0 and 1\" will hereafter be referred to as \"**B10**\".\n\nTask\n\nWrite a routine to find the B10 of a given integer.\n\nE.G.\n\n```\n      n                  B10      n  × multiplier\n      1                    1    ( 1  × 1         )\n      2                   10    ( 2  × 5         )\n      7                 1001    ( 7  x 143       )\n      9            111111111    ( 9  x 12345679  )\n     10                   10    ( 10 x 1         )\n\n```\n\nand so on.\n\nUse the routine to find and display here, on this page, the **B10** value for:\n\n```\n   1 through 10, 95 through 105, 297, 576, 594, 891, 909, 999\n\n```\n\nOptionally find **B10** for:\n\n```\n   1998, 2079, 2251, 2277\n\n```\n\nStretch goal; find **B10** for:\n\n```\n   2439, 2997, 4878\n\n```\n\nThere are many opportunities for optimizations, but avoid using magic numbers as much as possible. If you *do* use magic numbers, explain briefly why and what they do for your implementation.\n\nSee also\n\n:   * OEIS:A004290 Least positive multiple of n that when written in base 10 uses only 0's and 1's.\n    * How to find Minimum Positive Multiple in base 10 using only 0 and 1"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.02\n\nNaive, brute force. Simplest thing that could possibly work. Will find any B10 eventually (until you run out of memory or patience) but sloooow, especially for larger multiples of 9.\n\n```\nsay $_ , ': ', (1..*).map( *.base(2) ).first: * %% $_ for flat 1..10, 95..105; # etc.\n\n```\n\nBased on Ed Pegg jr.s C code from Mathpuzzlers.com. Similar to Phix and Go entries.\n\n```\nsub Ed-Pegg-jr (\\n) {\n    return 1 if n == 1;\n    my ($count, $power-mod-n) = 0, 1;\n    my @oom-mod-n = 0; # orders of magnitude of 10 mod n\n    my @dig-mod = 0;   # 1 to n + oom mod n\n    for 1..n -> \\i {\n        @oom-mod-n[i] = $power-mod-n;\n        for 1..n -> \\j {\n            my \\k = (j + $power-mod-n - 1) % n + 1;\n            @dig-mod[k] = i if @dig-mod[j] and @dig-mod[j] != i and !@dig-mod[k];\n        }\n        @dig-mod[$power-mod-n + 1] ||= i;\n        ($power-mod-n *= 10) %= n;\n        last if @dig-mod[1];\n    }\n    my ($b10, $remainder) = '', n;\n    while $remainder {\n        my $place = @dig-mod[$remainder % n + 1];\n        $b10 ~= '0' x ($count - $place) if $count > $place;\n        $count = $place - 1;\n        $b10 ~= '1';\n        $remainder = (n + $remainder - @oom-mod-n[$place]) % n;\n    }\n    $b10 ~ '0' x $count\n}\n\nprintf \"%5s: %28s  %s\\n\", 'Number', 'B10', 'Multiplier';\n\nfor flat 1..10, 95..105, 297, 576, 594, 891, 909, 999, 1998, 2079, 2251, 2277, 2439, 2997, 4878 {\n    printf \"%6d: %28s  %s\\n\", $_, my $a = Ed-Pegg-jr($_), $a / $_;\n}\n\n```\n\nOutput:\n\n```\nNumber:                          B10  Multiplier\n     1:                            1  1\n     2:                           10  5\n     3:                          111  37\n     4:                          100  25\n     5:                           10  2\n     6:                         1110  185\n     7:                         1001  143\n     8:                         1000  125\n     9:                    111111111  12345679\n    10:                           10  1\n    95:                       110010  1158\n    96:                     11100000  115625\n    97:                     11100001  114433\n    98:                     11000010  112245\n    99:           111111111111111111  1122334455667789\n   100:                          100  1\n   101:                          101  1\n   102:                      1000110  9805\n   103:                     11100001  107767\n   104:                      1001000  9625\n   105:                       101010  962\n   297:          1111011111111111111  3740778151889263\n   576:              111111111000000  192901234375\n   594:         11110111111111111110  18703890759446315\n   891:          1111111111111111011  1247038284075321\n   909:          1011111111111111111  1112333455567779\n   999:  111111111111111111111111111  111222333444555666777889\n  1998: 1111111111111111111111111110  556111667222778333889445\n  2079:       1001101101111111111111  481530111164555609\n  2251:                 101101101111  44913861\n  2277:         11110111111111111011  4879275850290343\n  2439:   10000101011110111101111111  4100082415379299344449\n  2997: 1111110111111111111111111111  370740777814851888925963\n  4878:  100001010111101111011111110  20500412076896496722245\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven three lists:\n\n* Numbers1 = [5,45,23,21,67]\n* Numbers2 = [43,22,78,46,38]\n* Numbers3 = [9,98,12,54,53]\n\nthen:\n\n1. Select the maximum (max) of Numbers[n], Numbers2[n] and Numbers3[n], where **n <= 5** (one based).\n2. For each value of max, find the least prime, minPrime, such that **minPrime >= max**\n3. Add minPrime to a new list (Primes)\n4. Show Primes on this page."}, {"role": "assistant", "content": "Seems kind of pointless to specify a maximum of 5 terms when there are only 5 elements in each list but... ¯\\\\_(ツ)\\_/¯\n\n```\nsay ([Zmax] <5 45 23 21 67>, <43 22 78 46 38>, <9 98 12 54 53>)».&next-prime[^5];\n\nsub next-prime { ($^m..*).first: &is-prime }\n\n```\n\nOutput:\n\n```\n(43 101 79 59 67)\n```"}]}
{"messages": [{"role": "user", "content": "The **Minkowski question-mark function** converts the continued fraction representation [a0; a1, a2, a3, ...] of a number into a binary decimal representation in which the integer part a0 is unchanged and the a1, a2, ... become alternating runs of binary zeroes and ones of those lengths. The decimal point takes the place of the first zero.\n\nThus, ?(31/7) = 71/16 because 31/7 has the continued fraction representation [4;2,3] giving the binary expansion 4 + 0.01112.\n\nAmong its interesting properties is that it maps roots of quadratic equations, which have repeating continued fractions, to rational numbers, which have repeating binary digits.\n\nThe question-mark function is continuous and monotonically increasing, so it has an inverse.\n\n* Produce a function for ?(x).   Be careful: rational numbers have two possible continued fraction representations:\n\n:   :   :   * [a0;a1,... an−1,an]     and\n            * [a0;a1,... an−1,an−1,1]\n\n* Choose one of the above that will give a binary expansion ending with a   **1**.\n* Produce the inverse function ?-1(x)\n* Verify that ?(φ) = 5/3, where φ is the Greek golden ratio.\n* Verify that ?-1(-5/9) = (√13 - 7)/6\n* Verify that the two functions are inverses of each other by showing that ?-1(?(x))=x and ?(?-1(y))=y for x, y of your choice\n\nDon't worry about precision error in the last few digits.\n\nSee also\n\n* Wikipedia entry: Minkowski's question-mark function"}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20201120 Raku programming solution\n\nmy \\MAXITER = 151;\n\nsub minkowski(\\x) {\n\n   return x.floor + minkowski( x - x.floor ) if x > 1 || x < 0 ;\n\n   my $y = my $p = x.floor;\n   my ($q,$s,$d) = 1 xx 3;\n   my $r = $p + 1;\n\n   loop {\n      last if ( $y + ($d /= 2)  == $y )        ||\n              ( my $m = $p + $r) <  0 | $p < 0 ||\n              ( my $n = $q + $s) <  0           ;\n      x < $m/$n ?? ( ($r,$s) = ($m, $n) ) !! ( $y += $d; ($p,$q) = ($m, $n) );\n   }\n   return $y + $d\n}\n\nsub minkowskiInv($x is copy) {\n\n   return $x.floor + minkowskiInv($x - $x.floor) if  $x > 1 || $x < 0 ;\n\n   return $x if $x == 1 || $x == 0 ;\n\n   my @contFrac = 0;\n   my $i = my $curr = 0 ; my $count = 1;\n\n   loop {\n      $x *= 2;\n      if $curr == 0 {\n         if $x < 1 {\n            $count++\n         } else {\n            $i++;\n            @contFrac.append: 0;\n            @contFrac[$i-1] = $count;\n            ($count,$curr) = 1,1;\n            $x--;\n         }\n      } else {\n         if $x > 1 {\n            $count++;\n            $x--;\n         } else {\n            $i++;\n            @contFrac.append: 0;\n            @contFrac[$i-1] = $count;\n            ($count,$curr) = 1,0;\n         }\n      }\n      if $x == $x.floor { @contFrac[$i] = $count ; last }\n      last if $i == MAXITER;\n    }\n    my $ret = 1 / @contFrac[$i];\n    loop (my $j = $i - 1; $j ≥ 0; $j--) { $ret = @contFrac[$j] + 1/$ret }\n    return 1 / $ret\n}\n\nprintf \"%19.16f %19.16f\\n\", minkowski(0.5*(1 + 5.sqrt)), 5/3;\nprintf \"%19.16f %19.16f\\n\", minkowskiInv(-5/9), (13.sqrt-7)/6;\nprintf \"%19.16f %19.16f\\n\", minkowski(minkowskiInv(0.718281828)),\n   minkowskiInv(minkowski(0.1213141516171819))\n\n```\n\nOutput:\n\n```\n 1.6666666666696983  1.6666666666666667\n-0.5657414540893351 -0.5657414540893352\n 0.7182818280000092  0.1213141516171819\n```"}]}
{"messages": [{"role": "user", "content": "Given a random number generator, (rng), generating numbers in the range 0.0 .. 1.0 called rgen, for example; and a function modifier(x)\ntaking an number in the same range and generating the probability that the input should be generated, in the same range 0..1; then implement the following algorithm for generating random numbers to the probability given by function modifier:\n\n```\nwhile True:\n    random1 = rgen()\n    random2 = rgen()\n    if random2 < modifier(random1):\n        answer = random1\n        break\n    endif\nendwhile\n```\n\nTask\n\n* Create a modifier function that generates a 'V' shaped probability of number generation using something like, for example:\n\n```\n                      modifier(x)  =  2*(0.5 - x)  if x < 0.5  else 2*(x - 0.5) \n\n```\n\n* Create a generator of random numbers with probabilities modified by the above function.\n* Generate >= 10,000 random numbers subject to the probability modification.\n* Output a textual histogram with from 11 to 21 bins showing the distribution of the random numbers generated.\n\nShow your output here, on this page."}, {"role": "assistant", "content": "```\nsub modified_random_distribution ( Code $modifier --> Seq ) {\n    return lazy gather loop {\n        my ( $r1, $r2 ) = rand, rand;\n        take $r1 if $modifier.($r1) > $r2;\n    }\n}\nsub modifier ( Numeric $x --> Numeric ) {\n    return 2 * ( $x < 1/2 ?? ( 1/2 - $x  )\n                          !! ( $x  - 1/2 ) );\n} \nsub print_histogram ( @data, :$n-bins, :$width ) { # Assumes minimum of zero.\n    my %counts = bag @data.map: { floor( $_ * $n-bins ) / $n-bins };\n    my $max_value = %counts.values.max;\n    sub hist { '■' x ( $width * $^count / $max_value ) }\n    say ' Bin, Counts: Histogram';\n    printf \"%4.2f, %6d: %s\\n\", .key, .value, hist(.value) for %counts.sort;\n}\n\nmy @d = modified_random_distribution( &modifier );\n\nprint_histogram( @d.head(50_000), :n-bins(20), :width(64) );\n\n```\n\nOutput:\n\n```\n Bin, Counts: Histogram\n0.00,   4718: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n0.05,   4346: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n0.10,   3685: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n0.15,   3246: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n0.20,   2734: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n0.25,   2359: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n0.30,   1702: ■■■■■■■■■■■■■■■■■■■■■■\n0.35,   1283: ■■■■■■■■■■■■■■■■■\n0.40,    702: ■■■■■■■■■\n0.45,    250: ■■■\n0.50,    273: ■■■\n0.55,    745: ■■■■■■■■■■\n0.60,   1231: ■■■■■■■■■■■■■■■■\n0.65,   1757: ■■■■■■■■■■■■■■■■■■■■■■■\n0.70,   2209: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n0.75,   2738: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n0.80,   3255: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n0.85,   3741: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n0.90,   4268: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n0.95,   4758: ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n\n```"}]}
{"messages": [{"role": "user", "content": "**Modular arithmetic** is a form of arithmetic (a calculation technique involving the concepts of addition and multiplication) which is done on numbers with a defined equivalence relation called *congruence*.\n\nFor any positive integer \n\np\n{\\displaystyle {\\displaystyle p}}\n called the *congruence modulus*,\ntwo numbers \n\na\n{\\displaystyle {\\displaystyle a}}\n and \n\nb\n{\\displaystyle {\\displaystyle b}}\n are said to be *congruent modulo p* whenever there exists an integer \n\nk\n{\\displaystyle {\\displaystyle k}}\n such that:\n\n:   a\n    =\n    b\n    +\n    k\n\n    p\n    {\\displaystyle {\\displaystyle a=b+k\\,p}}\n\nThe corresponding set of equivalence classes forms a ring denoted \n\nZ\n\np\n\nZ\n{\\displaystyle {\\displaystyle {\\frac {\\mathbb {Z} }{p\\mathbb {Z} }}}}\n. When p is a prime number, this ring becomes a field denoted \n\nF\n\np\n{\\displaystyle {\\displaystyle \\mathbb {F} \\_{p}}}\n, but you won't have to implement the multiplicative inverse for this task.\n\nAddition and multiplication on this ring have the same algebraic structure as in usual arithmetic, so that a function such as a polynomial expression could receive a ring element as argument and give a consistent result.\n\nThe purpose of this task is to show, if your programming language allows it,\nhow to redefine operators so that they can be used transparently on modular integers.\nYou can do it either by using a dedicated library, or by implementing your own class.\n\nYou will use the following function for demonstration:\n\n:   f\n    (\n    x\n    )\n    =\n\n    x\n\n    100\n    +\n    x\n    +\n    1\n    {\\displaystyle {\\displaystyle f(x)=x^{100}+x+1}}\n\nYou will use \n\n13\n{\\displaystyle {\\displaystyle 13}}\n as the congruence modulus and you will compute \n\nf\n(\n10\n)\n{\\displaystyle {\\displaystyle f(10)}}\n.\n\nIt is important that the function \n\nf\n{\\displaystyle {\\displaystyle f}}\n is agnostic about whether or not its argument is modular; it should behave the same way with normal and modular integers.\nIn other words, the function is an algebraic expression that could be used with any ring, not just integers.\n\nRelated tasks\n\nModular exponentiation"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nWe'll use the FiniteFields repo.\n\n```\nuse FiniteField;\n$*modulus = 13;\n\nsub f(\\x) { x**100 + x + 1};\n\nsay f(10);\n\n```\n\nOutput:\n\n```\n1\n```"}]}
{"messages": [{"role": "user", "content": "Find the last   **40**   decimal digits of   \n\na\n\nb\n{\\displaystyle {\\displaystyle a^{b}}}\n,   where\n\n:   :   * a\n          =\n          2988348162058574136915891421498819466320163312926952423791023078876139\n          {\\displaystyle {\\displaystyle a=2988348162058574136915891421498819466320163312926952423791023078876139}}\n        * b\n          =\n          2351399303373464486466122544523690094744975233415544072992656881240319\n          {\\displaystyle {\\displaystyle b=2351399303373464486466122544523690094744975233415544072992656881240319}}\n\nA computer is too slow to find the entire value of   \n\na\n\nb\n{\\displaystyle {\\displaystyle a^{b}}}\n.\n\nInstead, the program must use a fast algorithm for modular exponentiation:   \n\na\n\nb\n\nmod\n\n\nm\n{\\displaystyle {\\displaystyle a^{b}\\mod m}}\n.\n\nThe algorithm must work for any integers   \n\na\n,\nb\n,\nm\n{\\displaystyle {\\displaystyle a,b,m}}\n,     where   \n\nb\n≥\n0\n{\\displaystyle {\\displaystyle b\\geq 0}}\n   and   \n\nm\n>\n0\n{\\displaystyle {\\displaystyle m>0}}\n."}, {"role": "assistant", "content": "(formerly Perl 6)\nThis is specced as a built-in, but here's an explicit version:\n\n```\nsub expmod(Int $a is copy, Int $b is copy, $n) {\n    my $c = 1;\n    repeat while $b div= 2 {\n        ($c *= $a) %= $n if $b % 2;\n        ($a *= $a) %= $n;\n    }\n    $c;\n}\n\nsay expmod\n    2988348162058574136915891421498819466320163312926952423791023078876139,\n    2351399303373464486466122544523690094744975233415544072992656881240319,\n    10**40;\n\n```\n\nOutput:\n\n```\n1527229998585248450016808958343740453059\n```"}]}
{"messages": [{"role": "user", "content": "From Wikipedia:\n\nIn modular arithmetic,   the **modular multiplicative inverse** of an integer    *a*    modulo    *m*    is an integer    *x*    such that\n\n:   :   a\n\n        x\n        ≡\n        1\n\n\n        (\n        mod\n\n        m\n        )\n        .\n        {\\displaystyle {\\displaystyle a\\,x\\equiv 1{\\pmod {m}}.}}\n\nOr in other words, such that:\n\n:   :   ∃\n        k\n        ∈\n\n        Z\n        ,\n\n        a\n\n        x\n        =\n        1\n        +\n        k\n\n        m\n        {\\displaystyle {\\displaystyle \\exists k\\in \\mathbb {Z} ,\\qquad a\\,x=1+k\\,m}}\n\nIt can be shown that such an inverse exists   if and only if    *a*    and    *m*    are coprime,   but we will ignore this for this task.\n\nTask\n\nEither by implementing the algorithm, by using a dedicated library or by using a built-in function in\nyour language,   compute the modular inverse of   42 modulo 2017."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub inverse($n, :$modulo) {\n    my ($c, $d, $uc, $vc, $ud, $vd) = ($n % $modulo, $modulo, 1, 0, 0, 1);\n    my $q;\n    while $c != 0 {\n        ($q, $c, $d) = ($d div $c, $d % $c, $c);\n        ($uc, $vc, $ud, $vd) = ($ud - $q*$uc, $vd - $q*$vc, $uc, $vc);\n    }\n    return $ud % $modulo;\n}\n\nsay inverse 42, :modulo(2017)\n\n# or use a built-in routine - https://docs.raku.org/routine/expmod , kudos to trizen++\n\nsay expmod(42, -1, 2017);\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "It is useful to be able to execute a main() function only when a program is run directly. This is a central feature in programming scripts. A script that behaves this way is called a modulino.\n\nExamples from https://github.com/mcandre/modulinos\n\nSometimes getting the ScriptName is required in order to determine when to run main().\n\nCare when manipulating command line arguments, due to subtle exec security constraints that may or not be enforced on implicit argv[0]. https://ryiron.wordpress.com/2013/12/16/argv-silliness/\n\n:   *This is still a draft task, and the current task description has caused mega confusion. See **Talk:Modulinos** for numerous attempts to understand the task and to rewrite the task description.*\n\n:   **The task Executable library is written to replace this task.** *This task's future is in doubt as its aims are not clear enough.*"}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku automatically calls MAIN on direct invocation, but this may be a multi dispatch, so a library may have multiple \"scripted mains\".\n\n```\nclass LUE {\n    has $.answer = 42;\n}\n\nmulti MAIN ('test') {\n    say \"ok\" if LUE.new.answer == 42;\n}\n\nmulti MAIN ('methods') {\n    say ~LUE.^methods;\n}\n```"}]}
{"messages": [{"role": "user", "content": "A Monad is a combination of a data-type with two helper functions written for that type.\n\nThe data-type can be of any kind which can contain values of some other type – common examples are lists, records, sum-types, even functions or IO streams. The two special functions, mathematically known as **eta** and **mu**, but usually given more expressive names like 'pure', 'return', or 'yield' and 'bind', abstract away some boilerplate needed for pipe-lining or enchaining sequences of computations on values held in the containing data-type.\n\nThe bind operator in the List monad enchains computations which return their values wrapped in lists. One application of this is the representation of indeterminacy, with returned lists representing a set of possible values. An empty list can be returned to express incomputability, or computational failure.\n\nA sequence of two list monad computations (enchained with the use of bind) can be understood as the computation of a cartesian product.\n\nThe natural implementation of bind for the List monad is a composition of **concat** and **map**, which, used with a function which returns its value as a (possibly empty) list, provides for filtering in addition to transformation or mapping.\n\nDemonstrate in your programming language the following:\n\n1. Construct a List Monad by writing the 'bind' function and the 'pure' (sometimes known as 'return') function for that Monad (or just use what the language already has implemented)\n2. Make two functions, each which take a number and return a monadic number, e.g. Int -> List Int and Int -> List String\n3. Compose the two functions with bind"}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku does not have Monad types built in but they can be emulated/implemented without a great deal of difficulty. List Monads especially are of questionable utility in Raku. Most item types and Listy types have a Cool role in Raku. (Cool being a play on the slang term \"cool\" as in: \"That's cool with me.\" (That's ok with me). So Ints are pretty much treated like one item lists for operators that work with lists. (\"I work on a list.\" \"Here's an Int.\" \"Ok, that's cool.\") Explicitly wrapping an Int into a List is worse than useless. It won't do anything Raku can't do natively, and will likely **remove** some functionality that it would normally have. That being said, just because it is a bad idea (in Raku) doesn't mean it can't be done.\n\nIn Raku, bind is essentially map. I'll shadow map here but again, it **removes** capability, not adds it. Raku also provided \"hyper\" operators which will descend into data structures and apply an operator / function to each member of that data structure.\n\nHere's a simple, if contrived example. take the numbers from 0 to 9, add 3 to each, find the divisors of those sums and print the list of divisors for each sum... in base 2. Again, a bind function was implemented but it is more limited than if we just used map directly. The built in map method will work with either items or lists, here we need to implement a multi sub to handle either.\n\nThe \\* in the bind blocks are typically referred to as \"whatever\"; whatever + 3 etc. The guillemot (») is the hyper operator; descend into the data structure and apply the following operator/function to each member.\n\n```\nmulti bind (@list, &code) { @list.map: &code };\n\nmulti bind ($item, &code) { $item.&code };\n\nsub divisors (Int $int) { gather for 1 .. $int { .take if $int %% $_ } }\n\nput (^10).&bind(* + 3).&bind(&divisors)».&bind(*.base: 2).join: \"\\n\";\n\n```\n\nOutput:\n\n```\n1 11\n1 10 100\n1 101\n1 10 11 110\n1 111\n1 10 100 1000\n1 11 1001\n1 10 101 1010\n1 1011\n1 10 11 100 110 1100\n```"}]}
{"messages": [{"role": "user", "content": "Demonstrate in your programming language the following:\n\n1. Construct a Maybe Monad by writing the 'bind' function and the 'unit' (sometimes known as 'return') function for that Monad (or just use what the language already has implemented)\n2. Make two functions, each which take a number and return a monadic number, e.g. Int -> Maybe Int and Int -> Maybe String\n3. Compose the two functions with bind\n\nA Monad is a single type which encapsulates several other types, eliminating boilerplate code. In practice it acts like a dynamically typed computational sequence, though in many cases the type issues can be resolved at compile time.\n\nA Maybe Monad is a monad which specifically encapsulates the type of an undefined value."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\nIt is exceptionally difficult to come up with a compelling valuable use for\na Maybe monad in Raku. Monads are most useful in languages that don't have\nexceptions and/or only allow a single point of entry/exit from a subroutine.\n\nThere are very good reasons to have those restrictions. It makes it much less\ncomplex to reason about a programs correctness and actually *prove* that a\nprogram is correct, but those restrictions also lead to oddities like Monads,\njust as a way to work around those restrictions.\n\nThe task description asks for two functions that take an Int and return a Maybe\nInt or Maybe Str, but those distinctions are nearly meaningless in Raku. See\nbelow.\n\n```\nmy $monad = <42>;\nsay 'Is $monad an Int?: ', $monad ~~ Int;\nsay 'Is $monad a  Str?: ', $monad ~~ Str;\nsay 'Wait, what? What exactly is $monad?: ', $monad.^name;\n\n```\n\nOutput:\n\n```\nIs $monad an Int?: True\nIs $monad a  Str?: True\nWait, what? What exactly is $monad?: IntStr\n```\n\n$monad is both an Int **and** a Str. It exists in a sort-of quantum state\nwhere what-it-is depends on how-it-is-used. Bolting on some 'Monad' type to do\nthis will only *remove* functionality that Raku already has.\n\nOk, say you have a situation where you absolutely do not want an incalculable\nvalue to halt processing. (In a web process perhaps.) In that case, it *might*\nbe useful to subvert the normal exception handler and just return a \"Nothing\"\ntype. Any routine that needs to be able to handle a Nothing type will need to be\ninformed of it, but for the most part, that just means adding a multi-dispatch\ncandidate.\n\n```\n# Build a Nothing type. When treated as a string it returns the string 'Nothing'.\n# When treated as a Numeric, returns the value 'Nil'.\nclass NOTHING {\n    method Str { 'Nothing' }\n    method Numeric { Nil }\n}\n\n# A generic instance of a Nothing type.\nmy \\Nothing = NOTHING.new;\n\n# A reimplementation of the square-root function. Could just use the CORE one\n# but this more fully shows how multi-dispatch candidates are added.\n\n# Handle positive numbers & 0\nmulti root (Numeric $n where * >= 0) { $n.sqrt }\n# Handle Negative numbers (Complex number handling is built in.)\nmulti root (Numeric $n where * <  0) { $n.Complex.sqrt }\n# Else return Nothing\nmulti root ($n) { Nothing }\n\n# Handle numbers > 0\nmulti ln (Real $n where * > 0) { log $n, e }\n# Else return Nothing\nmulti ln ($n) { Nothing }\n\n# Handle fraction where the denominator != 0\nmulti recip (Numeric $n where * != 0) { 1/$n }\n# Else return Nothing\nmulti recip ($n) { Nothing }\n\n# Helper formatting routine\nsub center ($s) {\n    my $pad = 21 - $s.Str.chars;\n    ' ' x ($pad / 2).floor ~ $s ~ ' ' x ($pad / 2).ceiling;\n}\n\n# Display the \"number\" the reciprocal, the root, natural log and the 3 functions\n# composed together.\nput ('\"Number\"', 'Reciprocal', 'Square root', 'Natural log', 'Composed')».&center;\n\n# Note how it handles the last two \"values\". The string 'WAT' is not numeric at\n# all; but Ethiopic number 30, times vulgar fraction 1/7, is.\nput ($_, .&recip, .&root, .&ln, .&(&ln o &root o &recip) )».&center\n  for -2, -1, -0.5, 0, exp(-1), 1, 2, exp(1), 3, 4, 5, 'WAT', ፴ × ⅐;\n\n```\n\nOutput:\n\n```\n      \"Number\"             Reciprocal            Square root           Natural log            Composed       \n         -2                   -0.5          0+1.4142135623730951i        Nothing               Nothing       \n         -1                    -1                   0+1i                 Nothing               Nothing       \n        -0.5                   -2           0+0.7071067811865476i        Nothing               Nothing       \n          0                  Nothing                  0                  Nothing               Nothing       \n 0.36787944117144233    2.718281828459045    0.6065306597126334            -1                    0.5         \n          1                     1                     1                     0                     0          \n          2                    0.5           1.4142135623730951    0.6931471805599453    -0.3465735902799726 \n  2.718281828459045    0.36787944117144233   1.6487212707001282             1                   -0.5         \n          3                 0.333333         1.7320508075688772    1.0986122886681098    -0.5493061443340549 \n          4                   0.25                    2            1.3862943611198906    -0.6931471805599453 \n          5                    0.2            2.23606797749979     1.6094379124341003    -0.8047189562170503 \n         WAT                 Nothing               Nothing               Nothing               Nothing       \n      4.285714              0.233333         2.0701966780270626     1.455287232606842    -0.727643616303421\n```"}]}
{"messages": [{"role": "user", "content": "The Writer monad is a programming design pattern which makes it possible to compose functions which return their result values paired with a log string. The final result of a composed function yields both a value, and a concatenation of the logs from each component function application.\n\nDemonstrate in your programming language the following:\n\n1. Construct a Writer monad by writing the 'bind' function and the 'unit' (sometimes known as 'return') function for that monad (or just use what the language already provides)\n2. Write three simple functions: root, addOne, and half\n3. Derive Writer monad versions of each of these functions\n4. Apply a composition of the Writer versions of root, addOne, and half to the integer 5, deriving both a value for the Golden Ratio φ, and a concatenated log of the function applications (starting with the initial value, and followed by the application of root, etc.)"}, {"role": "assistant", "content": "Basic semantic borrowed from the Monads/List monad entry\n\n**Translation of**: Go\n\n```\n# 20200508 Raku programming solution\n\nclass Writer { has Numeric $.value ; has Str $.log }\n\nsub Bind (Writer \\v, &code) {\n   my \\n = v.value.&code;\n   Writer.new: value => n.value, log => v.log ~ n.log\n};\n\nsub Unit(\\v, \\s) { Writer.new: value=>v, log=>sprintf \"%-17s: %.12f\\n\",s,v}\n\nsub root(\\v) { Unit v.sqrt, \"Took square root\" }\n\nsub addOne(\\v) { Unit v+1, \"Added one\" }\n\nsub half(\\v) { Unit v/2, \"Divided by two\" }\n\nsay Unit(5, \"Initial value\").&Bind(&root).&Bind(&addOne).&Bind(&half).log;\n\n```\n\nOutput:\n\n```\nInitial value    : 5.000000000000\nTook square root : 2.236067977500\nAdded one        : 3.236067977500\nDivided by two   : 1.618033988750\n\n```"}]}
{"messages": [{"role": "user", "content": "A **Monte Carlo Simulation** is a way of approximating the value of a function\nwhere calculating the actual value is difficult or impossible.   \nIt uses random sampling to define constraints on the value\nand then makes a sort of \"best guess.\"\n\nA simple Monte Carlo Simulation can be used to calculate the value for \n\nπ\n{\\displaystyle {\\displaystyle \\pi }}\n.\n\nIf you had a circle and a square where the length of a side of the square\nwas the same as the diameter of the circle, the ratio of the area of the circle\nto the area of the square would be \n\nπ\n\n/\n4\n{\\displaystyle {\\displaystyle \\pi /4}}\n.\n\nSo, if you put this circle inside the square and select many random points\ninside the square, the number of points inside the circle\ndivided by the number of points inside the square and the circle\nwould be approximately \n\nπ\n\n/\n4\n{\\displaystyle {\\displaystyle \\pi /4}}\n.\n\nTask\n\nWrite a function to run a simulation like this, with a variable number of random points to select.\n\nAlso, show the results of a few different sample sizes.\n\nFor software where the number \n\nπ\n{\\displaystyle {\\displaystyle \\pi }}\n is not built-in,\nwe give \n\nπ\n{\\displaystyle {\\displaystyle \\pi }}\n as a number of digits:\n\n```\n            3.141592653589793238462643383280\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-24\n\nWe'll consider the upper-right quarter of the unitary disk centered at the origin. Its area is \n\nπ\n4\n{\\displaystyle {\\displaystyle \\pi \\over 4}}\n.\n\n```\nmy @random_distances = ([+] rand**2 xx 2) xx *;\n\nsub approximate_pi(Int $n) {\n    4 * @random_distances[^$n].grep(* < 1) / $n\n}\n\nsay \"Monte-Carlo π approximation:\";\nsay \"$_ iterations:  \", approximate_pi $_\n    for 100, 1_000, 10_000;\n\n```\n\nOutput:\n\n```\nMonte-Carlo π approximation:\n100 iterations:  2.88\n1000 iterations:  3.096\n10000 iterations:  3.1168\n```\n\nWe don't really need to write a function, though. A lazy list would do:\n\n```\nmy @pi = ([\\+] 4 * (1 > [+] rand**2 xx 2) xx *) Z/ 1 .. *;\nsay @pi[10, 1000, 10_000];\n\n```"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nImplement the Montgomery reduction algorithm, as explained in \"Handbook of Applied Cryptography, Section 14.3.2, page 600. Montgomery reduction calculates \n\nT\n\nR\n\n−\n1\n\nm\no\nd\nm\n{\\displaystyle {\\displaystyle TR^{-1}\\mathrm {mod} m}}\n, without having to divide by \n\nm\n{\\displaystyle {\\displaystyle m}}\n.\n\n* Let \n\n  M\n  {\\displaystyle {\\displaystyle M}}\n   be a positive integer, and \n\n  R\n  {\\displaystyle {\\displaystyle R}}\n   and \n\n  T\n  {\\displaystyle {\\displaystyle T}}\n   integers such that \n\n  R\n  >\n  m\n  {\\displaystyle {\\displaystyle R>m}}\n  , \n\n  g\n  c\n  d\n  (\n  m\n  ,\n  R\n  )\n  =\n  1\n  {\\displaystyle {\\displaystyle \\mathrm {gcd} (m,R)=1}}\n  , and \n\n  0\n  ≤\n  T\n  <\n  m\n  R\n  {\\displaystyle {\\displaystyle 0\\leq T<mR}}\n  .\n* R\n  {\\displaystyle {\\displaystyle R}}\n   is usually chosen as \n\n  b\n\n  n\n  {\\displaystyle {\\displaystyle b^{n}}}\n  , where \n\n  b\n  {\\displaystyle {\\displaystyle b}}\n   = base (radix) in which the numbers in the calculation as represented in (so \n\n  b\n  =\n  10\n  {\\displaystyle {\\displaystyle b=10}}\n   in ‘normal’ paper arithmetic, \n\n  b\n  =\n  2\n  {\\displaystyle {\\displaystyle b=2}}\n   for computer implementations) and \n\n  n\n  {\\displaystyle {\\displaystyle n}}\n   = number of digits in base \n\n  m\n  {\\displaystyle {\\displaystyle m}}\n* The numbers \n\n  m\n  {\\displaystyle {\\displaystyle m}}\n   (\n\n  n\n  {\\displaystyle {\\displaystyle n}}\n   digits long), \n\n  T\n  {\\displaystyle {\\displaystyle T}}\n   (\n\n  2\n  n\n  {\\displaystyle {\\displaystyle 2n}}\n   digits long), \n\n  R\n  {\\displaystyle {\\displaystyle R}}\n  , \n\n  b\n  {\\displaystyle {\\displaystyle b}}\n  , \n\n  n\n  {\\displaystyle {\\displaystyle n}}\n   are known entities, a number \n\n  m\n  ′\n  {\\displaystyle {\\displaystyle m'}}\n   (often represented as `m_dash` in code) = \n\n  −\n\n  m\n\n  −\n  1\n\n  m\n  o\n  d\n  b\n  {\\displaystyle {\\displaystyle -m^{-1}\\mathrm {mod} b}}\n   is precomputed.\n\nSee the Handbook of Applied Cryptography for brief introduction to theory and numerical example in radix 10. Individual chapters of the book can be viewed online as provided by the authors. The said algorithm can be found at [1] at page 600 (page 11 of pdf file)\n\nAlgorithm:\n\n```\nA ← T (temporary variable)\nFor i from 0 to (n-1) do the following:\n   ui ← ai* m' mod b      // ai is the ith digit of A, ui is a single digit number in radix b\n   A ← A + ui*m*bi\nA ← A/bn\nif A >= m,\n   A ← A - m\nReturn (A)\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n**Translation of**: Sidef\n\n```\nsub montgomery-reduce($m, $a is copy) {\n    for 0..$m.msb {\n        $a += $m if $a +& 1;\n        $a +>= 1\n    }\n    $a % $m\n}\n\nmy $m  = 750791094644726559640638407699;\nmy $t1 = 323165824550862327179367294465482435542970161392400401329100;\n\nmy $r1 = 440160025148131680164261562101;\nmy $r2 = 435362628198191204145287283255;\n\nmy $x1 = 540019781128412936473322405310;\nmy $x2 = 515692107665463680305819378593;\n\nsay \"Original x1:       \", $x1;\nsay \"Recovered from r1: \", montgomery-reduce($m, $r1);\nsay \"Original x2:       \", $x2;\nsay \"Recovered from r2: \", montgomery-reduce($m, $r2);\n\nprint \"\\nMontgomery  computation x1**x2 mod m: \";\nmy $prod = montgomery-reduce($m, $t1/$x1);\nmy $base = montgomery-reduce($m, $t1);\n\nfor $x2, {$_ +> 1} ... 0 -> $exponent {\n    $prod = montgomery-reduce($m, $prod * $base) if $exponent +& 1;\n    $base = montgomery-reduce($m, $base * $base);\n}\n\nsay montgomery-reduce($m, $prod);\nsay \"Built-in op computation x1**x2 mod m: \", $x1.expmod($x2, $m);\n\n```\n\nOutput:\n\n```\nOriginal x1:       540019781128412936473322405310\nRecovered from r1: 540019781128412936473322405310\nOriginal x2:       515692107665463680305819378593\nRecovered from r2: 515692107665463680305819378593\n\nMontgomery  computation x1**x2 mod m: 151232511393500655853002423778\nBuilt-in op computation x1**x2 mod m: 151232511393500655853002423778\n\n```"}]}
{"messages": [{"role": "user", "content": "Suppose you're on a game show and you're given the choice of three doors.\n\nBehind one door is a car; behind the others, goats.\n\nThe car and the goats were placed randomly behind the doors before the show.\n\nRules of the game\n\nAfter you have chosen a door, the door remains closed for the time being.\n\nThe game show host, Monty Hall, who knows what is behind the doors, now has to open one of the two remaining doors, and the door he opens must have a goat behind it.\n\nIf both remaining doors have goats behind them, he chooses one randomly.\n\nAfter Monty Hall opens a door with a goat, he will ask you to decide whether you want to stay with your first choice or to switch to the last remaining door.\n\nImagine that you chose Door 1 and the host opens Door 3, which has a goat.\n\nHe then asks you \"Do you want to switch to Door Number 2?\"\n\nThe question\n\nIs it to your advantage to change your choice?\n\nNote\n\nThe player may initially choose any of the three doors (not just Door 1), that the host opens a different door revealing a goat (not necessarily Door 3), and that he gives the player a second choice between the two remaining unopened doors.\n\nTask\n\nRun random simulations of the Monty Hall game. Show the effects of a strategy of the contestant always keeping his first guess so it can be contrasted with the strategy of the contestant always switching his guess.\n\nSimulate at least a thousand games using three doors for each strategy and show the results in such a way as to make it easy to compare the effects of each strategy.\n\nReferences\n:   * Stefan Krauss, X. T. Wang, \"The psychology of the Monty Hall problem: Discovering psychological mechanisms for solving a tenacious brain teaser.\", Journal of Experimental Psychology: General, Vol 132(1), Mar 2003, 3-22 DOI: 10.1037/0096-3445.132.1.3\n    * A YouTube video:   Monty Hall Problem - Numberphile."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\nThis implementation is parametric over the number of doors. Increasing the number of doors in play makes the superiority of the switch strategy even more obvious.\n\n```\nenum Prize <Car Goat>;\nenum Strategy <Stay Switch>;\n \nsub play (Strategy $strategy, Int :$doors = 3) returns Prize {\n \n    # Call the door with a car behind it door 0. Number the\n    # remaining doors starting from 1.\n    my Prize @doors = flat Car, Goat xx $doors - 1;\n \n    # The player chooses a door.\n    my Prize $initial_pick = @doors.splice(@doors.keys.pick,1)[0];\n \n    # Of the n doors remaining, the host chooses n - 1 that have\n    # goats behind them and opens them, removing them from play.\n    while @doors > 1 {\n\t@doors.splice($_,1)\n\t    when Goat\n\t\tgiven @doors.keys.pick;\n    }\n \n    # If the player stays, they get their initial pick. Otherwise,\n    # they get whatever's behind the remaining door.\n    return $strategy === Stay ?? $initial_pick !! @doors[0];\n}\n \nconstant TRIALS = 10_000;\n \nfor 3, 10 -> $doors {\n    my atomicint @wins[2];\n    say \"With $doors doors: \";\n    for Stay, 'Staying', Switch, 'Switching' -> $s, $name {\n        (^TRIALS).race.map: {\n            @wins[$s]⚛++ if play($s, doors => $doors) == Car;\n        }\n        say \"  $name wins \",\n            round(100*@wins[$s] / TRIALS),\n            '% of the time.'\n    }\n}\n\n```\n\nOutput:\n\n```\nWith 3 doors: \n  Staying wins 34% of the time.\n  Switching wins 66% of the time.\nWith 10 doors: \n  Staying wins 10% of the time.\n  Switching wins 90% of the time.\n```"}]}
{"messages": [{"role": "user", "content": "Morse code is one of the simplest and most versatile methods of telecommunication in existence.\nIt has been in use for more than 175 years — longer than any other electronic encoding system.\n\nTask\n\nSend a string as audible Morse code to an audio device   (e.g., the PC speaker).\n\nAs the standard Morse code does not contain all possible characters,\nyou may either ignore unknown characters in the file,\nor indicate them somehow   (e.g. with a different pitch)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-24\n\nHere we use the user as the audio device.\nJust read the output, leaving extra pauses where indicated\nby either whitespace or underscore.\n\n```\nmy %m = ' ', '_ _ ',\n|<\n    !\t---.\n    \"\t.-..-.\n    $\t...-..-\n    '\t.----.\n    (\t-.--.\n    )\t-.--.-\n    +\t.-.-.\n    ,\t--..--\n    -\t-....-\n    .\t.-.-.-\n    /\t-..-.\n    :\t---...\n    ;\t-.-.-.\n    =\t-...-\n    ?\t..--..\n    @\t.--.-.\n    [\t-.--.\n    ]\t-.--.-\n    _\t..--.-\n    0\t-----\n    1\t.----\n    2\t..---\n    3\t...--\n    4\t....-\n    5\t.....\n    6\t-....\n    7\t--...\n    8\t---..\n    9\t----.\n    A\t.-\n    B\t-...\n    C\t-.-.\n    D\t-..\n    E\t.\n    F\t..-.\n    G\t--.\n    H\t....\n    I\t..\n    J\t.---\n    K\t-.-\n    L\t.-..\n    M\t--\n    N\t-.\n    O\t---\n    P\t.--.\n    Q\t--.-\n    R\t.-.\n    S\t...\n    T\t-\n    U\t..-\n    V\t...-\n    W\t.--\n    X\t-..-\n    Y\t-.--\n    Z\t--..\n>.map: -> $c, $m is copy {\n    $m.=subst(rx/'-'/, 'BGAAACK!!! ', :g);\n    $m.=subst(rx/'.'/, 'buck ', :g);\n    $c => $m ~ '_';\n}\n\nsay prompt(\"Gimme a string: \").uc.comb.map: { %m{$_} // \"<scratch> \" }\n\n```\n\nSample run:\n\nGimme a string: **Howdy, World!**\n  \nbuck buck buck buck \\_ BGAAACK!!! BGAAACK!!! BGAAACK!!! \\_ buck BGAAACK!!! BGAAACK!!! \\_ BGAAACK!!! buck buck \\_ BGAAACK!!! buck BGAAACK!!! BGAAACK!!! \\_ BGAAACK!!! BGAAACK!!! buck buck BGAAACK!!! BGAAACK!!! \\_ \\_ \\_ buck BGAAACK!!! BGAAACK!!! \\_ BGAAACK!!! BGAAACK!!! BGAAACK!!! \\_ buck BGAAACK!!! buck \\_ buck BGAAACK!!! buck buck \\_ BGAAACK!!! buck buck \\_ BGAAACK!!! BGAAACK!!! BGAAACK!!! buck \\_"}]}
{"messages": [{"role": "user", "content": "Task\n\nDraw a 'mosaic' matrix which, for the purposes of this task, is a square matrix which has 1's in alternate cells (both horizontally and vertically) starting with a 1 in the top-left hand cell.\n\nOther cells can either be left blank or filled with some other character.\n  \nIf you can please use GUI\n  \nMosaic Matrix - image\n\n### See also\n\n* Four sides of square\n* Matrix with two diagonals"}, {"role": "assistant", "content": "This isn't a matrix, especially if it is supposed to be graphical; it's a very small (or extremely low resolution) bitmap.\n\n```\nsub checker ($n) { (^$n).map: { 1 xx $n Z× (flat ($_ %% 2, $_ % 2) xx *) } }\n\n.put for checker 7;\nput '';\n.put for checker 8;\n\n```\n\nOutput:\n\n```\n1 0 1 0 1 0 1\n0 1 0 1 0 1 0\n1 0 1 0 1 0 1\n0 1 0 1 0 1 0\n1 0 1 0 1 0 1\n0 1 0 1 0 1 0\n1 0 1 0 1 0 1\n\n1 0 1 0 1 0 1 0\n0 1 0 1 0 1 0 1\n1 0 1 0 1 0 1 0\n0 1 0 1 0 1 0 1\n1 0 1 0 1 0 1 0\n0 1 0 1 0 1 0 1\n1 0 1 0 1 0 1 0\n0 1 0 1 0 1 0 1\n```"}]}
{"messages": [{"role": "user", "content": "The string distance function (SDF) that is the subject of this entry\nwas proposed in a paper published in 2014 as a method for quickly\nestimating how similar two\nordered sets or\nstrings are.\nThis SDF has also been proposed as being suitable in bioinformatics, e.g. for comparing sequences in the wp:fasta format.\n\nUnfortunately, the original paper\nby Sadi Evren Seker et al.\n(arXiv:1401.6596 [cs.DS])\n[1]\nhas a number of internal inconsistencies and for this and other\nreasons is not entirely clear in several key respects, but the paper\ndoes give some worked examples and several of these (notably the two\ngiven under the \"Worked Examples\" heading below) agree with the\ninterpretation used by the authors of the Python entry herein, so that\ninterpretation is used in the present task description.\n\nThe Task\n\n(a) Show a time-efficient implementation of the SDF as if by a\nfunction mostFreqKSDF(s1, s2, k, n), where s1 and s2 are arbitrary\nstrings, and k and n are non-negative integers as explained below;\n\n(b) Show the values produced by the SDF for the following values of s1 and s2,\nwith k = 2 and n = 10:\n\n| String Inputs | \"Top Two\" | SDF Output (k=2, n=10) |\n| --- | --- | --- |\n| 'night' 'nacht' | n:1 i:1 n:1 a:1 | 8 |\n| 'my' 'a' | m:1 y:1 a:1 | 10 |\n| ‘research’ ‘research’ | r:2 e:2 r:2 e:2 | 2 |\n| ‘significant’ ‘capabilities’ | i:3 n:2 i:3 a:2 | 4 |\n\n(c) Show the value produced by the SDF for k = 2, n = 100,\nand the two strings:\n\n\"LCLYTHIGRNIYYGSYLYSETWNTGIMLLLITMATAFMGYVLPWGQMSFWGATVITNLFSAIPYIGTNLV\"\n\"EWIWGGFSVDKATLNRFFAFHFILPFTMVALAGVHLTFLHETGSNNPLGLTSDSDKIPFHPYYTIKDFLG\"\n\nReference Algorithm\n\nThe original paper employs an unusual scheme for encoding the\nfrequencies of single letters as a string of letters and numbers. This\nscheme has several disadvantages, and so in the following we take a\nmore abstract view and simply assume, solely for the purposes\nof this description, that two functions are available:\n\n1) MostFreqK(s, k) returns (in decreasing order of their frequency of occurrence)\nthe k most frequently occurring letters in s, with\nany ties broken by the position of the first occurrence in s;\n\n2) For any letter c in MostFreqK(s, k), Freq(s,c) returns the frequency\nof c in s.\n\nMFKsimilarity\n\nNext define MFKsimilarlity(s1, s2, k) as if by the following pseudo-code:\n\n```\nint function MFKsimilarity(string s1, string s2, int k):\n    let similarity = 0\n    let mfk1 = MostFreqK(s1, k)\n    let mfk2 = MostFreqK(s2, k)\n    for each c in mfk1\n        if (c occurs in mfk2) \n        then similarity += Freq(s1, c) + Freq(s2, c)\n\tend\n    return similarity\n\n```\n\nString Distance Wrapper Function\n\nNow define MostFreqKSDF as if by:\n\n```\nint function MostFreqKSDF(string s1, string s2, int k, int n)\n    return n - MFKsimilarity(s1, s2, k)\n\n```\n\nWorked Examples\n\nThe original paper gives several worked examples, including\nthese two:\n\n(i) MostFreqKSDF(\"night\", \"nacht\", 2, 10)\n\nFor \"night\", the \"top two\" letters with their frequencies are: n:1 and i:1.\n\nFor \"nacht\", the \"top two\" letters with their frequencies are: n:1 and a:1.\n\nSince \"n\" is the only shared letter amongst these candidates, the\nSDF is 10 - 1 - 1 = 8, as per the original paper.\n\n(2)\nMostFreqKSDF(\n\"LCLYTHIGRNIYYGSYLYSETWNTGIMLLLITMATAFMGYVLPWGQMSFWGATVITNLFSAIPYIGTNLV\",\n\"EWIWGGFSVDKATLNRFFAFHFILPFTMVALAGVHLTFLHETGSNNPLGLTSDSDKIPFHPYYTIKDFLG\",\n2, 100)\n\nFor the first string, the \"top two\" letters with their frequencies are: L:9 and T:8;\nand for the second, the \"top two\" are F:9 and L:8.\n\nSince \"L\" is the only shared letter amongst these top-k characters, and since the sum of the corresponding frequencies is 9+8 = 17, the SDF is 83."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nMy initial impressions of this task are registered on the discussion page under \"Prank Page?\".\n\nThe \"most frequent k characters\" hashing function is straightforward enough to implement. The distance function is incomprehensible though. The description doesn't match the pseudo-code and neither of them match the examples. I'm not going to bother trying to figure it out unless there is some possible value.\n\nMaybe I am too hasty though. Lets give it a try. Implement a MFKC routine and run an assortment of words through it to get a feel for how it hashes different words.\n\n```\n# Fairly straightforward implementation, actually returns a list of pairs\n# which can be joined to make a string or manipulated further.\n\nsub mfkh ($string, \\K = 2) {\n    my %h;\n    $string.comb.kv.map: { %h{$^v}[1] //= $^k; %h{$^v}[0]++ };\n    %h.sort( { -$_.value[0], $_.value[1] } ).head(K).map( { $_.key => $_.value[0] } );\n}\n\n# lets try running 150 or so words from unixdic.txt through it to see\n# how many unique hash values it comes up with.\n\nmy @test-words = <\n    aminobenzoic arginine asinine biennial biennium brigantine brinkmanship\n    britannic chinquapin clinging corinthian declination dickinson dimension\n    dinnertime dionysian diophantine dominican financial financier finessing\n    fingernail fingerprint finnish giovanni hopkinsian inaction inalienable\n    inanimate incaution incendiary incentive inception incident incidental\n    incinerate incline inclusion incommunicable incompletion inconceivable\n    inconclusive incongruity inconsiderable inconsiderate inconspicuous\n    incontrovertible inconvertible incurring incursion indefinable indemnify\n    indemnity indeterminacy indian indiana indicant indifferent indigene\n    indigenous indigent indispensable indochina indochinese indoctrinate\n    indonesia inequivalent inexplainable infantile inferential inferring\n    infestation inflammation inflationary influential information infringe\n    infusion ingenious ingenuity ingestion ingredient inhabitant inhalation\n    inharmonious inheritance inholding inhomogeneity inkling inoffensive\n    inordinate inorganic inputting inseminate insensible insincere insinuate\n    insistent insomnia insomniac insouciant installation instinct instinctual\n    insubordinate insubstantial insulin insurrection intangible intelligent\n    intensify intensive interception interruption intestinal intestine\n    intoxicant introduction introversion intrusion invariant invasion inventive\n    inversion involution justinian kidnapping kingpin lineprinter liniment\n    livingston mainline mcginnis minion minneapolis minnie pigmentation\n    pincushion pinion quinine quintessential resignation ruination seminarian\n    triennial wilkinson wilmington wilsonian wineskin winnie winnipeg  \n>;\n\nsay @test-words.map( { join '', mfkh($_)».kv } ).Bag;\n\n```\n\nOutput:\n\n```\nBag(i2n2(151))\n```\n\nOne... Nope, I was right, it *is* pretty much worthless."}]}
{"messages": [{"role": "user", "content": "Definition\n\nThe **n**th Motzkin number (denoted by M[n]) is the number of different ways of drawing non-intersecting chords between **n** points on a circle (not necessarily touching every point by a chord).\n\nBy convention M[0] = 1.\n\nTask\n\nCompute and show on this page the first **42** Motzkin numbers or, if your language does not support 64 bit integers, as many such numbers as you can. Indicate which of these numbers are prime.\n\nSee also\n\n* oeis:A001006 Motzkin numbers"}, {"role": "assistant", "content": "### Using binomial coefficients and Catalan numbers\n\n```\nuse Lingua::EN::Numbers;\n\nconstant \\C = 1, |[\\×] (2, 6 … ∞) Z/ 2 .. *;\n\nsub binomial { [×] ($^n … 0) Z/ 1 .. $^p }\n\nmy \\𝐌 = 1, |(1..∞).map: -> \\𝐧 { sum ^𝐧 .map( -> \\𝐤 { C[𝐤] × binomial 𝐧, 2×𝐤 } ) };\n\nsay \" 𝐧          𝐌[𝐧]            Prime?\";\n𝐌[^42].kv.map: { printf \"%2d %24s  %s\\n\", $^k, $^v.&comma, $v.is-prime };\n\n```\n\nOutput:\n\n```\n 𝐧          𝐌[𝐧]            Prime?\n 0                        1  False\n 1                        1  False\n 2                        2  True\n 3                        4  False\n 4                        9  False\n 5                       21  False\n 6                       51  False\n 7                      127  True\n 8                      323  False\n 9                      835  False\n10                    2,188  False\n11                    5,798  False\n12                   15,511  True\n13                   41,835  False\n14                  113,634  False\n15                  310,572  False\n16                  853,467  False\n17                2,356,779  False\n18                6,536,382  False\n19               18,199,284  False\n20               50,852,019  False\n21              142,547,559  False\n22              400,763,223  False\n23            1,129,760,415  False\n24            3,192,727,797  False\n25            9,043,402,501  False\n26           25,669,818,476  False\n27           73,007,772,802  False\n28          208,023,278,209  False\n29          593,742,784,829  False\n30        1,697,385,471,211  False\n31        4,859,761,676,391  False\n32       13,933,569,346,707  False\n33       40,002,464,776,083  False\n34      114,988,706,524,270  False\n35      330,931,069,469,828  False\n36      953,467,954,114,363  True\n37    2,750,016,719,520,991  False\n38    7,939,655,757,745,265  False\n39   22,944,749,046,030,949  False\n40   66,368,199,913,921,497  False\n41  192,137,918,101,841,817  False\n```\n\n### Using recurrence relationship\n\n```\nuse Lingua::EN::Numbers;\n\nmy \\𝐌 = 1, 1, { state $i = 2; ++$i; ($^b × (2 × $i - 1) + $^a × (3 × $i - 6)) ÷ ($i + 1) } … *;\n\nsay \" 𝐧          𝐌[𝐧]            Prime?\";\n𝐌[^42].kv.map: { printf \"%2d %24s  %s\\n\", $^k, $^v.&comma, $v.is-prime };\n\n```\n\nSame output"}]}
{"messages": [{"role": "user", "content": "Task\n\nGet the current location of the mouse cursor relative to the active window.\n\nPlease specify if the window may be externally created."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo/jvm version 2013-12-03\n\n```\nuse java::awt::MouseInfo:from<java>;\n\ngiven MouseInfo.getPointerInfo.getLocation {\n    say .getX, 'x', .getY;\n}\n\n```\n\nAn implementation that will work on any X11 windowing system. Reports mouse position, window ID# and window name for whichever window the mouse pointer is over. Automatically moves mouse for hands-off testing purposes.\n\n**Works with**: Rakudo version 2018.11\n\n```\nuse X11::libxdo;\nmy $xdo = Xdo.new;\n\nmy ($dw, $dh) = $xdo.get-desktop-dimensions( 0 );\n\nsleep .25;\n\nfor ^$dw -> $mx {\n    my $my = (($mx / $dh * τ).sin * 500).abs.Int + 200;\n    $xdo.move-mouse( $mx, $my, 0 );\n    my ($x, $y, $window-id, $screen) = $xdo.get-mouse-info;\n    my $name = (try $xdo.get-window-name($window-id) if $window-id)\n       // 'No name set';\n\n    my $line = \"Mouse location: x=$x : y=$y\\nWindow under mouse:\\nWindow ID: \" ~\n       $window-id ~ \"\\nWindow name: \" ~ $name ~ \"\\nScreen #: $screen\";\n\n    print \"\\e[H\\e[J\", $line;\n    sleep .001;\n}\n\nsay '';\n\n```"}]}
{"messages": [{"role": "user", "content": "Given a symbol table of a *zero-indexed* array of all possible input symbols\nthis algorithm reversibly transforms a sequence\nof input symbols into an array of output numbers (indices).\n\nThe transform in many cases acts to give frequently repeated input symbols\nlower indices which is useful in some compression algorithms.\n\nEncoding algorithm\n\n```\n    for each symbol of the input sequence:\n        output the index of the symbol in the symbol table\n        move that symbol to the front of the symbol table\n\n```\n\nDecoding algorithm\n\n```\n    # Using the same starting symbol table\n    for each index of the input sequence:\n        output the symbol at that index of the symbol table\n        move that symbol to the front of the symbol table\n\n```\n\nExample\n\nEncoding the string of character symbols 'broood' using a symbol table of the lowercase characters   **a**-to-**z**\n\n:   :   :   :   :   | Input | Output | SymbolTable |\n                    | --- | --- | --- |\n                    | **b**roood | 1 | 'abcdefghijklmnopqrstuvwxyz' |\n                    | b**r**oood | 1 17 | 'bacdefghijklmnopqrstuvwxyz' |\n                    | br**o**ood | 1 17 15 | 'rbacdefghijklmnopqstuvwxyz' |\n                    | bro**o**od | 1 17 15 0 | 'orbacdefghijklmnpqstuvwxyz' |\n                    | broo**o**d | 1 17 15 0 0 | 'orbacdefghijklmnpqstuvwxyz' |\n                    | brooo**d** | 1 17 15 0 0 5 | 'orbacdefghijklmnpqstuvwxyz' |\n\nDecoding the indices back to the original symbol order:\n\n:   :   :   :   :   | Input | Output | SymbolTable |\n                    | --- | --- | --- |\n                    | **1** 17 15 0 0 5 | b | 'abcdefghijklmnopqrstuvwxyz' |\n                    | 1 **17** 15 0 0 5 | br | 'bacdefghijklmnopqrstuvwxyz' |\n                    | 1 17 **15** 0 0 5 | bro | 'rbacdefghijklmnopqstuvwxyz' |\n                    | 1 17 15 **0** 0 5 | broo | 'orbacdefghijklmnpqstuvwxyz' |\n                    | 1 17 15 0 **0** 5 | brooo | 'orbacdefghijklmnpqstuvwxyz' |\n                    | 1 17 15 0 0 **5** | broood | 'orbacdefghijklmnpqstuvwxyz' |\n\nTask\n:   * Encode and decode the following three strings of characters using the symbol table of the lowercase characters   **a**-to-**z**   as above.\n    * Show the strings and their encoding here.\n    * Add a check to ensure that the decoded string is the same as the original.\n\nThe strings are:\n\n```\n   broood          \n   bananaaa     \n   hiphophiphop  \n\n```\n\n(Note the misspellings in the above strings.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-24\n\n```\nsub encode ( Str $word ) {\n    my @sym = 'a' .. 'z';\n    gather for $word.comb -> $c {\n\tdie \"Symbol '$c' not found in @sym\" if $c eq @sym.none;\n        @sym[0 .. take (@sym ... $c).end] .= rotate(-1);\n    }\n}\n \nsub decode ( @enc ) {\n    my @sym = 'a' .. 'z';\n    [~] gather for @enc -> $pos {\n        take @sym[$pos];\n        @sym[0..$pos] .= rotate(-1);\n    }\n}\n \nuse Test;\nplan 3;\nfor <broood bananaaa hiphophiphop> -> $word {\n    my $enc = encode($word);\n    my $dec = decode($enc);\n    is $word, $dec, \"$word.fmt('%-12s') ($enc[])\";\n}\n\n```\n\nOutput:\n\n```\n1..3\nok 1 - broood       (1 17 15 0 0 5)\nok 2 - bananaaa     (1 1 13 1 1 1 0 0)\nok 3 - hiphophiphop (7 8 15 2 15 2 2 3 2 2 3 2)\n```"}]}
{"messages": [{"role": "user", "content": "Prime numbers are prime no matter what base they are represented in.\n\nA prime number in a base other than 10 may not *look* prime at first glance.\n\nFor instance: **19** base 10 is **25** in base 7.\n\nSeveral different prime numbers may be expressed as the \"same\" string when converted to a different base.\n\n* **107** base **10** converted to base **6** == **255**\n\n* **173** base **10** converted to base **8** == **255**\n\n* **353** base **10** converted to base **12** == **255**\n\n* **467** base **10** converted to base **14** == **255**\n\n* **743** base **10** converted to base **18** == **255**\n\n* **1277** base **10** converted to base **24** == **255**\n\n* **1487** base **10** converted to base **26** == **255**\n\n* **2213** base **10** converted to base **32** == **255**\n\nTask\n\nRestricted to bases **2** through **36**; find the strings that have the most different bases that evaluate to that string when converting prime numbers to a base.\n\nFind the conversion string, the amount of bases that evaluate a prime to that string and the enumeration of bases that evaluate a prime to that string.\n\nDisplay here, on this page, the string, the count and the list for all of the: **1** character, **2** character, **3** character, and **4** character strings that have the **maximum** base count that evaluate to that string.\n\n*Should be no surprise, the string '2' has the largest base count for single character strings.*\n\nStretch goal\n\nDo the same for the maximum **5** character string."}, {"role": "assistant", "content": "Up to 4 character strings finish fairly quickly. 5 character strings take a while.\n\n*All your base are belong to us. You have no chance to survive make your prime.*\n\n```\nuse Math::Primesieve;\nmy $sieve = Math::Primesieve.new;\n\nmy %prime-base;\n\nmy $chars = 4; # for demonstration purposes. Change to 5 for the whole shmegegge.\n \nmy $threshold = ('1' ~ 'Z' x $chars).parse-base(36);\n\nmy @primes = $sieve.primes($threshold);\n\n%prime-base.push: $_ for (2..36).map: -> $base {\n    $threshold = (($base - 1).base($base) x $chars).parse-base($base);\n    @primes[^(@primes.first: * > $threshold, :k)].race.map: { .base($base) => $base }\n}\n\n%prime-base.=grep: +*.value.elems > 10;\n\nfor 1 .. $chars -> $m {\n    say \"$m character strings that are prime in maximum bases: \" ~ (my $e = ((%prime-base.grep( *.key.chars == $m )).max: +*.value.elems).value.elems);\n    .say for %prime-base.grep( +*.value.elems == $e ).grep(*.key.chars == $m).sort: *.key;\n    say '';\n}\n\n```\n\nOutput:\n\n```\n1 character strings that are prime in maximum bases: 34\n2 => [3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36]\n\n2 character strings that are prime in maximum bases: 18\n21 => [3 5 6 8 9 11 14 15 18 20 21 23 26 29 30 33 35 36]\n\n3 character strings that are prime in maximum bases: 18\n131 => [4 5 7 8 9 10 12 14 15 18 19 20 23 25 27 29 30 34]\n551 => [6 7 11 13 14 15 16 17 19 21 22 24 25 26 30 32 35 36]\n737 => [8 9 11 12 13 15 16 17 19 22 23 24 25 26 29 30 31 36]\n\n4 character strings that are prime in maximum bases: 19\n1727 => [8 9 11 12 13 15 16 17 19 20 22 23 24 26 27 29 31 33 36]\n5347 => [8 9 10 11 12 13 16 18 19 22 24 25 26 30 31 32 33 34 36]\n\n5 character strings that are prime in maximum bases: 18\n30271 => [8 10 12 13 16 17 18 20 21 23 24 25 31 32 33 34 35 36]\n```\n\nYou can't really assume that the maximum string will be all numeric digits. It is just an accident that they happen to work out that way with a upper limit of base 36. If we do the same filtering using a maximum of base 62, we end up with several that contain alphabetics.\n\n```\nuse Math::Primesieve;\nuse Base::Any;\n\nmy $chars = 4;\nmy $check-base = 62;\nmy $threshold = $check-base ** $chars + 20;\n\nmy $sieve = Math::Primesieve.new;\nmy @primes = $sieve.primes($threshold);\n\nmy %prime-base;\n\n%prime-base.push: $_ for (2..$check-base).map: -> $base {\n    $threshold = (($base - 1).&to-base($base) x $chars).&from-base($base);\n    @primes[^(@primes.first: * > $threshold, :k)].race.map: { .&to-base($base) => $base }\n}\n\n%prime-base.=grep: +*.value.elems > 10;\n\nfor 1 .. $chars -> $m {\n    say \"$m character strings that are prime in maximum bases: \" ~ (my $e = ((%prime-base.grep( *.key.chars == $m )).max: +*.value.elems).value.elems);\n    .say for %prime-base.grep( +*.value.elems == $e ).grep(*.key.chars == $m).sort: *.key;\n    say '';\n}\n\n```\n\nYields:\n\n```\n1 character strings that are prime in maximum bases: 60\n2 => [3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62]\n\n2 character strings that are prime in maximum bases: 31\n65 => [7 8 9 11 13 14 16 17 18 21 22 24 27 28 29 31 32 37 38 39 41 42 43 44 46 48 51 52 57 58 59]\n\n3 character strings that are prime in maximum bases: 33\n1L1 => [22 23 25 26 27 28 29 30 31 32 33 34 36 38 39 40 41 42 43 44 45 46 48 51 52 53 54 57 58 59 60 61 62]\nB9B => [13 14 15 16 17 19 20 21 23 24 26 27 28 30 31 34 36 39 40 42 45 47 49 50 52 53 54 57 58 59 60 61 62]\n\n4 character strings that are prime in maximum bases: 32\n1727 => [8 9 11 12 13 15 16 17 19 20 22 23 24 26 27 29 31 33 36 37 38 39 41 45 46 48 50 51 57 58 60 61]\n417B => [12 13 15 16 17 18 19 21 23 25 28 30 32 34 35 37 38 39 41 45 48 49 50 51 52 54 56 57 58 59 61 62]\n```"}]}
{"messages": [{"role": "user", "content": "For the purposes of this task, the actual memory layout or access method of this data structure is not mandated.\n\nIt is enough to:\n\n1. State the number and extent of each index to the array.\n2. Provide specific, ordered, integer indices for all dimensions of the array together with a new value to update the indexed value.\n3. Provide specific, ordered, numeric indices for all dimensions of the array to obtain the arrays value at that indexed position.\n\nTask\n\n* State if the language supports multi-dimensional arrays in its syntax and usual implementation.\n* State whether the language uses row-major or column major order for multi-dimensional array storage, or any other relevant kind of storage.\n* Show how to create a four dimensional array in your language and set, access, set to another value; and access the new value of an integer-indexed item of the array.  \n   The idiomatic method for the language is preferred.\n\n:   * The array should allow a range of five, four, three and two (or two three four five if convenient), in each of the indices, in order. (For example, *if* indexing starts at zero for the first index then a range of 0..4 inclusive would suffice).\n\n* State if memory allocation is optimised for the array - especially if contiguous memory is likely to be allocated.\n* If the language has exceptional native multi-dimensional array support such as optional bounds checking, reshaping, or being able to state both the lower and upper bounds of index ranges, then this is the task to mention them.\n\nShow all output here, (but you may judiciously use ellipses to shorten repetitive output text)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# Raku supports multi dimension arrays natively. There are no arbitrary limits on the number of dimensions or maximum indices. Theoretically, you could have an infinite number of dimensions of infinite length, though in practice more than a few dozen dimensions gets unwieldy. An infinite maximum index is a fairly common idiom though. You can assign an infinite lazy list to an array and it will only produce the values when they are accessed.\n\nmy @integers = 1 .. Inf; # an infinite array containing all positive integers\n\nsay @integers[100000]; #100001 (arrays are zero indexed.)\n\n# Multi dimension arrays may be predeclared which constrains the indices to the declared size:\n\nmy @dim5[3,3,3,3,3];\n\n#Creates a preallocated 5 dimensional array where each branch has 3 storage slots and constrains the size to the declared size.\n#It can then be accessed like so:\n\n@dim5[0;1;2;1;0] = 'Raku';\n\nsay @dim5[0;1;2;1;0]; # prints 'Raku'\n\n#@dim5[0;1;2;1;4] = 'error'; # runtime error: Index 4 for dimension 5 out of range (must be 0..2)\n\n# Note that the dimensions do not _need_ to be predeclared / allocated. Raku will auto-vivify the necessary storage slots on first access.\n\nmy @a2;\n\n@a2[0;1;2;1;0] = 'Raku';\n\n@a2[0;1;2;1;4] = 'not an error';\n\n# It is easy to access array \"slices\" in Raku.\n\nmy @b = map { [$_ X~ 1..5] }, <a b c d>;\n\n.say for @b;\n# [a1 a2 a3 a4 a5]\n# [b1 b2 b3 b4 b5]\n# [c1 c2 c3 c4 c5]\n# [d1 d2 d3 d4 d5]\n\nsay @b[*;2]; # Get the all of the values in the third \"column\"\n# (a3 b3 c3 d3)\n\n# By default, Raku can store any object in an array, and it is not very compact. You can constrain the type of values that may be stored which can allow the optimizer to store them much more efficiently.\n\nmy @c = 1 .. 10; # Stores integers, but not very compactly since there are no constraints on what the values _may_ be\n\nmy uint16 @d = 1 .. 10 # Since there are and only can be unsigned 16 bit integers, the optimizer will use a much more compact memory layout.\n\n# Indices must be a positive integer. Negative indices are not permitted, fractional indices will be truncated to an integer.\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a program that finds and outputs the root of a system of nonlinear equations\nusing Newton-Raphson method."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# Reference:\n# https://github.com/pierre-vigier/Perl6-Math-Matrix\n# Mastering Algorithms with Perl\n# By Jarkko Hietaniemi, John Macdonald, Jon Orwant\n# Publisher: O'Reilly Media, ISBN-10: 1565923987\n# https://resources.oreilly.com/examples/9781565923980/blob/master/ch16/solve\n\nuse v6;\n\nsub solve_funcs ($funcs, @guesses, $iterations, $epsilon) {\n   my ($error_value, @values, @delta, @jacobian); my \\ε = $epsilon;\n   for 1 .. $iterations {\n      for ^+$funcs { @values[$^i] = $funcs[$^i](|@guesses); }\n      $error_value = 0;\n      for ^+$funcs { $error_value += @values[$^i].abs }\n      return @guesses if $error_value ≤ ε;\n      for ^+$funcs { @delta[$^i] = -@values[$^i] }\n      @jacobian = jacobian $funcs, @guesses, ε;\n      @delta = solve_matrix @jacobian, @delta;\n      loop (my $j = 0, $error_value = 0; $j < +$funcs; $j++) {\n         $error_value += @delta[$j].abs ;\n         @guesses[$j] += @delta[$j];\n      }\n      return @guesses if $error_value ≤ ε;\n   }\n   return @guesses;\n}\n\nsub jacobian ($funcs is copy, @points is copy, $epsilon is copy) {\n   my ($Δ, @P, @M, @plusΔ, @minusΔ);\n   my Array @jacobian; my \\ε = $epsilon;\n   for ^+@points -> $i {\n      @plusΔ = @minusΔ = @points;\n      $Δ = (ε * @points[$i].abs) || ε;\n      @plusΔ[$i] = @points[$i] + $Δ;\n      @minusΔ[$i] = @points[$i] - $Δ;\n      for ^+$funcs { @P[$^k] = $funcs[$^k](|@plusΔ); }\n      for ^+$funcs { @M[$^k] = $funcs[$^k](|@minusΔ); }\n      for ^+$funcs -> $j {\n         @jacobian[$j][$i] = (@P[$j] - @M[$j]) / (2 * $Δ);\n      }\n   }\n   return @jacobian;\n}\n\nsub solve_matrix (@matrix_array is copy, @delta is copy) {\n   # https://github.com/pierre-vigier/Perl6-Math-Matrix/issues/56\n   { use Math::Matrix;\n      my $matrix = Math::Matrix.new(@matrix_array);\n      my $vector = Math::Matrix.new(@delta.map({.list}));\n      die \"Matrix is not invertible\" unless $matrix.is-invertible;\n      my @result = ( $matrix.inverted dot $vector ).transposed;\n      return @result.split(\" \");\n   }\n}\n\nmy $funcs = [\n   { 9*$^x² + 36*$^y² + 4*$^z² - 36 }\n   { $^x² - 2*$^y² - 20*$^z }\n   { $^x² - $^y² + $^z² }\n];\n\nmy @guesses = (1,1,0);\n\nmy @solution = solve_funcs $funcs, @guesses, 20, 1e-8;\n\nsay \"Solution: \", @solution;\n\n```\n\nOutput:\n\n```\nSolution: [0.8936282344764825 0.8945270103905782 -0.04008928615915281]\n\n```"}]}
{"messages": [{"role": "user", "content": "The factorial of a number, written as \n\nn\n!\n{\\displaystyle {\\displaystyle n!}}\n, is defined as \n\nn\n!\n=\nn\n(\nn\n−\n1\n)\n(\nn\n−\n2\n)\n.\n.\n.\n(\n2\n)\n(\n1\n)\n{\\displaystyle {\\displaystyle n!=n(n-1)(n-2)...(2)(1)}}\n.\n\nMultifactorials generalize factorials as follows:\n\n:   n\n    !\n    =\n    n\n    (\n    n\n    −\n    1\n    )\n    (\n    n\n    −\n    2\n    )\n    .\n    .\n    .\n    (\n    2\n    )\n    (\n    1\n    )\n    {\\displaystyle {\\displaystyle n!=n(n-1)(n-2)...(2)(1)}}\n:   n\n    !\n    !\n    =\n    n\n    (\n    n\n    −\n    2\n    )\n    (\n    n\n    −\n    4\n    )\n    .\n    .\n    .\n    {\\displaystyle {\\displaystyle n!!=n(n-2)(n-4)...}}\n:   n\n    !\n    !\n    !\n    =\n    n\n    (\n    n\n    −\n    3\n    )\n    (\n    n\n    −\n    6\n    )\n    .\n    .\n    .\n    {\\displaystyle {\\displaystyle n!!!=n(n-3)(n-6)...}}\n:   n\n    !\n    !\n    !\n    !\n    =\n    n\n    (\n    n\n    −\n    4\n    )\n    (\n    n\n    −\n    8\n    )\n    .\n    .\n    .\n    {\\displaystyle {\\displaystyle n!!!!=n(n-4)(n-8)...}}\n:   n\n    !\n    !\n    !\n    !\n    !\n    =\n    n\n    (\n    n\n    −\n    5\n    )\n    (\n    n\n    −\n    10\n    )\n    .\n    .\n    .\n    {\\displaystyle {\\displaystyle n!!!!!=n(n-5)(n-10)...}}\n\nIn all cases, the terms in the products are positive integers.\n\nIf we define the degree of the multifactorial as the difference in successive terms that are multiplied together for a multifactorial (the number of exclamation marks), then the task is twofold:\n\n1. Write a function that given n and the degree, calculates the multifactorial.\n2. Use the function to generate and display here a table of the first ten members (1 to 10) of the first five degrees of multifactorial.\n\n**Note:** The wikipedia entry on multifactorials gives a different formula. This task uses the Wolfram mathworld definition."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nfor 1 .. 5 -> $degree {\n    sub mfact($n) { [*] $n, *-$degree ...^ * <= 0 };\n    say \"$degree: \", map &mfact, 1..10\n}\n\n```\n\nOutput:\n\n```\n1: 1 2 6 24 120 720 5040 40320 362880 3628800\n2: 1 2 3 8 15 48 105 384 945 3840\n3: 1 2 3 4 10 18 28 80 162 280\n4: 1 2 3 4 5 12 21 32 45 120\n5: 1 2 3 4 5 6 14 24 36 50\n```"}]}
{"messages": [{"role": "user", "content": "Simple shebangs can help with scripting, e.g., `#!/usr/bin/env python` at the top of a Python script will allow it to be run in a terminal as \"`./script.py`\".\n\nOccasionally, a more complex shebang line is needed. For example, some languages do not include the program name in ARGV; a multiline shebang can reorder the arguments so that the program name is included in ARGV.\n\nThe syntax for a multiline shebang is complicated. The shebang lines must be simultaneously commented away from the main language and revealed to some shell (perhaps Bash) so that they can be executed. In other words, Polyglots.\n\nWarning: Using a multiline shebang of the form `#!/bin/sh ... exec ... !#` will set the code's mimetype to `text/x-shellscript`, which creates problems such as Emacs treating the file as a shell script, no matter which language and file extension it really uses.\n\nSee also\n\n* Native shebang - where the \"program loaded\" is *of* the actual native task language."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n#!/usr/local/bin/raku\nuse MONKEY; EVAL '(exit $?0)' && EVAL 'exec rake $0 ${1+\"$@\"}'\n& EVAL 'exec raku $0 $argv:q'\n        if 0;\n\n```"}]}
{"messages": [{"role": "user", "content": "Create a sequence (array, list, whatever) consisting of n distinct, initialized items of the same type. n should be determined at runtime.\n\nBy *distinct* we mean that if they are mutable, changes to one do not affect all others; if there is an appropriate equality operator they are considered unequal; etc. The code need not specify a particular kind of distinction, but do not use e.g. a numeric-range generator which does not generalize.\n\nBy *initialized* we mean that each item must be in a well-defined state appropriate for its type, rather than e.g. arbitrary previous memory contents in an array allocation. Do not show only an initialization technique which initializes only to \"zero\" values (e.g. calloc() or int a[n] = {}; in C), unless user-defined types can provide definitions of \"zero\" for that type.\n\nThis task was inspired by the common error of intending to do this, but instead creating a sequence of n references to the *same* mutable object; it might be informative to show the way to do that as well, both as a negative example and as how to do it when that's all that's actually necessary.\n\nThis task is most relevant to languages operating in the pass-references-by-value style (most object-oriented, garbage-collected, and/or 'dynamic' languages).\n\nSee also: Closures/Value capture"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUnlike in Perl 5, the list repetition operator evaluates the left argument thunk each time, so\n\n```\nmy @a = Foo.new xx $n;\n\n```\n\nproduces `$n` distinct objects."}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a set of data vectors in the following format:\n\n```\n   \n  \n    \n      \n        \n          \n            y\n            =\n            {\n            \n              y\n              \n                1\n              \n            \n            ,\n            \n              y\n              \n                2\n              \n            \n            ,\n            .\n            .\n            .\n            ,\n            \n              y\n              \n                n\n              \n            \n            }\n            \n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle y=\\{y_{1},y_{2},...,y_{n}\\}\\,}}\n  \n\n\n```\n\n```\n   \n  \n    \n      \n        \n          \n            \n              X\n              \n                i\n              \n            \n            =\n            {\n            \n              x\n              \n                i\n                1\n              \n            \n            ,\n            \n              x\n              \n                i\n                2\n              \n            \n            ,\n            .\n            .\n            .\n            ,\n            \n              x\n              \n                i\n                n\n              \n            \n            }\n            ,\n            i\n            ∈\n            1..\n            k\n            \n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle X_{i}=\\{x_{i1},x_{i2},...,x_{in}\\},i\\in 1..k\\,}}\n  \n\n\n```\n\nCompute the vector \n\nβ\n=\n{\n\nβ\n\n1\n,\n\nβ\n\n2\n,\n.\n.\n.\n,\n\nβ\n\nk\n}\n{\\displaystyle {\\displaystyle \\beta =\\{\\beta \\_{1},\\beta \\_{2},...,\\beta \\_{k}\\}}}\n using ordinary least squares regression using the following equation:\n\n```\n   \n  \n    \n      \n        \n          \n            \n              y\n              \n                j\n              \n            \n            =\n            \n              Σ\n              \n                i\n              \n            \n            \n              β\n              \n                i\n              \n            \n            ⋅\n            \n              x\n              \n                i\n                j\n              \n            \n            ,\n            j\n            ∈\n            1..\n            n\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle y_{j}=\\Sigma _{i}\\beta _{i}\\cdot x_{ij},j\\in 1..n}}\n  \n\n\n```\n\nYou can assume  *y*  is given to you as a vector (a one-dimensional array), and  *X*  is given to you as a two-dimensional array (i.e. matrix)."}, {"role": "assistant", "content": "|  |\n| --- |\n| This example is **broken**. It fails to compile or causes a runtime error. Please fix the code and remove this message. |\n\n(formerly Perl 6)\nWe're going to solve the example on the Wikipedia article using Clifford, a geometric algebra module. Optimization for large vector space does not quite work yet, so it's going to take (a lof of) time and a fair amount of memory, but it should work.\n\nLet's create four vectors containing our input data:\n\nw\n\n\n=\n\nw\n\nk\n\n\ne\n\nk\n\nh\n\n0\n\n\n=\n(\n\nh\n\nk\n\n)\n\n0\n\n\ne\n\nk\n\nh\n\n1\n\n\n=\n(\n\nh\n\nk\n\n)\n\n1\n\n\ne\n\nk\n\nh\n\n2\n\n\n=\n(\n\nh\n\nk\n\n)\n\n2\n\n\ne\n\nk\n{\\displaystyle {\\displaystyle {\\begin{aligned}\\mathbf {w} &=w^{k}\\mathbf {e} \\_{k}\\\\\\mathbf {h\\_{0}} &=(h^{k})^{0}\\mathbf {e} \\_{k}\\\\\\mathbf {h\\_{1}} &=(h^{k})^{1}\\mathbf {e} \\_{k}\\\\\\mathbf {h\\_{2}} &=(h^{k})^{2}\\mathbf {e} \\_{k}\\end{aligned}}}}\n\nThen what we're looking for are three scalars \n\nα\n{\\displaystyle {\\displaystyle \\alpha }}\n, \n\nβ\n{\\displaystyle {\\displaystyle \\beta }}\n and \n\nγ\n{\\displaystyle {\\displaystyle \\gamma }}\n such that:\n\nα\n\nh\n0\n+\nβ\n\nh\n1\n+\nγ\n\nh\n2\n=\n\nw\n{\\displaystyle {\\displaystyle \\alpha \\mathbf {h0} +\\beta \\mathbf {h1} +\\gamma \\mathbf {h2} =\\mathbf {w} }}\n\nTo get for instance \n\nα\n{\\displaystyle {\\displaystyle \\alpha }}\n we can first make the \n\nβ\n{\\displaystyle {\\displaystyle \\beta }}\n and \n\nγ\n{\\displaystyle {\\displaystyle \\gamma }}\n terms disappear:\n\nα\n\nh\n0\n∧\n\nh\n1\n∧\n\nh\n2\n=\n\nw\n∧\n\nh\n1\n∧\n\nh\n2\n{\\displaystyle {\\displaystyle \\alpha \\mathbf {h0} \\wedge \\mathbf {h1} \\wedge \\mathbf {h2} =\\mathbf {w} \\wedge \\mathbf {h1} \\wedge \\mathbf {h2} }}\n\nNoting \n\nI\n=\n\nh\n0\n∧\n\nh\n1\n∧\n\nh\n2\n{\\displaystyle {\\displaystyle I=\\mathbf {h0} \\wedge \\mathbf {h1} \\wedge \\mathbf {h2} }}\n, we then get:\n\nα\n=\n(\n\nw\n∧\n\nh\n1\n∧\n\nh\n2\n)\n⋅\n\nI\n~\n\n/\nI\n⋅\n\nI\n~\n{\\displaystyle {\\displaystyle \\alpha =(\\mathbf {w} \\wedge \\mathbf {h1} \\wedge \\mathbf {h2} )\\cdot {\\tilde {I}}/I\\cdot {\\tilde {I}}}}\n\n**Note:** a number of the formulae above are invisible to the majority of browsers, including Chrome, IE/Edge, Safari and Opera. They may (subject to the installation of necessary fronts) be visible to Firefox.\n\n```\nuse Clifford;\nmy @height = <1.47 1.50 1.52 1.55 1.57 1.60 1.63 1.65 1.68 1.70 1.73 1.75 1.78 1.80 1.83>;\nmy @weight = <52.21 53.12 54.48 55.84 57.20 58.57 59.93 61.29 63.11 64.47 66.28 68.10 69.92 72.19 74.46>;\n\nmy $w = [+] @weight Z* @e;\n\nmy $h0 = [+] @e[^@weight];\nmy $h1 = [+] @height Z* @e;\nmy $h2 = [+] (@height X** 2) Z* @e;\n\nmy $I = $h0∧$h1∧$h2;\nmy $I2 = ($I·$I.reversion).Real;\n\nsay \"α = \", ($w∧$h1∧$h2)·$I.reversion/$I2;\nsay \"β = \", ($w∧$h2∧$h0)·$I.reversion/$I2;\nsay \"γ = \", ($w∧$h0∧$h1)·$I.reversion/$I2;\n\n```\n\nOutput:\n\n```\nα = 128.81280357844\nβ = -143.1620228648\nγ = 61.960325442\n```\n\nApril 2016: This computation took over an hour with MoarVM, running in a VirtualBox linux system guest hosted by a windows laptop with a i7 intel processor.  \nMarch 2020: With various improvements to the language, 6.d releases of Raku now run the code 2x to 3x as fast, depending on the hardware used, but even so it is generous to describe it as 'slow'."}]}
{"messages": [{"role": "user", "content": "Task\n\nProduce a formatted   12×12   multiplication table of the kind memorized by rote when in primary (or elementary) school.\n\nOnly print the top half triangle of products."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n(my $f = \"%{$_}s\" given my $width = ($_**2).chars ) given my $max = 12;\n\nsay '×'.fmt($f)  ~ ' ┃ ' ~ (1..$max).fmt($f);\nsay '━' x $width ~ '━╋'  ~ '━' x $max × (1+$width);\n\nfor 1..$max -> $i {\n    say $i.fmt($f) ~ ' ┃ ' ~ ( $i ≤ $_ ?? $i×$_ !! '' for 1..$max ).fmt($f);\n}\n```\n\nOutput:\n\n```\n  x│   1   2   3   4   5   6   7   8   9  10  11  12\n───┼────────────────────────────────────────────────\n  1│   1   2   3   4   5   6   7   8   9  10  11  12\n  2│       4   6   8  10  12  14  16  18  20  22  24\n  3│           9  12  15  18  21  24  27  30  33  36\n  4│              16  20  24  28  32  36  40  44  48\n  5│                  25  30  35  40  45  50  55  60\n  6│                      36  42  48  54  60  66  72\n  7│                          49  56  63  70  77  84\n  8│                              64  72  80  88  96\n  9│                                  81  90  99 108\n 10│                                     100 110 120\n 11│                                         121 132\n 12│                                             144\n\n```"}]}
{"messages": [{"role": "user", "content": "The **multiplicative order** of *a* relative to *m* is the least positive integer *n* such that *a^n* is 1 (modulo *m*).\n\nExample\n\nThe multiplicative order of 37 relative to 1000 is 100 because 37^100 is 1 (modulo 1000), and no number smaller than 100 would do.\n\nOne possible algorithm that is efficient also for large numbers is the following: By the Chinese Remainder Theorem, it's enough to calculate the multiplicative order for each prime exponent *p^k* of *m*, and\ncombine the results with the *least common multiple* operation.\n\nNow the order of *a* with regard to *p^k* must divide *Φ(p^k)*. Call this number *t*, and determine it's factors *q^e*. Since each multiple of the order will also yield 1 when used as exponent for *a*, it's enough to find the least d such that *(q^d)\\*(t/(q^e))* yields 1 when used as exponent.\n\nTask\n\nImplement a routine to calculate the multiplicative order along these lines. You may assume that routines to determine the factorization into prime powers are available in some library.\n\n---\n\nAn algorithm for the multiplicative order can be found in Bach & Shallit, *Algorithmic Number Theory, Volume I: Efficient Algorithms*, The MIT Press, 1996:\n\nExercise 5.8, page 115:\n\nSuppose you are given a prime p and a complete factorization\nof p-1.   Show how to compute the order of an\nelement a in (Z/(p))\\* using O((lg p)4/(lg lg p)) bit\noperations.\n\nSolution, page 337:\n\nLet the prime factorization of p-1  be q1e1q2e2...qkek . We use the following observation:\nif x^((p-1)/qifi) = 1 (mod p) , \nand fi=ei or x^((p-1)/qifi+1) != 1 (mod p) , then qiei-fi||ordp x.   (This follows by combining Exercises 5.1 and 2.10.)\nHence it suffices to find, for each i , the exponent fi  such that the condition above holds.\n\nThis can be done as follows: first compute q1e1, q2e2, ... ,\nqkek .  This can be done using O((lg p)2) bit operations. Next, compute y1=(p-1)/q1e1, ... , yk=(p-1)/qkek . \nThis can be done using O((lg p)2) bit operations. Now, using the binary method,\ncompute x1=ay1(mod p), ... , xk=ayk(mod p) . \nThis can be done using O(k(lg p)3) bit operations, and k=O((lg p)/(lg lg p)) by Theorem 8.8.10.\nFinally, for each i , repeatedly raise xi to the qi-th power (mod p) (as many as ei-1  times), checking to see when 1 is obtained.\nThis can be done using O((lg p)3) steps.\nThe total cost is dominated by O(k(lg p)3) , which is O((lg p)4/(lg lg p))."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nuse Prime::Factor;\n\nsub mo-prime($a, $p, $e) {\n    my $m = $p ** $e;\n    my $t = ($p - 1) * ($p ** ($e - 1)); #  = Phi($p**$e) where $p prime\n    my @qs = 1;\n    for prime-factors($t).Bag -> $f {\n        @qs = flat @qs.map(-> $q { (0..$f.value).map(-> $j { $q * $f.key ** $j }) });\n    }\n\n    @qs.sort.first: -> $q { expmod( $a, $q, $m ) == 1 };\n}\n\nsub mo($a, $m) {\n    $a gcd $m == 1 or die \"$a and $m are not relatively prime\";\n    [lcm] flat 1, prime-factors($m).Bag.map: { mo-prime($a, .key, .value) };\n}\n\nmulti MAIN('test') {\n    use Test;\n\n    for (10, 21, 25, 150, 1231, 123141, 34131) -> $n {\n        is ([*] prime-factors($n).Bag.map( { .key ** .value } )), $n, \"$n factors correctly\";\n    }\n\n    is mo(37, 1000), 100, 'mo(37,1000) == 100';\n    my $b = 10**20-1;\n    is mo(2, $b), 3748806900, 'mo(2,10**20-1) == 3748806900';\n    is mo(17, $b), 1499522760, 'mo(17,10**20-1) == 1499522760';\n    $b = 100001;\n    is mo(54, $b), 9090, 'mo(54,100001) == 9090';\n}\n\n```\n\nOutput:\n\n```\nok 1 - 10 factors correctly\nok 2 - 21 factors correctly\nok 3 - 25 factors correctly\nok 4 - 150 factors correctly\nok 5 - 1231 factors correctly\nok 6 - 123141 factors correctly\nok 7 - 34131 factors correctly\nok 8 - mo(37,1000) == 100\nok 9 - mo(2,10**20-1) == 3748806900\nok 10 - mo(17,10**20-1) == 1499522760\nok 11 - mo(54,100001) == 9090\n```"}]}
{"messages": [{"role": "user", "content": "If the product of the divisors of an integer n (including n itself) is equal to n^2, then n is a *multiplicatively perfect number*.\nAlternatively: the product of the proper divisors of n (i.e. excluding n) is equal to n.\n\nNote that the integer '1' qualifies under the first definition (1 = 1 x 1), but not under the second since '1' has no proper divisors. Given this ambiguity, it is optional whether '1' is included or not in solutions to this task.\n\nTask\n\nFind and show on this page the multiplicatively perfect numbers below **500**.\n\nStretch\n\nFind and show the number of multiplicatively perfect numbers under **500**, **5,000**, **50,000** and **500,000** and for each of these limits deduce (avoid counting separately) and show the number of *semi-primes* (numbers which are the product of exactly two primes) under that limit.\n\nRelated (and near duplicate) task\n\n* Semiprime\n\nSee also\n\n* The OEIS sequence:  A007422: Multiplicatively perfect numbers"}, {"role": "assistant", "content": "```\nuse List::Divvy;\nuse Lingua::EN::Numbers;\n\nconstant @primes = (^∞).grep: &is-prime;\nconstant @cubes  = @primes.map: *³;\n\nstate $cube = 0;\nsub is-mpn(Int $n ) {\n    return False if $n.is-prime;\n    if $n == @cubes[$cube] {\n        ++$cube;\n        return True\n    }\n    my $factor = find-factor($n);\n    return True if ($factor.is-prime && ( my $div = $n div $factor ).is-prime && ($div != $factor));\n    False;\n}\n\nsub find-factor ( Int $n, $constant = 1 ) {\n    my $x      = 2;\n    my $rho    = 1;\n    my $factor = 1;\n    while $factor == 1 {\n        $rho *= 2;\n        my $fixed = $x;\n        for ^$rho {\n            $x = ( $x * $x + $constant ) % $n;\n            $factor = ( $x - $fixed ) gcd $n;\n            last if 1 < $factor;\n        }\n    }\n    $factor = find-factor( $n, $constant + 1 ) if $n == $factor;\n    $factor;\n}\n\nconstant @mpn = lazy 1, |(2..*).grep: &is-mpn;\n\nsay 'Multiplicatively perfect numbers less than 500:';\nput @mpn.&upto(500).batch(10)».fmt(\"%3d\").join: \"\\n\";\n\nput \"\\nThere are:\";\nfor 5e2, 5e3, 5e4, 5e5, 5e6 {\n   printf  \"%8s MPNs less than %9s, %7s semiprimes.\\n\",\n     comma(my $count = +@mpn.&upto($_)), .Int.&comma,\n     comma $count + @primes.map(*²).&upto($_) - @cubes.&upto($_) - 1;\n}\n\n```\n\nOutput:\n\n```\nMultiplicatively perfect numbers less than 500:\n  1   6   8  10  14  15  21  22  26  27\n 33  34  35  38  39  46  51  55  57  58\n 62  65  69  74  77  82  85  86  87  91\n 93  94  95 106 111 115 118 119 122 123\n125 129 133 134 141 142 143 145 146 155\n158 159 161 166 177 178 183 185 187 194\n201 202 203 205 206 209 213 214 215 217\n218 219 221 226 235 237 247 249 253 254\n259 262 265 267 274 278 287 291 295 298\n299 301 302 303 305 309 314 319 321 323\n326 327 329 334 335 339 341 343 346 355\n358 362 365 371 377 381 382 386 391 393\n394 395 398 403 407 411 413 415 417 422\n427 437 445 446 447 451 453 454 458 466\n469 471 473 478 481 482 485 489 493 497\n\nThere are:\n     150 MPNs less than       500,     153 semiprimes.\n   1,354 MPNs less than     5,000,   1,365 semiprimes.\n  12,074 MPNs less than    50,000,  12,110 semiprimes.\n 108,223 MPNs less than   500,000, 108,326 semiprimes.\n 978,983 MPNs less than 5,000,000, 979,274 semiprimes.\n```"}]}
{"messages": [{"role": "user", "content": "It is often necessary to split a string into pieces\nbased on several different (potentially multi-character) separator strings,\nwhile still retaining the information about which separators were present in the input.\n\nThis is particularly useful when doing small parsing tasks.   \nThe task is to write code to demonstrate this.\n\nThe function (or procedure or method, as appropriate) should\ntake an input string and an ordered collection of separators.\n\nThe order of the separators is significant:   \nThe delimiter order represents priority in matching, with the first defined delimiter having the highest priority.\nIn cases where there would be an ambiguity as to\nwhich separator to use at a particular point\n(e.g., because one separator is a prefix of another)\nthe separator with the highest priority should be used.\nDelimiters can be reused and the output from the function should be an ordered sequence of substrings.\n\nTest your code using the input string “`a!===b=!=c`” and the separators “`==`”, “`!=`” and “`=`”.\n\nFor these inputs the string should be parsed as `\"a\" (!=) \"\" (==) \"b\" (=) \"\" (!=) \"c\"`, where matched delimiters are shown in parentheses, and separated strings are quoted, so our resulting output is `\"a\", empty string, \"b\", empty string, \"c\"`.\nNote that the quotation marks are shown for clarity and do not form part of the output.\n\n**Extra Credit:** provide information that indicates which separator was matched at each separation point and where in the input string that separator was matched."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub multisplit($str, @seps) { $str.split: / ||@seps /, :v }\n\nmy @chunks = multisplit 'a!===b=!=c==d', < == != = >;\n\n# Print the strings.\nsay @chunks».Str.raku;\n\n# Print the positions of the separators.\nfor grep Match, @chunks -> $s {\n    say \"{$s.fmt: '%2s'} from {$s.from.fmt: '%2d'} to {$s.to.fmt: '%2d'}\";\n}\n\n```\n\nOutput:\n\n```\n(\"a\", \"!=\", \"\", \"==\", \"b\", \"=\", \"\", \"!=\", \"c\", \"==\", \"d\")\n!= from  1 to  3\n== from  3 to  5\n = from  6 to  7\n!= from  7 to  9\n== from 10 to 12\n```\n\nUsing the array @seps in a pattern automatically does alternation.\nBy default this would do longest-term matching (that is, | semantics), but we can force it to do left-to-right matching by embedding the array in a short-circuit alternation (that is, || semantics).\nAs it happens, with the task's specified list of separators, it doesn't make any difference.\n\nRaku automatically returns Match objects that will stringify to the matched pattern, but can also be interrogated for their match positions, as illustrated above by post-processing the results two different ways."}]}
{"messages": [{"role": "user", "content": "Description\n\nThe multiton pattern is a design pattern which generalizes the singleton pattern. Whereas the singleton allows only one instance of a class to be created, the multiton pattern allows for the controlled creation of multiple instances, which it manages through the use of a map.\n\nTask\n\nImplement a basic Multiton class or other structure and test that it works as intended. If your language does not support the *object oriented* paradigm, then try to emulate a multiton as best you can with the tools available.\n\nIf your language supports multithreading, then you may optionally implement a thread safe variant as well.\n\nRelated task\n\n* Singleton"}, {"role": "assistant", "content": "Tried to translate the C# example at WP but not sure if my interpretation/implementation is correct\n\n```\n# 20211001 Raku programming solution \n\nenum MultitonType < Gold Silver Bronze >;\n\nclass Multiton { \n\n   my %instances = MultitonType.keys Z=> $ ⚛= 1 xx * ;\n\n   has $.type is rw; \n\n   method TWEAK { $.type = 'Nothing' unless cas(%instances{$.type}, 1, 0) }\n}\n\nrace for ^10 -> $i {\n   Thread.start(\n      sub {\n#         sleep roll(^2);\n         my $obj = Multiton.new: type => MultitonType.roll;\n         say \"Thread \", $i, \" has got \", $obj.type;\n      }\n   );\n}\n\n```\n\nOutput:\n\n```\nThread 5 has got Bronze\nThread 9 has got Gold\nThread 7 has got Nothing\nThread 8 has got Nothing\nThread 3 has got Nothing\nThread 2 has got Nothing\nThread 1 has got Nothing\nThread 0 has got Silver\nThread 4 has got Nothing\nThread 6 has got Nothing\n\n```"}]}
{"messages": [{"role": "user", "content": "A Munchausen number is a natural number *n* the sum of whose digits (in base 10), each raised to the power of itself, equals *n*.\n\n(**Munchausen** is also spelled: **Münchhausen**.)\n\nFor instance:    3435 = 33 + 44 + 33 + 55\n\nTask\n\nFind all Munchausen numbers between   **1**   and   **5000**.\n\nAlso see\n:   * The OEIS entry: A046253\n    * The Wikipedia entry: Perfect digit-to-digit invariant, redirected from Munchausen Number"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub is_munchausen ( Int $n ) {\n    constant @powers = 0, |map { $_ ** $_ }, 1..9;\n    $n == @powers[$n.comb].sum;\n}\n.say if .&is_munchausen for 1..5000;\n\n```\n\nOutput:\n\n```\n1\n3435\n```"}]}
{"messages": [{"role": "user", "content": "Render a graphical pattern where each pixel is colored by the value of 'x xor y' from an arbitrary color table."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nHere's one simple way:\n\n```\nmy $ppm = open(\"munching0.ppm\", :w) orelse .die;\n\n$ppm.print(q :to 'EOT');\nP3\n256 256\n255\nEOT\n\nfor 0 .. 255 -> $row {\n    for 0 .. 255 -> $col {\n        my $color = $row +^ $col;\n        $ppm.print(\"0 $color 0 \");\n    }\n    $ppm.say();\n}\n\n$ppm.close();\n\n```\n\nAnother way:\n\n```\nmy @colors = map -> $r, $g, $b { Buf.new: $r, $g, $b },\n\t\tmap -> $x { floor ($x/256) ** 3 * 256 },\n\t\t    (flat (0...255) Z\n\t\t     (255...0) Z\n\t\t     flat (0,2...254),(254,252...0));\n\n\nmy $PPM = open \"munching1.ppm\", :w orelse .die;\n\n$PPM.print: qq:to/EOH/;\n    P6\n    # munching.pgm\n    256 256 \n    255\n    EOH\n\n$PPM.write: @colors[$_] for ^256 X+^ ^256;\n\n$PPM.close;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nOutput the 8 notes of the **C major** diatonic scale to the default musical sound device on the system. Specifically, pitch must be tuned to 12-tone equal temperament (12TET) with the modern standard A=440Hz.\n\nThese are the notes \"C, D, E, F, G, A, B, C(1 octave higher)\", or \"Do, Re, Mi, Fa, Sol, La, Si/Ti, Do(1 octave higher)\" on *Fixed do Solfège*.\n\nFor the purpose of this task, **Middle C** (in the case of the above tuning, around 261.63 Hz) should be used as the starting note, and any note duration is allowed.\n\nFor languages that cannot utilize a sound device, it is permissible to output to a musical score sheet (or midi file), or the task can be omitted."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nfor 0,2,4,5,7,9,11,12 {\n    shell \"play -n -c1 synth 0.2 sin %{$_ - 9}\"\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "A **mutex** (from \"**mut**ual **ex**clusion\") is a synchronization object, a variant of semaphore with *k*=1.\nA mutex is said to be seized by a task decreasing *k*.\nIt is released when the task restores *k*. Mutexes are typically used to protect a shared resource from concurrent access.\nA task seizes (or acquires) the mutex, then accesses the resource, and after that releases the mutex.\n\nA mutex is a low-level synchronization primitive exposed to deadlocking. A deadlock can occur with just two tasks and two mutexes (if each task attempts to acquire both mutexes, but in the opposite order).\nEntering the deadlock is usually aggravated by a race condition state, which leads to sporadic hangups, which are very difficult to track down.\n\n# Variants of mutexes\n\n## Global and local mutexes\n\nUsually the OS provides various implementations of mutexes corresponding to the variants of tasks available in the OS. For example, system-wide mutexes can be used by processes. Local mutexes can be used only by threads etc. This distinction is maintained because, depending on the hardware, seizing a global mutex might be a thousand times slower than seizing a local one.\n\n## Reentrant mutex\n\nA reentrant mutex can be seized by the same task multiple times. Each seizing of the mutex is matched by releasing it, in order to allow another task to seize it.\n\n## Read write mutex\n\nA read write mutex can be seized at two levels for *read* and for *write*. The mutex can be seized for *read* by any number of tasks. Only one task may seize it for '*write*. Read write mutexes are usually used to protect resources which can be accessed in mutable and immutable ways. Immutable (read) access is granted concurrently for many tasks because they do not change the resource state. Read write mutexes can be reentrant, global or local. Further, promotion operations may be provided. That's when a task that has seized the mutex for *write* releases it while keeping seized for *read*. Note that the reverse operation is potentially deadlocking and requires some additional access policy control.\n\n# Deadlock prevention\n\nThere exists a simple technique of deadlock prevention when mutexes are seized in some fixed order. This is discussed in depth in the Dining philosophers problem.\n\n# Sample implementations / APIs"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $lock = Lock.new;\n\n$lock.protect: { your-ad-here() }\n\n```\n\nLocks are reentrant. You may explicitly lock and unlock them, but the syntax above guarantees the lock will be unlocked on scope exit, even if by thrown exception or other exotic control flow. That being said, direct use of locks is discouraged in Raku in favor of promises, channels, and supplies, which offer better composable semantics."}]}
{"messages": [{"role": "user", "content": "Two functions are said to be mutually recursive if the first calls the second,\nand in turn the second calls the first.\n\nWrite two mutually recursive functions that compute members of the Hofstadter Female and Male sequences defined as:\n\n:   F\n    (\n    0\n    )\n\n\n    =\n    1\n     \n    ;\n     \n    M\n    (\n    0\n    )\n    =\n    0\n\n\n    F\n    (\n    n\n    )\n\n\n    =\n    n\n    −\n    M\n    (\n    F\n    (\n    n\n    −\n    1\n    )\n    )\n    ,\n\n    n\n    >\n    0\n\n\n    M\n    (\n    n\n    )\n\n\n    =\n    n\n    −\n    F\n    (\n    M\n    (\n    n\n    −\n    1\n    )\n    )\n    ,\n\n    n\n    >\n    0.\n    {\\displaystyle {\\displaystyle {\\begin{aligned}F(0)&=1\\ ;\\ M(0)=0\\\\F(n)&=n-M(F(n-1)),\\quad n>0\\\\M(n)&=n-F(M(n-1)),\\quad n>0.\\end{aligned}}}}\n\n(If a language does not allow for a solution using mutually recursive functions\nthen state this rather than give a solution by other means)."}, {"role": "assistant", "content": "(formerly Perl 6)\nA direct translation of the definitions of \n\nF\n{\\displaystyle {\\displaystyle F}}\n and \n\nM\n{\\displaystyle {\\displaystyle M}}\n:\n\n```\nmulti F(0) { 1 }; multi M(0) { 0 }\nmulti F(\\𝑛) { 𝑛 - M(F(𝑛 - 1)) }\nmulti M(\\𝑛) { 𝑛 - F(M(𝑛 - 1)) }\n\nsay map &F, ^20;\nsay map &M, ^20;\n\n```\n\nOutput:\n\n```\n1 1 2 2 3 3 4 5 5 6 6 7 8 8 9 9 10 11 11 12\n0 0 1 2 2 3 4 4 5 6 6 7 7 8 9 9 10 11 11 12\n\n```"}]}
{"messages": [{"role": "user", "content": "The classical **Möbius function: μ(n)** is an important multiplicative function in number theory and combinatorics.\n\nThere are several ways to implement a Möbius function.\n\nA fairly straightforward method is to find the prime factors of a positive integer **n**, then define **μ(n)** based on the sum of the primitive factors. It has the values **{−1, 0, 1}** depending on the factorization of **n**:\n\n:   * **μ(1)** is defined to be **1**.\n\n:   * **μ(n) = 1** if **n** is a square-free positive integer with an **even** number of prime factors.\n\n:   * **μ(n) = −1** if **n** is a square-free positive integer with an **odd** number of prime factors.\n\n:   * **μ(n) = 0** if **n** has a **squared** prime factor.\n\nTask\n:   * Write a routine (function, procedure, whatever) **μ(n)** to find the Möbius number for a positive integer **n**.\n\n:   * Use that routine to find and display here, on this page, at least the first 99 terms in a grid layout. (Not just one long line or column of numbers.)\n\nSee also\n:   * Wikipedia: Möbius function\n\nRelated Tasks\n:   * Mertens function"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2022.12\n\nMöbius number is not defined for n == 0. Raku arrays are indexed from 0 so store a blank value at position zero to keep n and μ(n) aligned.\n\n```\nuse Prime::Factor;\n\nsub μ (Int \\n) {\n    return 0 if n %% (4|9|25|49|121);\n    my @p = prime-factors(n);\n    +@p == +@p.unique ?? +@p %% 2 ?? 1 !! -1 !! 0\n}\n\nmy @möbius = lazy flat '', 1, (2..*).hyper.map: &μ;\n\n# The Task\nput \"Möbius sequence - First 199 terms:\\n\",\n    @möbius[^200]».fmt('%3s').batch(20).join: \"\\n\";\n\n```\n\nOutput:\n\n```\nMöbius sequence - First 199 terms:\n      1  -1  -1   0  -1   1  -1   0   0   1  -1   0  -1   1   1   0  -1   0  -1\n  0   1   1  -1   0   0   1   0   0  -1  -1  -1   0   1   1   1   0  -1   1   1\n  0  -1  -1  -1   0   0   1  -1   0   0   0   1   0  -1   0   1   0   1   1  -1\n  0  -1   1   0   0   1  -1  -1   0   1  -1  -1   0  -1   1   0   0   1  -1  -1\n  0   0   1  -1   0   1   1   1   0  -1   0   1   0   1   1   1   0  -1   0   0\n  0  -1  -1  -1   0  -1   1  -1   0  -1  -1   1   0  -1  -1   1   0   0   1   1\n  0   0   1   1   0   0   0  -1   0   1  -1  -1   0   1   1   0   0  -1  -1  -1\n  0   1   1   1   0   1   1   0   0  -1   0  -1   0   0  -1   1   0  -1   1   1\n  0   1   0  -1   0  -1   1  -1   0   0  -1   0   0  -1  -1   0   0   1   1  -1\n  0  -1  -1   1   0   1  -1   1   0   0  -1  -1   0  -1   1  -1   0  -1   0  -1\n```"}]}
{"messages": [{"role": "user", "content": "Write a function/method/subroutine/... that when given an integer greater than or equal to zero returns a string of the number followed by an apostrophe then the ordinal suffix.\n\nExample\n\nReturns would include `1'st 2'nd 3'rd 11'th 111'th 1001'st 1012'th`\n\nTask\n\nUse your routine to show here the output for *at least* the following (inclusive) ranges of integer inputs:\n`0..25, 250..265, 1000..1025`\n\n**Note:** apostrophes are now *optional* to allow correct apostrophe-less English."}, {"role": "assistant", "content": "(formerly Perl 6)\n(Spurious apostrophes intentionally omitted.)\n\n```\nmy %irregulars = <1 st 2 nd 3 rd>, (11..13 X=> 'th');\n\nsub nth ($n) { $n ~ ( %irregulars{$n % 100} // %irregulars{$n % 10} // 'th' ) }\n\nsay .list».&nth for [^26], [250..265], [1000..1025];\n\n```\n\nOutput:\n\n```\n0th 1st 2nd 3rd 4th 5th 6th 7th 8th 9th 10th 11th 12th 13th 14th 15th 16th 17th 18th 19th 20th 21st 22nd 23rd 24th 25th\n250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th\n1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th\n```\n\nIf you want to get Unicodally fancy, use this version instead:\n\n```\nmy %irregulars = <1 ˢᵗ 2 ⁿᵈ 3 ʳᵈ>, (11..13 X=> 'ᵗʰ');\n\nsub nth ($n) { $n ~ ( %irregulars{$n % 100} // %irregulars{$n % 10} // 'ᵗʰ' ) }\n\nsay .list».&nth for [^26], [250..265], [1000..1025];\n\n```\n\nOutput:\n\n> 0ᵗʰ 1ˢᵗ 2ⁿᵈ 3ʳᵈ 4ᵗʰ 5ᵗʰ 6ᵗʰ 7ᵗʰ 8ᵗʰ 9ᵗʰ 10ᵗʰ 11ᵗʰ 12ᵗʰ 13ᵗʰ 14ᵗʰ 15ᵗʰ 16ᵗʰ 17ᵗʰ 18ᵗʰ 19ᵗʰ 20ᵗʰ 21ˢᵗ 22ⁿᵈ 23ʳᵈ 24ᵗʰ 25ᵗʰ\n>\n> 250ᵗʰ 251ˢᵗ 252ⁿᵈ 253ʳᵈ 254ᵗʰ 255ᵗʰ 256ᵗʰ 257ᵗʰ 258ᵗʰ 259ᵗʰ 260ᵗʰ 261ˢᵗ 262ⁿᵈ 263ʳᵈ 264ᵗʰ 265ᵗʰ\n>\n> 1000ᵗʰ 1001ˢᵗ 1002ⁿᵈ 1003ʳᵈ 1004ᵗʰ 1005ᵗʰ 1006ᵗʰ 1007ᵗʰ 1008ᵗʰ 1009ᵗʰ 1010ᵗʰ 1011ᵗʰ 1012ᵗʰ 1013ᵗʰ 1014ᵗʰ 1015ᵗʰ 1016ᵗʰ 1017ᵗʰ 1018ᵗʰ 1019ᵗʰ 1020ᵗʰ 1021ˢᵗ 1022ⁿᵈ 1023ʳᵈ 1024ᵗʰ 1025ᵗʰ"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nThe\nN\n{\\displaystyle {\\displaystyle N}}\n-body problem is an inherent feature of a physical description of mechanical system of \n\nN\n{\\displaystyle {\\displaystyle N}}\n interacting objects.\nThe system is described by Newton's Law\n\n:   F\n    →\n    =\n\n    m\n\n    i\n\n    d\n\n    2\n\n    r\n    →\n\n    i\n\n    d\n\n    t\n\n    2\n    ,\n    i\n    =\n    1..\n    N\n    {\\displaystyle {\\displaystyle {\\vec {F}}=m\\_{i}{\\frac {d^{2}{\\vec {r}}\\_{i}}{dt^{2}}},i=1..N}}\n\nwith continuous combined force from other bodies\n\n:   F\n\n    i\n    =\n\n    ∑\n\n    j\n    ≠\n    i\n\n\n    F\n\n    i\n    j\n    ,\n    i\n    =\n    1..\n    N\n    {\\displaystyle {\\displaystyle F\\_{i}=\\sum \\_{j\\neq i}^{}F\\_{ij},i=1..N}}\n\nExact formulation of first mechanical problem is, given initial coordinates and velocities \n\nt\n=\n0\n{\\displaystyle {\\displaystyle t=0}}\n, to find coordinates and velocities at \n\nt\n=\n\nt\n\n0\n{\\displaystyle {\\displaystyle t=t\\_{0}}}\n with accuracy more then given relative value \n\nϵ\n=\n\nr\n→\n−\n\nr\n→\n′\n\n\n|\n\nr\n→\n\n|\n{\\displaystyle {\\displaystyle \\epsilon ={\\frac {{\\vec {r}}-{\\vec {r}}'}{|{\\vec {r}}|}}}}\n\nAs well known from physical background, only the choice of \n\nN\n=\n2\n{\\displaystyle {\\displaystyle N=2}}\n can be analytically solved.\n\nTask\n\nWrite a simulation of three masses interacting under gravitation and show their evolution over a number of time-steps (at least 20)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nWe'll try to simulate the Sun+Earth+Moon system, with plausible astrometric values.\n\nWe use a 18-dimension vector \n\nA\nB\nC\n{\\displaystyle {\\displaystyle ABC}}\n. The first nine dimensions are the positions of the three bodies. The other nine are the velocities. This allows us to write the dynamics as a first-temporal derivative equation, since\n\nd\n\np\no\ns\ni\nt\ni\no\nn\n\nd\nt\n=\n\ns\np\ne\ne\nd\n{\\displaystyle {\\displaystyle {\\frac {d\\mathrm {position} }{dt}}=\\mathrm {speed} }}\n\nand thus\n\nd\nA\nB\n\nC\n\n1..9\n\nd\nt\n=\nA\nB\n\nC\n\n10..18\n{\\displaystyle {\\displaystyle {\\frac {dABC\\_{1..9}}{dt}}=ABC\\_{10..18}}}\n\nTo keep things compact, we'll only display the first 20 lines of output.\n\n```\n# Simple Vector implementation\nmulti infix:<+>(@a, @b) { @a Z+ @b }\nmulti infix:<->(@a, @b) { @a Z- @b }\nmulti infix:<*>($r, @a) { $r X* @a }\nmulti infix:</>(@a, $r) { @a X/ $r }\nsub norm { sqrt [+] @_ X** 2 }\n \n# Runge-Kutta stuff\nsub runge-kutta(&yp) {\n    return -> \\t, \\y, \\δt {\n        my $a = δt * yp( t, y );\n        my $b = δt * yp( t + δt/2, y + $a/2 );\n        my $c = δt * yp( t + δt/2, y + $b/2 );\n        my $d = δt * yp( t + δt, y + $c );\n        ($a + 2*($b + $c) + $d) / 6;\n    }\n}\n \n# gravitational constant\nconstant G = 6.674e-11;\n# astronomical unit\nconstant au = 150e9;\n \n# time constants in seconds\nconstant year = 365.25*24*60*60;\nconstant month = 21*24*60*60;\n \n# masses in kg\nconstant $ma = 2e30;     # Sun\nconstant $mb = 6e24;     # Earth\nconstant $mc = 7.34e22;  # Moon\n\nmy &dABC = runge-kutta my &f = sub ( $t, @ABC ) {\n    my @a = @ABC[0..2];\n    my @b = @ABC[3..5];\n    my @c = @ABC[6..8];\n \n    my $ab = norm(@a - @b); \n    my $ac = norm(@a - @c);\n    my $bc = norm(@b - @c);\n \n    return [\n        flat\n        @ABC[@(9..17)],\n        map G * *,\n        $mb/$ab**3 * (@b - @a) + $mc/$ac**3 * (@c - @a),\n        $ma/$ab**3 * (@a - @b) + $mc/$bc**3 * (@c - @b),\n        $ma/$ac**3 * (@a - @c) + $mb/$bc**3 * (@b - @c);\n    ];\n}\n \nloop (\n    my ($t, @ABC) = 0,\n        0, 0, 0,                                 # Sun position\n        au, 0, 0,                                # Earth position\n        0.998*au, 0, 0,                          # Moon position\n        0, 0, 0,                                 # Sun speed\n        0, 2*pi*au/year, 0,                      # Earth speed\n        0, 2*pi*(au/year + 0.002*au/month), 0    # Moon speed\n    ;\n    $t < .2;\n    ($t, @ABC) »+=« (.01, dABC($t, @ABC, .01))\n) {\n    printf \"t = %.02f : %s\\n\", $t, @ABC.fmt(\"%+.3e\");\n}\n\n```\n\nOutput:\n\n```\nt = 0.00 : +0.000e+00 +0.000e+00 +0.000e+00 +1.500e+11 +0.000e+00 +0.000e+00 +1.497e+11 +0.000e+00 +0.000e+00 +0.000e+00 +0.000e+00 +0.000e+00 +0.000e+00 +2.987e+04 +0.000e+00 +0.000e+00 +3.090e+04 +0.000e+00\nt = 0.01 : +9.008e-13 +5.981e-22 +0.000e+00 +1.500e+11 +2.987e+02 +0.000e+00 +1.497e+11 +3.090e+02 +0.000e+00 +1.802e-10 +1.794e-19 +0.000e+00 -5.987e-05 +2.987e+04 +0.000e+00 -1.507e-05 +3.090e+04 +0.000e+00\nt = 0.02 : +3.603e-12 +4.785e-21 +0.000e+00 +1.500e+11 +5.973e+02 +0.000e+00 +1.497e+11 +6.181e+02 +0.000e+00 +3.603e-10 +7.177e-19 +0.000e+00 -1.197e-04 +2.987e+04 +0.000e+00 -3.014e-05 +3.090e+04 +0.000e+00\nt = 0.03 : +8.107e-12 +1.615e-20 +0.000e+00 +1.500e+11 +8.960e+02 +0.000e+00 +1.497e+11 +9.271e+02 +0.000e+00 +5.405e-10 +1.615e-18 +0.000e+00 -1.796e-04 +2.987e+04 +0.000e+00 -4.521e-05 +3.090e+04 +0.000e+00\nt = 0.04 : +1.441e-11 +3.828e-20 +0.000e+00 +1.500e+11 +1.195e+03 +0.000e+00 +1.497e+11 +1.236e+03 +0.000e+00 +7.206e-10 +2.871e-18 +0.000e+00 -2.395e-04 +2.987e+04 +0.000e+00 -6.028e-05 +3.090e+04 +0.000e+00\nt = 0.05 : +2.252e-11 +7.476e-20 +0.000e+00 +1.500e+11 +1.493e+03 +0.000e+00 +1.497e+11 +1.545e+03 +0.000e+00 +9.008e-10 +4.486e-18 +0.000e+00 -2.993e-04 +2.987e+04 +0.000e+00 -7.535e-05 +3.090e+04 +0.000e+00\nt = 0.06 : +3.243e-11 +1.292e-19 +0.000e+00 +1.500e+11 +1.792e+03 +0.000e+00 +1.497e+11 +1.854e+03 +0.000e+00 +1.081e-09 +6.460e-18 +0.000e+00 -3.592e-04 +2.987e+04 +0.000e+00 -9.041e-05 +3.090e+04 +0.000e+00\nt = 0.07 : +4.414e-11 +2.051e-19 +0.000e+00 +1.500e+11 +2.091e+03 +0.000e+00 +1.497e+11 +2.163e+03 +0.000e+00 +1.261e-09 +8.792e-18 +0.000e+00 -4.191e-04 +2.987e+04 +0.000e+00 -1.055e-04 +3.090e+04 +0.000e+00\nt = 0.08 : +5.765e-11 +3.062e-19 +0.000e+00 +1.500e+11 +2.389e+03 +0.000e+00 +1.497e+11 +2.472e+03 +0.000e+00 +1.441e-09 +1.148e-17 +0.000e+00 -4.789e-04 +2.987e+04 +0.000e+00 -1.206e-04 +3.090e+04 +0.000e+00\nt = 0.09 : +7.296e-11 +4.360e-19 +0.000e+00 +1.500e+11 +2.688e+03 +0.000e+00 +1.497e+11 +2.781e+03 +0.000e+00 +1.621e-09 +1.453e-17 +0.000e+00 -5.388e-04 +2.987e+04 +0.000e+00 -1.356e-04 +3.090e+04 +0.000e+00\nt = 0.10 : +9.008e-11 +5.981e-19 +0.000e+00 +1.500e+11 +2.987e+03 +0.000e+00 +1.497e+11 +3.090e+03 +0.000e+00 +1.802e-09 +1.794e-17 +0.000e+00 -5.987e-04 +2.987e+04 +0.000e+00 -1.507e-04 +3.090e+04 +0.000e+00\nt = 0.11 : +1.090e-10 +7.961e-19 +0.000e+00 +1.500e+11 +3.285e+03 +0.000e+00 +1.497e+11 +3.399e+03 +0.000e+00 +1.982e-09 +2.171e-17 +0.000e+00 -6.586e-04 +2.987e+04 +0.000e+00 -1.658e-04 +3.090e+04 +0.000e+00\nt = 0.12 : +1.297e-10 +1.034e-18 +0.000e+00 +1.500e+11 +3.584e+03 +0.000e+00 +1.497e+11 +3.709e+03 +0.000e+00 +2.162e-09 +2.584e-17 +0.000e+00 -7.184e-04 +2.987e+04 +0.000e+00 -1.808e-04 +3.090e+04 +0.000e+00\nt = 0.13 : +1.522e-10 +1.314e-18 +0.000e+00 +1.500e+11 +3.882e+03 +0.000e+00 +1.497e+11 +4.018e+03 +0.000e+00 +2.342e-09 +3.032e-17 +0.000e+00 -7.783e-04 +2.987e+04 +0.000e+00 -1.959e-04 +3.090e+04 +0.000e+00\nt = 0.14 : +1.766e-10 +1.641e-18 +0.000e+00 +1.500e+11 +4.181e+03 +0.000e+00 +1.497e+11 +4.327e+03 +0.000e+00 +2.522e-09 +3.517e-17 +0.000e+00 -8.382e-04 +2.987e+04 +0.000e+00 -2.110e-04 +3.090e+04 +0.000e+00\nt = 0.15 : +2.027e-10 +2.019e-18 +0.000e+00 +1.500e+11 +4.480e+03 +0.000e+00 +1.497e+11 +4.636e+03 +0.000e+00 +2.702e-09 +4.037e-17 +0.000e+00 -8.980e-04 +2.987e+04 +0.000e+00 -2.260e-04 +3.090e+04 +0.000e+00\nt = 0.16 : +2.306e-10 +2.450e-18 +0.000e+00 +1.500e+11 +4.778e+03 +0.000e+00 +1.497e+11 +4.945e+03 +0.000e+00 +2.883e-09 +4.593e-17 +0.000e+00 -9.579e-04 +2.987e+04 +0.000e+00 -2.411e-04 +3.090e+04 +0.000e+00\nt = 0.17 : +2.603e-10 +2.938e-18 +0.000e+00 +1.500e+11 +5.077e+03 +0.000e+00 +1.497e+11 +5.254e+03 +0.000e+00 +3.063e-09 +5.186e-17 +0.000e+00 -1.018e-03 +2.987e+04 +0.000e+00 -2.562e-04 +3.090e+04 +0.000e+00\nt = 0.18 : +2.919e-10 +3.488e-18 +0.000e+00 +1.500e+11 +5.376e+03 +0.000e+00 +1.497e+11 +5.563e+03 +0.000e+00 +3.243e-09 +5.814e-17 +0.000e+00 -1.078e-03 +2.987e+04 +0.000e+00 -2.712e-04 +3.090e+04 +0.000e+00\nt = 0.19 : +3.252e-10 +4.102e-18 +0.000e+00 +1.500e+11 +5.674e+03 +0.000e+00 +1.497e+11 +5.872e+03 +0.000e+00 +3.423e-09 +6.477e-17 +0.000e+00 -1.138e-03 +2.987e+04 +0.000e+00 -2.863e-04 +3.090e+04 +0.000e+00\n```"}]}
{"messages": [{"role": "user", "content": "An N-gram is a sequence of N contiguous elements of a given text. Although N-grams refer sometimes to words or syllables, in this task we will consider only sequences of characters.\nThe task consists in, given a text and an integer size of the desired N-grams, find all the different contiguous sequences of N characters, together with the number of times they appear in the text.\nFor example, the 2-grams of the text \"Live and let live\" are:\n\n```\n \"LI\" - 2\n \"IV\" - 2\n \"VE\" - 2\n \" L\" - 2\n \"E \" - 1\n \" A\" - 1\n \"AN\" - 1\n \"ND\" - 1\n \"D \" - 1\n \"LE\" - 1\n \"ET\" - 1\n \"T \" - 1\n\n```\n\nNote that space and other non-alphanumeric characters are taken into account.\n\nSee also\n\n* Related task: Sorensen–Dice coefficient"}, {"role": "assistant", "content": "```\nsub n-gram ($this, $N=2) { Bag.new( flat $this.uc.map: { .comb.rotor($N => -($N-1))».join } ) }\ndd 'Live and let live'.&n-gram; # bi-gram\ndd 'Live and let live'.&n-gram(3); # tri-gram\n\n```\n\nOutput:\n\n```\n(\"IV\"=>2,\"T \"=>1,\"VE\"=>2,\"E \"=>1,\"LE\"=>1,\"AN\"=>1,\"LI\"=>2,\"ND\"=>1,\"ET\"=>1,\" L\"=>2,\" A\"=>1,\"D \"=>1).Bag\n(\"ET \"=>1,\"AND\"=>1,\"LIV\"=>2,\" LI\"=>1,\"ND \"=>1,\" LE\"=>1,\"IVE\"=>2,\"E A\"=>1,\"VE \"=>1,\"T L\"=>1,\"D L\"=>1,\"LET\"=>1,\" AN\"=>1).Bag\n```"}]}
{"messages": [{"role": "user", "content": "N-Queens: you've been there; done that; have the T-shirt. It is time to find the minimum number of Queens, Bishops or Knights that can be placed on an NxN board such that no piece attacks another but every unoccupied square is attacked.\n\nFor N=1 to 10 discover the minimum number of Queens, Bishops, and Knights required to fulfill the above requirement. For N=8 print out a possible solution for Queens and Bishops.\n\nLinks\n\n* OEIS Independent domination number for queens\n* OEIS Independent domination number for knights\n* ScienceDirect | minimum dominating set of queens - ways to do it."}, {"role": "assistant", "content": "Due to the time it's taking only a subset of the task are attempted.\n\n**Translation of**: Go\n\n```\n# 20220705 Raku programming solution\n\nmy (@board, @diag1, @diag2, @diag1Lookup, @diag2Lookup, $n, $minCount, $layout);\n\nmy %limits   = ( my @pieces = <Q B K> ) Z=> 7,7,6; # >>=>>> 10;\nmy %names    = @pieces Z=> <Queens Bishops Knights>;\n\nsub isAttacked(\\piece, \\row, \\col) {\n   given piece {\n      when 'Q' { \n         (^$n)>>.&{ return True if @board[$_;col] || @board[row;$_] }  \n\t return True if @diag1Lookup[@diag1[row;col]] || \n\t                @diag2Lookup[@diag2[row;col]]\n      }\n      when 'B' {\n         return True if @diag1Lookup[@diag1[row;col]] ||\n                        @diag2Lookup[@diag2[row;col]]\n      }\n      default { # 'K'\n         return True if (\n            @board[row;col] or \n            row+2 < $n && col-1 >= 0 && @board[row+2;col-1] or\n            row-2 >= 0 && col-1 >= 0 && @board[row-2;col-1] or\n            row+2 < $n && col+1 < $n && @board[row+2;col+1] or\n            row-2 >= 0 && col+1 < $n && @board[row-2;col+1] or\n            row+1 < $n && col+2 < $n && @board[row+1;col+2] or\n            row-1 >= 0 && col+2 < $n && @board[row-1;col+2] or\n            row+1 < $n && col-2 >= 0 && @board[row+1;col-2] or\n            row-1 >= 0 && col-2 >= 0 && @board[row-1;col-2]\n\t )\n      }\n   }\n   return False\n}\n\nsub attacks(\\piece, \\row, \\col, \\trow, \\tcol) {\n   given piece {\n      when 'Q' { row==trow || col==tcol || abs(row - trow)==abs(col - tcol) } \n      when 'B' { abs(row - trow) == abs(col - tcol) }\n      default  { my (\\rd,\\cd) = ((trow - row),(tcol - col))>>.abs; # when 'K' \n                 (rd == 1 && cd == 2) || (rd == 2 && cd == 1)               }\n   }\n}\n\nsub storeLayout(\\piece) {\n   $layout = [~] @board.map: -> @row { \n      [~] ( @row.map: { $_ ??  piece~' ' !! '. ' } ) , \"\\n\"\n   }   \n}\n\nsub placePiece(\\piece, \\countSoFar, \\maxCount) {\n   return if countSoFar >= $minCount; \n   my ($allAttacked,$ti,$tj) = True,0,0;\n   for ^$n X ^$n -> (\\i,\\j) {\n      unless isAttacked(piece, i, j) {\n         ($allAttacked,$ti,$tj) = False,i,j andthen last\n      }\n      last unless $allAttacked \n   }\n   if $allAttacked {\n      $minCount = countSoFar;\n      storeLayout(piece);\n      return\n   }\n   if countSoFar <= maxCount {\n      my ($si,$sj) = $ti,$tj;\n      if piece eq 'K' {\n         ($si,$sj) >>-=>> 2;\n         $si = 0 if $si < 0; \n         $sj = 0 if $sj < 0; \n      }\n      for ($si..^$n) X ($sj..^$n) -> (\\i,\\j) {\n         unless isAttacked(piece, i, j) {\n            if (i == $ti && j == $tj) || attacks(piece, i, j, $ti, $tj) {\n               @board[i][j] = True; \n               unless piece eq 'K' {\n\t          (@diag1Lookup[@diag1[i;j]],@diag2Lookup[@diag2[i;j]])=True xx *               \n               }\n               placePiece(piece, countSoFar+1, maxCount);\n               @board[i][j] = False; \n               unless piece eq 'K' {\n                  (@diag1Lookup[@diag1[i;j]],@diag2Lookup[@diag2[i;j]])=False xx *\n               }\n            }\n\t }\n      }\n   }\n}\n\nfor @pieces -> \\piece {\n   say %names{piece}~\"\\n=======\\n\";\n   loop ($n = 1 ; ; $n++) {\n      @board = [ [ False xx $n ] xx $n ]; \n      unless piece eq 'K' {\n         @diag1 = ^$n .map: { $_ ... $n+$_-1 } ;\n         @diag2 = ^$n .map: { $n+$_-1 ... $_ } ;\n\t @diag2Lookup = @diag1Lookup = [ False xx 2*$n-1 ]\n      }\n      $minCount = 2³¹ - 1; # golang: math.MaxInt32\n      my \\nSQ   = $n*$n;\n      for 1..nSQ -> \\maxCount {\n         placePiece(piece, 0, maxCount);\n         last if $minCount <= nSQ \n      }\n      printf(\"%2d x %-2d : %d\\n\", $n, $n, $minCount);\n      if $n == %limits{piece} {\n         printf \"\\n%s on a %d x %d board:\\n\", %names{piece}, $n, $n;\n         say $layout andthen last\n      }\n   }\n}\n\n```\n\nOutput:\n\n```\nQueens\n=======\n\n 1 x 1  : 1\n 2 x 2  : 1\n 3 x 3  : 1\n 4 x 4  : 3\n 5 x 5  : 3\n 6 x 6  : 4\n 7 x 7  : 4\n\nQueens on a 7 x 7 board:\n.  Q  .  .  .  .  . \n.  .  .  .  .  Q  . \n.  .  .  .  .  .  . \nQ  .  .  .  .  .  . \n.  .  .  .  Q  .  . \n.  .  .  .  .  .  . \n.  .  .  .  .  .  . \n\nBishops\n=======\n\n 1 x 1  : 1\n 2 x 2  : 2\n 3 x 3  : 3\n 4 x 4  : 4\n 5 x 5  : 5\n 6 x 6  : 6\n 7 x 7  : 7\n\nBishops on a 7 x 7 board:\n.  .  .  .  .  B  . \n.  .  B  .  .  .  . \n.  .  B  .  B  .  . \n.  .  .  .  .  .  B \n.  .  .  B  .  .  . \n.  .  .  B  .  .  . \n.  .  .  .  .  .  . \n\nKnights\n=======\n\n 1 x 1  : 1\n 2 x 2  : 4\n 3 x 3  : 4\n 4 x 4  : 4\n 5 x 5  : 5\n 6 x 6  : 8\n\nKnights on a 6 x 6 board:\nK  .  .  .  .  K \n.  .  .  .  .  . \n.  .  K  K  .  . \n.  .  K  K  .  . \n.  .  .  .  .  . \nK  .  .  .  .  K \n\n```"}]}
{"messages": [{"role": "user", "content": "Solve the eight queens puzzle.\n\nYou can extend the problem to solve the puzzle with a board of size   **N**x**N**.\n\nFor the number of solutions for small values of   **N**,   see   OEIS: A000170.\n\nRelated tasks\n\n* A\\* search algorithm\n* Solve a Hidato puzzle\n* Solve a Holy Knight's tour\n* Knight's tour\n* Peaceful chess queen armies\n* Solve a Hopido puzzle\n* Solve a Numbrix puzzle\n* Solve the no connection puzzle"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-11-29\n\nNeither pretty nor efficient, a simple backtracking solution\n\n```\nsub MAIN(\\N = 8) {\n    sub collision(@field, $row) {\n        for ^$row -> $i {\n            my $distance = @field[$i] - @field[$row];\n            return True if $distance == any(0, $row - $i, $i - $row);\n        }\n        False;\n    }\n    sub search(@field, $row) {\n        return @field if $row == N;\n        for ^N -> $i {\n            @field[$row] = $i;\n            return search(@field, $row + 1) || next\n                unless collision(@field, $row);\n        }\n        ()\n    }\n    for 0 .. N / 2 {\n        if search [$_], 1 -> @f {\n            say @f;\n            last;\n        }\n    }\n}\n```\n\nOutput:\n\n```\n[0 4 7 5 2 6 1 3]\n```"}]}
{"messages": [{"role": "user", "content": "**n-smooth**   numbers are positive integers which have no prime factors  >  **n**.\n\nThe   **n**   in the expression   **n-smooth**   is always prime;\n  \nthere are   no   **9-smooth** numbers.\n\n**1**   (unity)   is always included in n-smooth numbers.\n\n2-smooth   numbers are non-negative powers of two.\n  \n5-smooth   numbers are also called   Hamming numbers.\n  \n7-smooth   numbers are also called   humble numbers.\n\nA way to express   11-smooth   numbers is:\n\n```\n  11-smooth  =  2i × 3j × 5k × 7m × 11p\n\n```\n\n```\n           where     i, j, k, m, p ≥ 0  \n\n```\n\nTask\n:   * calculate and show the first   **25**   n-smooth numbers   for   **n=2**   ───►   **n=29**\n    * calculate and show   three numbers starting with   **3,000**   n-smooth numbers   for   **n=3**   ───►   **n=29**\n    * calculate and show twenty numbers starting with  **30,000**   n-smooth numbers   for   **n=503**   ───►   **n=521**   (optional)\n\nAll ranges   (for   **n**)   are to be inclusive, and only prime numbers are to be used.\n  \nThe (optional) n-smooth numbers for the third range are:   **503**,   **509**,   and   **521**.\n  \nShow all n-smooth numbers for any particular   **n**   in a horizontal list.\n  \nShow all output here on this page.\n\nRelated tasks\n:   * Hamming numbers\n    * humble numbers\n\nReferences\n:   * Wikipedia entry:   Hamming numbers     (this link is re-directed to   **Regular number**).\n    * Wikipedia entry:   Smooth number\n    * OEIS entry:   A000079    2-smooth numbers or non-negative powers of two\n    * OEIS entry:   A003586    3-smooth numbers\n    * Mintz 1981:   3-smooth numbers\n    * OEIS entry:   A051037    5-smooth numbers or Hamming numbers\n    * OEIS entry:   A002473    7-smooth numbers or humble numbers\n    * OEIS entry:   A051038   11-smooth numbers\n    * OEIS entry:   A080197   13-smooth numbers\n    * OEIS entry:   A080681   17-smooth numbers\n    * OEIS entry:   A080682   19-smooth numbers\n    * OEIS entry:   A080683   23-smooth numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\n```\nsub smooth-numbers (*@list) {\n    cache my \\Smooth := gather {\n        my %i = (flat @list) Z=> (Smooth.iterator for ^@list);\n        my %n = (flat @list) Z=> 1 xx *;\n \n        loop {\n            take my $n := %n{*}.min;\n \n            for @list -> \\k {\n                %n{k} = %i{k}.pull-one * k if %n{k} == $n;\n            }\n        }\n    }\n}\n\nsub abbrev ($n) {\n   $n.chars > 50 ??\n   $n.substr(0,10) ~ \"...({$n.chars - 20} digits omitted)...\" ~ $n.substr(* - 10) !!\n   $n\n}\n \nmy @primes = (2..*).grep: *.is-prime;\n \nmy $start = 3000;\n \nfor ^@primes.first( * > 29, :k ) -> $p {\n    put join \"\\n\", \"\\nFirst 25, and {$start}th through {$start+2}nd {@primes[$p]}-smooth numbers:\",\n    $(smooth-numbers(|@primes[0..$p])[^25]),\n    $(smooth-numbers(|@primes[0..$p])[$start - 1 .. $start + 1]».&abbrev);\n}\n \n$start = 30000;\n \nfor 503, 509, 521 -> $p {\n    my $i = @primes.first( * == $p, :k );\n    put \"\\n{$start}th through {$start+19}th {@primes[$i]}-smooth numbers:\\n\" ~\n    smooth-numbers(|@primes[0..$i])[$start - 1 .. $start + 18];\n}\n\n```\n\nOutput:\n\n```\nFirst 25, and 3000th through 3002nd 2-smooth numbers:\n1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 524288 1048576 2097152 4194304 8388608 16777216\n6151159610...(883 digits omitted)...9114994688 1230231922...(884 digits omitted)...8229989376 2460463844...(884 digits omitted)...6459978752\n\nFirst 25, and 3000th through 3002nd 3-smooth numbers:\n1 2 3 4 6 8 9 12 16 18 24 27 32 36 48 54 64 72 81 96 108 128 144 162 192\n91580367978306252441724649472 92829823186414819915547541504 94096325042746502515294076928\n\nFirst 25, and 3000th through 3002nd 5-smooth numbers:\n1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 25 27 30 32 36 40 45 48 50 54\n278942752080 279936000000 281250000000\n\nFirst 25, and 3000th through 3002nd 7-smooth numbers:\n1 2 3 4 5 6 7 8 9 10 12 14 15 16 18 20 21 24 25 27 28 30 32 35 36\n50176000 50331648 50388480\n\nFirst 25, and 3000th through 3002nd 11-smooth numbers:\n1 2 3 4 5 6 7 8 9 10 11 12 14 15 16 18 20 21 22 24 25 27 28 30 32\n2112880 2116800 2117016\n\nFirst 25, and 3000th through 3002nd 13-smooth numbers:\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 18 20 21 22 24 25 26 27 28\n390000 390390 390625\n\nFirst 25, and 3000th through 3002nd 17-smooth numbers:\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 20 21 22 24 25 26 27\n145800 145860 146016\n\nFirst 25, and 3000th through 3002nd 19-smooth numbers:\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 24 25 26\n74256 74358 74360\n\nFirst 25, and 3000th through 3002nd 23-smooth numbers:\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n46552 46575 46585\n\nFirst 25, and 3000th through 3002nd 29-smooth numbers:\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n33516 33524 33534\n\n30000th through 30019th 503-smooth numbers:\n62913 62914 62916 62918 62920 62923 62926 62928 62930 62933 62935 62937 62944 62946 62951 62952 62953 62957 62959 62964\n\n30000th through 30019th 509-smooth numbers:\n62601 62602 62604 62607 62608 62609 62611 62618 62620 62622 62624 62625 62626 62628 62629 62634 62640 62643 62645 62646\n\n30000th through 30019th 521-smooth numbers:\n62287 62288 62291 62292 62300 62304 62307 62308 62310 62315 62320 62321 62322 62325 62328 62329 62330 62331 62335 62336\n```"}]}
{"messages": [{"role": "user", "content": "Create a function which takes in a number of arguments which are specified by name rather than (necessarily) position, and show how to call the function. If the language supports reordering the arguments or optionally omitting some of them, note this.\n\n**Note:**\n\n:   Named parameters relies on being able to use the names given to function parameters when the function is defined, when assigning arguments when the function is called.\n:   For example, if a function were to be defined as `define func1( paramname1, paramname2)`; then it could be called normally as `func1(argument1, argument2)` and in the called function paramname1 would be associated with argument1 and paramname2 with argument2.\n:   `func1` **must also be able to be called in a way that visually binds each parameter to its respective argument, irrespective of argument order**, for example: `func1(paramname2=argument2, paramname1=argument1)` which *explicitly* makes the same parameter/argument bindings as before.\n:   Named parameters are often a feature of languages used in safety critical areas such as Verilog and VHDL.\n\n**See also:**\n\n* Varargs\n* Optional parameters\n* Wikipedia: Named parameter"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #22 \"Thousand Oaks\"\n\nRaku's support for optional parameters is much like Python's. Consider this declaration:\n\n```\nsub funkshun ($a, $b?, $c = 15, :$d, *@e, *%f) {\n   ...\n}\n\n```\n\nIn the above signature:\n\n* `$a` is a mandatory parameter accepted by position (`funkshun 15, ...`).\n* `$b` is an optional parameter that can be passed by position or by name. By default, it's undefined.\n* `$c` is an optional parameter that can be passed by position or by name. Its default value is `15`.\n* `$d` is an optional parameter that can only be passed by name. By default, it's undefined.\n* `@e` is a slurpy array: it receives any leftover positional arguments.\n* `%f` is a slurpy hash: it receives any leftover named arguments.\n\nSo, if we defined the function like this:\n\n```\nsub funkshun ($a, $b?, :$c = 15, :$d, *@e, *%f) {\n   say \"$a $b $c $d\";\n   say join ' ', @e;\n   say join ' ', keys %f;\n}\n\n# this particularly thorny call:\n\nfunkshun\n    'Alfa', k1 => 'v1', c => 'Charlie', 'Bravo', 'e1',\n    d => 'Delta', 'e2', k2 => 'v2';\n\n```\n\nwould print this:\n\n```\nAlfa Bravo Charlie Delta\ne1 e2\nk1 k2\n```"}]}
{"messages": [{"role": "user", "content": "Translate the spelled-out English name of a number to a number. You can use a preexisting implementation or roll your own, but you should support inputs up to at least one million (or the maximum value of your language's default bounded integer type, if that's less).\n\nSupport for inputs other than positive integers (like zero, negative integers, fractions and floating-point numbers) is optional.\n\nSee also\n\n* Number names — the reverse operation."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nmy $phrases-with-numbers = q:to/END/;\nOne Hundred and One Dalmatians\nTwo Thousand and One: A Space Odyssey\n\nFour  Score  And  Seven  Years  Ago\ntwelve dozen is one hundred forty-four, aka one gross\ntwo hundred pairs of socks\nAlways give one hundred and ten percent effort\nChange due: zero dollars and thirty-seven cents\n\nOne hour, fifty-nine minutes, forty point two seconds\nπ ≅ three point one four one five nine\nEND\n\nmy $pure-numbers = q:to/END/;\nTwenty Nineteen\nTwo Thousand Nineteen\nTwo Thousand Zero Hundred and Nineteen\nTwo Thousand Ten Nine\n\none thousand one\nninety nine thousand nine hundred ninety nine\nfive hundred and twelve thousand, six hundred and nine\ntwo billion, one hundred\n\nOne Thousand One Hundred Eleven\nEleven Hundred Eleven\none hundred eleven billion one hundred eleven\nEight Thousand Eight Hundred Eighty-Eight\nEighty-Eight Hundred Eighty-Eight\n\nForty-two quintillion, one quadrillion, two trillion, three billion, four million, five thousand six\nEND\n\nmy %nums = (\n    zero        => 0,     one        => 1,     two         => 2,     three    => 3,\n    four        => 4,     five       => 5,     six         => 6,     seven    => 7,\n    eight       => 8,     nine       => 9,     ten         => 10,    eleven   => 11,\n    twelve      => 12,    thirteen   => 13,    fourteen    => 14,    fifteen  => 15,\n    sixteen     => 16,    seventeen  => 17,    eighteen    => 18,    nineteen => 19,\n    twenty      => 20,    thirty     => 30,    forty       => 40,    fifty    => 50,\n    sixty       => 60,    seventy    => 70,    eighty      => 80,    ninety   => 90,\n    hundred     => 100,   thousand   => 1_000, million     => 1_000_000,\n    billion     => 1_000_000_000,              trillion    => 1_000_000_000_000,\n    quadrillion => 1_000_000_000_000_000,      quintillion => 1_000_000_000_000_000_000\n);\n\n# groupings:     thousand million billion  trillion quadrillion quintillion\nmy token groups { \\d**4  | \\d**7 | \\d**10 | \\d**13 | \\d**16    | \\d**19 };\n\n# remove hyphens/spaces: leading, trailing, multiple\nsub squeeze ($str is copy) { $str ~~ s:g/'-' | \\s+ / /; $str .=trim }\n\n# commify larger numbers for readabilty\nsub comma { $^i.chars > 4 ?? $^i.flip.comb(3).join(',').flip !! $^i }\n\nsub numify ($str is copy) {\n    $str = squeeze $str.lc;\n    $str ~~ s:g/(.)(<punct>)/$0 $1/;\n\n    for %nums.kv -> $word, $number { $str ~~ s:g/ <|w> $word <|w> / $number / }\n\n    $str ~~ s:g/(\\d+)<ws> <?before \\d>/$0/ if $str ~~ /(point )<ws>[(\\d)<ws>]+$/;\n    $str ~~ s:g/(\\d+) <ws> 'score' / {$0 * 20} /;\n    $str ~~ s:g/(\\d) <ws> [','|'and'] <ws> (\\d)/$0 $1/;\n\n    $str ~~ s:g/ <|w> (\\d) <ws> 100 <ws> (\\d\\d) <ws> (\\d) <ws>     (<groups>) <|w> / {($0 * 100 + $1 + $2) * $3} /;\n    $str ~~ s:g/ <|w> (\\d) <ws> 100 <ws> (\\d ** 1..2)     <ws>     (<groups>) <|w> / {($0 * 100 + $1) * $2}      /;\n    $str ~~ s:g/ <|w> (\\d) <ws> 100                       <ws>     (<groups>) <|w> / { $0 * 100 * $1}            /;\n    $str ~~ s:g/ <|w>      <ws> 100 <ws> (\\d\\d) <ws> (\\d) <ws>     (<groups>) <|w> / {($0 + 100 + $1) * $2}      /;\n    $str ~~ s:g/ <|w>      <ws> 100 <ws> (\\d ** 1..2)     <ws>     (<groups>) <|w> / {($0 + 100     ) * $1}      /;\n    $str ~~ s:g/ <|w>      <ws> 100                       <ws>     (<groups>) <|w> / { $0 * 100}                 /;\n    $str ~~ s:g/ <|w>              (\\d\\d) <ws> (\\d)       <ws>     (<groups>) <|w> / {($0 + $1) * $2}            /;\n    $str ~~ s:g/ <|w>              (\\d ** 1..2)           <ws>     (<groups>) <|w> / { $0 * $1}                  /;\n    $str ~~ s:g/ <|w>              (\\d\\d) <ws> (\\d)       <ws> 100            <|w> / {($0 + $1) * 100}           /;\n    $str ~~ s:g/ <|w>              (\\d ** 1..2)           <ws> 100            <|w> / { $0 * 100}                 /;\n    $str ~~ s:g/ <|w>              (\\d ** 2)<ws>(\\d ** 2)                     <|w> / { $0 * 100 + $1}            /;\n\n    $str ~~ s:g/( [\\d+<ws>]* \\d+ ) / {[+] $0.split: ' '} /;\n\n    $str ~~ s:g/(\\d+) <ws> 'pairs of'         /  {$0 *  2} /;\n    $str ~~ s:g/(\\d+) <ws> 'dozen'            /  {$0 * 12} /;\n    $str ~~ s:g/(\\d+) <ws> 'point' <ws> (\\d+) /   $0.$1    /;\n    $str ~~ s:g/(\\d+) <ws> 'percent'          /   $0%      /;\n    $str ~~ s:g/(\\d+) <ws> 'dollars'          / \\$$0       /;\n    $str ~~ s:g/(\\d+) <ws> 'cents'            /   $0¢      /;\n\n    squeeze $str;\n}\n\nsay $_ ~ ' --> ' ~ .&numify        for $phrases-with-numbers.split(\"\\n\").grep: *.so;\nsay $_ ~ ' --> ' ~ .&numify.&comma for         $pure-numbers.split(\"\\n\").grep: *.so;\n\n```\n\nOutput:\n\n```\nOne Hundred and One Dalmatians --> 101 dalmatians\nTwo Thousand and One: A Space Odyssey --> 2001 : a space odyssey\nFour  Score  And  Seven  Years  Ago   --> 87 years ago\ntwelve dozen is one hundred forty-four, aka one gross --> 144 is 144 , aka 1 gross\ntwo hundred pairs of socks --> 400 socks\nAlways give one hundred and ten percent effort --> always give 110% effort\nChange due: zero dollars and thirty-seven cents --> change due : $0 and 37¢\nOne hour, fifty-nine minutes, forty point two seconds --> 1 hour , 59 minutes , 40.2 seconds\nπ ≅ three point one four one five nine --> π ≅ 3.14159\nTwenty Nineteen --> 2019\nTwo Thousand Nineteen --> 2019\nTwo Thousand Zero Hundred and Nineteen --> 2019\nTwo Thousand Ten Nine --> 2019\none thousand one --> 1001\nninety nine thousand nine hundred ninety nine --> 99,999\nfive hundred and twelve thousand, six hundred and nine --> 512,609\ntwo billion, one hundred --> 2,000,000,100\nOne Thousand One Hundred Eleven --> 1111\nEleven Hundred Eleven --> 1111\none hundred eleven billion one hundred eleven --> 111,000,000,111\nEight Thousand Eight Hundred Eighty-Eight --> 8888\nEighty-Eight Hundred Eighty-Eight --> 8888\nForty-two quintillion, one quadrillion, two trillion, three billion, four million, five thousand six --> 42,001,002,003,004,005,006\n```"}]}
{"messages": [{"role": "user", "content": "Many languages have naming conventions regarding the identifiers used in the language, its libraries, and programs written in the language. Such conventions, which may be classified as *de facto* or *de jure* depending on how they are enforced,\noften take the form of rules regarding prefixes, suffixes, and the use of upper-case and lower-case characters.\n\nThe naming conventions are sometimes a bit haphazard, especially if the language and/or library has gone through periods of evolution. (In this case: give a brief example and description.)\n\nDocument (with simple examples where possible) the evolution and current status of these naming conventions.\nFor example, name conventions for:\n\n* Procedure and operator names. (Intrinsic or external)\n* Class, Subclass and instance names.\n* Built-in versus libraries names.\n\nIf possible, indicate where the naming conventions are implicit, explicit, mandatory or discretionary.\nAny tools that enforced the the naming conventions.\nAny cases where the naming convention as commonly violated.\n\nIf possible, indicate where the convention is used to hint at other issues. For example the C standard library uses a prefix of \"\\_\" to \"hide\" raw Operating System calls from the non systems-programmer, whereas Python embeds member functions in between \"\\_\\_\" to make a member function \"private\".\n\nSee also\n\n* Wikipedia: Naming convention (programming)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku is written in Unicode, and has consistent Unicode semantics regardless of the underlying text representations. By default Raku presents Unicode in \"NFG\" formation, where each grapheme counts as one character. A grapheme is what the user would think of as a character in their normal everyday life, including any diacritics.\n\nBuilt-in object types start with an uppercase letter. This includes immutable types (e.g. Int, Num, Complex, Rat, Str, Bit, Regex, Set, Block, Iterator), as well as mutable (container) types, such as Scalar, Array, Hash, Buf, Routine, Module, and non-instantiable Roles such as Callable and Integral. The names may extend to CamelCase for compound words: IntStr, CaptureCursor, BagHash, SoftRoutine.\n\nNon-object (native) types are lowercase: int, num, complex, rat, buf, bit.\n\nNearly all built-in subroutines, functions, methods and pragmas included in Raku CORE are lowercase or lower kebab-case. (Compound words joined with hyphens rather than underscores or camelCase.) .grep, .pairs, .log, .defined, .subst-rw. The few notable exceptions are those which can radically change behaviour of the executing code. They are in all-cap/kebab-case to make them stand out: EVAL, MONKEY-TYPING.\n\nAll upper case names are semi-reserved. You are free to use them, but are warned that you may encounter future collisions with internal usage. Upper case names are used for pseudo-packages: MY, OUR, CORE, GLOBAL, etc., for relative scope identifiers: CALLER, OUTER, SETTING, PARENT, etc. and other things.\n\nVariables in Raku CORE tend be lower kebab-case for lexical variables and upper case for special or package globals. They have an attached, prefix sigil (or twigil) to indicate what type of object they hold and what methods are available to operate on them.\n\nIn user space, there are very few restrictions on how things are named. Identifiers of any type can not contain white space. Subroutines must start with a letter character, any Unicode character that has a \"letter\" property. Variable names can't contain any of the sigil, twigil or comment characters ($, @, %, \\*, ?, =, :, #). Outside of those few restrictions, it's pretty much a free-for-all.\n\nThat being said, there are some community conventions which are encouraged, though not enforced. Descriptiveness is favoured over terseness, though this should be scaled to the scope of the object. It is perfectly fine to name an index variable in a three line loop, $i. An object in global scope with dozens of methods may be better off with a more descriptive name. It is encouraged to name subroutines for what they do to make it easier for others to follow your logic. Nouny things should have nouny names. Verby things should be verby. Finally, if you *aren't* going to follow convention, at least be consistent."}]}
{"messages": [{"role": "user", "content": "Quoting from the Esolangs wiki page:\n\n> A **narcissist** (or **Narcissus program**) is the decision-problem version of a quine.\n\n> A quine, when run, takes no input, but produces a copy of its own source code at its output. In contrast, a narcissist reads a string of symbols from its input, and produces no output except a \"1\" or \"accept\" if that string matches its own source code, or a \"0\" or \"reject\" if it does not.\n\nFor concreteness, in this task we shall assume that symbol = character.\n\nThe narcissist should be able to cope with any finite input, whatever its length.\n\nAny form of output is allowed, as long as the program always halts, and \"accept\", \"reject\" and \"not yet finished\" are distinguishable."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nFor the narcissist to work you must be very careful with whitespace. The following version works if it is given to standard input as exactly one line terminated by a newline character.\n\nNote how the code takes advantage of Raku's ability to nest quoting delimiters.\n\n```\nEVAL my $self = q{say slurp() eq q[EVAL my $self = q{]~$self~q[}]~10.chr ?? q{Beautiful!} !! q{Not my type.}}\n\n```\n\nOutput:\n\n```\n$ narcissist='EVAL my $self = q{say slurp() eq q[EVAL my $self = q{]~$self~q[}]~10.chr ?? q{Beautiful!} !! q{Not my type.}}'\n$ raku -e \"$narcissist\" <<<\"$narcissist\"\nBeautiful!\n$ raku -e \"$narcissist\" <<<\"$narcissist # a comment ruining it all\" \nNot my type.\n\n```"}]}
{"messages": [{"role": "user", "content": "A   Narcissistic decimal number   is a non-negative integer,   \n\nn\n{\\displaystyle {\\displaystyle n}}\n,   that is equal to the sum of the   \n\nm\n{\\displaystyle {\\displaystyle m}}\n-th   powers of each of the digits in the decimal representation of   \n\nn\n{\\displaystyle {\\displaystyle n}}\n,   where   \n\nm\n{\\displaystyle {\\displaystyle m}}\n   is the number of digits in the decimal representation of   \n\nn\n{\\displaystyle {\\displaystyle n}}\n.\n\nNarcissistic (decimal) numbers are sometimes called   **Armstrong**   numbers, named after Michael F. Armstrong.\n  \nThey are also known as   **Plus Perfect**   numbers.\n\nAn example\n:   :   :   :   * if   \n\n                  n\n                  {\\displaystyle {\\displaystyle n}}\n                     is   **153**\n                * then   \n\n                  m\n                  {\\displaystyle {\\displaystyle m}}\n                  ,   (the number of decimal digits)   is   **3**\n                * we have    13 + 53 + 33   =   1 + 125 + 27   =   **153**\n                * and so   **153**   is a narcissistic decimal number\n\nTask\n\nGenerate and show here the first   **25**   narcissistic decimal numbers.\n\nNote:   \n\n0\n\n1\n=\n0\n{\\displaystyle {\\displaystyle 0^{1}=0}}\n,   the first in the series.\n\nSee also\n\n* the  OEIS entry:     Armstrong (or Plus Perfect, or narcissistic) numbers.\n* MathWorld entry:   Narcissistic Number.\n* Wikipedia entry:     Narcissistic number."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Simple, with concurrency\n\nSimple implementation is not exactly speedy, but concurrency helps move things along.\n\n```\nsub is-narcissistic(Int $n) { $n == [+] $n.comb »**» $n.chars }\nmy @N = lazy (0..∞).hyper.grep: *.&is-narcissistic;\n@N[^25].join(' ').say;\n\n```\n\nOutput:\n\n```\n0 1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 54748 92727 93084 548834 1741725 4210818 9800817 9926315\n```\n\n### Single-threaded, with precalculations\n\nThis version that precalculates the values for base 1000 digits, but despite the extra work ends up taking more wall-clock time than the simpler version.\n\n```\nsub kigits($n) {\n    my int $i = $n;\n    my int $b = 1000;\n    gather while $i {\n        take $i % $b;\n        $i = $i div $b;\n    }\n}\n\nfor (1..*) -> $d {\n    my @t = 0..9 X** $d;\n    my @table = @t X+ @t X+ @t;\n    sub is-narcissistic(\\n) { n == [+] @table[kigits(n)] };\n    state $l = 2;\n    FIRST say \"1\\t0\";\n    say $l++, \"\\t\", $_ if .&is-narcissistic for 10**($d-1) ..^ 10**$d;\n    last if $l > 25\n};\n\n```\n\nOutput:\n\n```\n1\t0\n2\t1\n3\t2\n4\t3\n5\t4\n6\t5\n7\t6\n8\t7\n9\t8\n10\t9\n11\t153\n12\t370\n13\t371\n14\t407\n15\t1634\n16\t8208\n17\t9474\n18\t54748\n19\t92727\n20\t93084\n21\t548834\n22\t1741725\n23\t4210818\n24\t9800817\n25\t9926315\n```"}]}
{"messages": [{"role": "user", "content": "\n\n**In short:** Use the specimen language (native) for \"scripting\".\n\nExample\n:   If your language is \"foo\", then the test case of \"echo.foo\" runs in a terminal as \"./echo.foo Hello, world!\".\n\n**In long**: Create a program (in the specimen language) that will automatically compile a *test case* (of the same specimen language) to a native binary executable and then transparently load and run this *test case* executable.\n\nMake it so that all that is required is a custom shebangs\nat the start of the *test case*. e.g. \"#!/usr/local/bin/script\\_foo\"\n\n**Importantly:** This task must be coded **strictly** in the specimen language, **neither** using a shell script **nor** any other 3rd language.\n\nOptimise this progress so that the *test program* **binary executable** is only created if the original *test program* **source code** as been touched/edited.\n\nNote: If the lauguage (or a specific implementation) handles this automatically,\nthen simple provide an example of \"echo.foo\"\n\n**Background:**\n\nSimple shebangs can help with scripting, e.g. \"#!/usr/bin/env python\" at the top of a Python script will allow it to be run in a terminal as \"./script.py\".\n\nThe task Multiline shebang largely demonstrates how to use \"shell\" code in the shebang to compile and/or run source-code from a 3rd language, typically \"#!/bin/bash\" or \"#!/bin/sh\".\n\n**This task:**\n\nHowever in this task **Native shebang** task we are go *native*.\nIn the shebang, instead of running a shell, we call a binary-executable\ngenerated from the original native language,\ne.g. when using C with gcc \"#!/usr/local/bin/script\\_gcc\"\nto extract, compile and run the native \"script\" source code.\n\nOther small innovations required of this *Native shebang* task:\n\n* Cache the executable in some appropriate place in a path, dependant on available write permissions.\n* Generate a new cached executable only when the source has been touched.\n* If a cached is available, then run this instead of regenerating a new executable.\n\n**Difficulties:**\n\n* Naturally, some languages are not compiled. These languages are forced to use shebang executables from another language, eg \"#!/usr/bin/env python\" uses the C binaries /usr/bin/env and /usr/bin/python. If this is the case, then simply document the details of the case.\n* In a perfect world, the test file (e.g. *echo.c*) would still be a valid program, and would compile without error using the native compiler (e.g. *gcc* for *text.c*). The problem is that \"#!\" is syntactically incorrect on many languages, but in others it can be parsed as a comment.\n* The \"test binary\" should be exec-ed and hence retain the original Process identifier.\n\n**Test case:**\n\n* Create a simple \"script file\" (in the same native language) called \"echo\" then use the \"script\" to output \"Hello, world!\""}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku is not installed by default on most systems and does not have a default install directory, so the path will vary by system.\n\n**Works with**: Rakudo version 2020.02\n\n**File: echo.p6**\n\n```\n#!/path/to/raku\nput @*ARGS;\n\n```\n\n**Usage:**\n\n```\n./echo.p6 Hello, world!\n\n```\n\nOutput:\n\n```\nHello, world!\n\n```"}]}
{"messages": [{"role": "user", "content": "Natural sorting is the sorting of text that does more than rely on the\norder of individual characters codes to make the finding of\nindividual strings easier for a *human* reader.\n\nThere is no \"one true way\" to do this, but for the purpose of this task 'natural' orderings might include:\n\n:   1. Ignore leading, trailing and multiple adjacent spaces\n:   2. Make all whitespace characters equivalent.\n:   3. Sorting without regard to case.\n:   4. Sorting numeric portions of strings in numeric order.\n\n    :   That is split the string into fields on numeric boundaries, then sort on each field, with the rightmost fields being the most significant, and numeric fields of integers treated as numbers.\n    :   foo9.txt before foo10.txt\n    :   As well as ... x9y99 before x9y100, before x10y0\n    :   ... (for any number of groups of integers in a string).\n:   5. Title sorts: without regard to a leading, very common, word such\n\n    :   as 'The' in \"The thirty-nine steps\".\n:   6. Sort letters without regard to accents.\n:   7. Sort ligatures as separate letters.\n:   8. Replacements:\n\n    :   Sort German eszett or scharfes S (ß)       as   ss\n    :   Sort ſ, LATIN SMALL LETTER LONG S     as   s\n    :   Sort ʒ, LATIN SMALL LETTER EZH           as   s\n    :   ∙∙∙\n\nTask Description\n\n* **Implement the first four** of the eight given features in a natural sorting routine/function/method...\n* Test each feature implemented separately with an ordered list of test strings from the   **Sample inputs**   section below,   and make sure your naturally sorted output is in the same order as other language outputs such as    `Python`.\n* Print and display your output.\n* **For extra credit** implement more than the first four.\n\nNote:   it is not necessary to have individual control of which features are active in the natural sorting routine at any time.\n\nSample input\n\n```\n• Ignoring leading spaces.                       Text strings:   ['ignore leading spaces:  2-2',\n                                                                  'ignore leading spaces:  2-1', \n                                                                  'ignore leading spaces:  2+0',\n                                                                  'ignore leading spaces:  2+1']\n\n• Ignoring multiple adjacent spaces (MAS).       Text strings:   ['ignore MAS spaces:  2-2', \n                                                                  'ignore MAS spaces:  2-1', \n                                                                  'ignore MAS spaces:  2+0', \n                                                                  'ignore MAS spaces:  2+1']\n\n• Equivalent whitespace characters.              Text strings:   ['Equiv.  spaces:     3-3', \n                                                                  'Equiv. \\rspaces:    3-2', \n                                                                  'Equiv. \\x0cspaces:  3-1', \n                                                                  'Equiv. \\x0bspaces:  3+0', \n                                                                  'Equiv. \\nspaces:    3+1', \n                                                                  'Equiv. \\tspaces:    3+2']\n\n• Case Independent sort.                         Text strings:   ['cASE INDEPENDENT:  3-2', \n                                                                  'caSE INDEPENDENT:  3-1', \n                                                                  'casE INDEPENDENT:  3+0', \n                                                                  'case INDEPENDENT:  3+1']\n  \n• Numeric fields as numerics.                    Text strings:   ['foo100bar99baz0.txt', \n                                                                  'foo100bar10baz0.txt', \n                                       sv                           'foo1000bar99baz10.txt', \n                                                                  'foo1000bar99baz9.txt']\n\n• Title sorts.                                   Text strings:   ['The Wind in the Willows', \n                                                                  'The 40th step more', \n                                                                  'The 39 steps', \n                                                                  'Wanda']\n\n• Equivalent accented characters (and case).     Text strings:   [u'Equiv. \\xfd accents:  2-2', \n                                                                  u'Equiv. \\xdd accents:  2-1', \n                                                                  u'Equiv.  y accents:    2+0', \n                                                                  u'Equiv.  Y accents:    2+1']\n\n• Separated ligatures.                           Text strings:   [u'\\u0132 ligatured ij', \n                                                                   'no ligature']\n\n• Character replacements.                        Text strings:   [u'Start with an \\u0292:  2-2', \n                                                                  u'Start with an \\u017f:  2-1', \n                                                                  u'Start with an \\xdf:    2+0', \n                                                                  u'Start with an  s:      2+1']\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-11-02\n\nIn Raku it is very easy to modify the default sorting order by passing in a\ntransform routine to the sort function. If the transform routines are arity one,\nthe sort function will apply a Schwartzian Transform so it only needs to calculate\nthe transform once. Note that the transforms are non-destructive; The sort function\nreturns the original strings.\n\nThe following are a series of subroutines to perform the various natural\nsorting transforms. They may be applied individually or mixed and matched\nto get the particular result desired. When more than one is strung\ntogether, they apply left to right. Some combinations may yield\ndifferent results depending on the order they are applied.\n\n```\n# Sort groups of digits in number order. Sort by order of magnitude then lexically.\nsub naturally ($a) { $a.lc.subst(/(\\d+)/, ->$/ {0~$0.chars.chr~$0},:g) ~\"\\x0\"~$a }\n\n# Collapse multiple ws characters to a single.\nsub collapse ($a) { $a.subst( / ( \\s ) $0+ /, -> $/ { $0 }, :g ) }\n\n# Convert all ws characters to a space.\nsub normalize ($a) { $a.subst( / ( \\s ) /, ' ', :g ) }\n\n# Ignore common leading articles for title sorts\nsub title ($a) { $a.subst( / :i ^ ( a | an | the ) >> \\s* /, '' ) }\n\n# Decompose ISO-Latin1 glyphs to their base character.\nsub latin1_decompose ($a) {\n    $a.trans: < \n       Æ AE æ ae Þ TH þ th Ð TH ð th ß ss À A Á A Â A Ã A Ä A Å A à a á a\n        â a ã a ä a å a Ç C ç c È E É E Ê E Ë E è e é e ê e ë e Ì I Í I Î\n        I Ï I ì i í i î i ï i Ò O Ó O Ô O Õ O Ö O Ø O ò o ó o ô o õ o ö o\n        ø o Ñ N ñ n Ù U Ú U Û U Ü U ù u ú u û u ü u Ý Y ÿ y ý y\n    >.hash;\n}\n\n# Used as:\n\nmy @tests = (\n    [\n        \"Task 1a\\nSort while ignoring leading spaces.\",\n        [\n          'ignore leading spaces: 1', '   ignore leading spaces: 4',\n          '  ignore leading spaces: 3', ' ignore leading spaces: 2'\n        ],\n        {.trim} # builtin method.\n    ],\n    [\n        \"Task 1b\\nSort while ignoring multiple adjacent spaces.\",\n        [\n          'ignore m.a.s   spaces: 3', 'ignore m.a.s spaces: 1',\n          'ignore m.a.s    spaces: 4', 'ignore m.a.s  spaces: 2'\n        ],\n        {.&collapse}\n    ],\n    [\n        \"Task 2\\nSort with all white space normalized to regular spaces.\",\n        [\n          \"Normalized\\tspaces: 4\", \"Normalized\\xa0spaces: 1\",\n          \"Normalized\\x20spaces: 2\", \"Normalized\\nspaces: 3\"\n        ],\n        {.&normalize}\n    ],\n    [\n        \"Task 3\\nSort case independently.\",\n        [\n          'caSE INDEPENDENT: 3', 'casE INDEPENDENT: 2',\n          'cASE INDEPENDENT: 4', 'case INDEPENDENT: 1'\n        ],\n        {.lc} # builtin method\n    ],\n    [\n        \"Task 4\\nSort groups of digits in natural number order.\",\n        [\n          <Foo100bar99baz0.txt foo100bar10baz0.txt foo1000bar99baz10.txt\n           foo1000bar99baz9.txt 201st 32nd 3rd 144th 17th 2 95>\n        ],\n        {.&naturally}\n    ],\n    [\n        \"Task 5 ( mixed with 1, 2, 3 & 4 )\\n\"\n        ~ \"Sort titles, normalize white space, collapse multiple spaces to\\n\"\n        ~ \"single, trim leading white space, ignore common leading articles\\n\"\n        ~ 'and sort digit groups in natural order.',\n        [\n          'The Wind\tin the Willows  8', '  The 39 Steps               3',\n          'The    7th Seal              1', 'Wanda                        6',\n          'A Fish Called Wanda          5', ' The Wind and the Lion       7',\n          'Any Which Way But Loose      4', '12 Monkeys                   2'\n        ],\n        {.&normalize.&collapse.trim.&title.&naturally}\n    ],\n    [\n        \"Task 6, 7, 8\\nMap letters in Latin1 that have accents or decompose to two\\n\"\n        ~ 'characters to their base characters for sorting.',\n        [\n          <apple Ball bald car Card above Æon æon aether\n            niño nina e-mail Évian evoke außen autumn>\n        ],\n        {.&latin1_decompose.&naturally}\n    ]\n);\n\n\nfor @tests -> $case {\n    my $code_ref = $case.pop;\n    my @array = $case.pop.list;\n    say $case.pop, \"\\n\";\n\n    say \"Standard Sort:\\n\";\n    .say for @array.sort;\n\n    say \"\\nNatural Sort:\\n\";\n    .say for @array.sort: {.$code_ref};\n\n    say \"\\n\" ~ '*' x 40 ~ \"\\n\";\n}\n\n```\n\nSample output:\n\n```\nTask 1a\nSort while ignoring leading spaces.\n\nStandard Sort:\n\n   ignore leading spaces: 4\n  ignore leading spaces: 3\n ignore leading spaces: 2\nignore leading spaces: 1\n\nNatural Sort:\n\nignore leading spaces: 1\n ignore leading spaces: 2\n  ignore leading spaces: 3\n   ignore leading spaces: 4\n\n****************************************\n\nTask 1b\nSort while ignoring multiple adjacent spaces.\n\nStandard Sort:\n\nignore m.a.s    spaces: 4\nignore m.a.s   spaces: 3\nignore m.a.s  spaces: 2\nignore m.a.s spaces: 1\n\nNatural Sort:\n\nignore m.a.s spaces: 1\nignore m.a.s  spaces: 2\nignore m.a.s   spaces: 3\nignore m.a.s    spaces: 4\n\n****************************************\n\nTask 2\nSort with all white space normalized to regular spaces.\n\nStandard Sort:\n\nNormalized\tspaces: 4\nNormalized\nspaces: 3\nNormalized spaces: 2\nNormalized spaces: 1\n\nNatural Sort:\n\nNormalized spaces: 1\nNormalized spaces: 2\nNormalized\nspaces: 3\nNormalized\tspaces: 4\n\n****************************************\n\nTask 3\nSort case independently.\n\nStandard Sort:\n\ncASE INDEPENDENT: 4\ncaSE INDEPENDENT: 3\ncasE INDEPENDENT: 2\ncase INDEPENDENT: 1\n\nNatural Sort:\n\ncase INDEPENDENT: 1\ncasE INDEPENDENT: 2\ncaSE INDEPENDENT: 3\ncASE INDEPENDENT: 4\n\n****************************************\n\nTask 4\nSort groups of digits in natural number order.\n\nStandard Sort:\n\n144th\n17th\n2\n201st\n32nd\n3rd\n95\nFoo100bar99baz0.txt\nfoo1000bar99baz10.txt\nfoo1000bar99baz9.txt\nfoo100bar10baz0.txt\n\nNatural Sort:\n\n2\n3rd\n17th\n32nd\n95\n144th\n201st\nfoo100bar10baz0.txt\nFoo100bar99baz0.txt\nfoo1000bar99baz9.txt\nfoo1000bar99baz10.txt\n\n****************************************\n\nTask 5 ( mixed with 1, 2, 3 & 4 )\nSort titles, normalize white space, collapse multiple spaces to\nsingle, trim leading white space, ignore common leading articles\nand sort digit groups in natural order.\n\nStandard Sort:\n\n  The 39 Steps               3\n The Wind and the Lion       7\n12 Monkeys                   2\nA Fish Called Wanda          5\nAny Which Way But Loose      4\nThe    7th Seal              1\nThe Wind\tin the Willows  8\nWanda                        6\n\nNatural Sort:\n\nThe    7th Seal              1\n12 Monkeys                   2\n  The 39 Steps               3\nAny Which Way But Loose      4\nA Fish Called Wanda          5\nWanda                        6\n The Wind and the Lion       7\nThe Wind\tin the Willows  8\n\n****************************************\n\nTask 6, 7, 8\nMap letters in Latin1 that have accents or decompose to two\ncharacters to their base characters for sorting.\n\nStandard Sort:\n\nBall\nCard\nabove\naether\napple\nautumn\naußen\nbald\ncar\ne-mail\nevoke\nnina\nniño\nÆon\nÉvian\næon\n\nNatural Sort:\n\nabove\nÆon\næon\naether\napple\naußen\nautumn\nbald\nBall\ncar\nCard\ne-mail\nÉvian\nevoke\nnina\nniño\n\n****************************************\n\n```"}]}
{"messages": [{"role": "user", "content": "File:Ship'sBell.jpg\n\nTask\n\nWrite a small program that emulates a nautical bell producing a ringing bell pattern at certain times throughout the day.\n\nThe bell timing should be in accordance with Greenwich Mean Time, unless locale dictates otherwise.\n\nIt is permissible for the program to daemonize, or to slave off a scheduler, and it is permissible to use alternative notification methods (such as producing a written notice \"Two Bells Gone\"), if these are more usual for the system type.\n\nRelated task\n\n* Sleep"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku uses UTC (GMT) time internally and by default. This will display the current UTC time and on the half hour, display a graphical representation of the bell. If run in a terminal with the system bell enabled, will also chime the system alarm bell.\n\n```\nmy @watch = <Middle Morning Forenoon Afternoon Dog First>;\nmy @ordinal = <One Two Three Four Five Six Seven Eight>;\n \nmy $thishour;\nmy $thisminute = '';\n \nloop {\n    my $utc = DateTime.new(time);\n    if $utc.minute ~~ any(0,30) and $utc.minute != $thisminute {\n        $thishour   = $utc.hour;\n        $thisminute = $utc.minute;\n        bell($thishour, $thisminute);\n    }\n    printf \"%s%02d:%02d:%02d\", \"\\r\", $utc.hour, $utc.minute, $utc.second;\n    sleep(1);\n}\n \nsub bell ($hour, $minute) {\n \n    my $bells = (($hour % 4) * 2 + $minute div 30) || 8;\n \n    printf \"%s%02d:%02d %9s watch, %6s Bell%s Gone: \\t\", \"\\b\" x 9, $hour, $minute,\n      @watch[($hour div 4 - !?($minute + $hour % 4) + 6) % 6],\n      @ordinal[$bells - 1], $bells == 1 ?? '' !! 's';\n \n    chime($bells);\n \n    sub chime ($count) {\n\tfor 1..$count div 2 {\n\t\tprint \"\\a♫ \";\n\t\tsleep .25;\n\t\tprint \"\\a\";\n\t\tsleep .75;\n\t}\n\tif $count % 2 {\n\t     print \"\\a♪\";\n\t     sleep 1;\n        }\n        print \"\\n\";\n    }\n}\n\n```\n\nOutput:\n\n```\n00:00     First watch,  Eight Bells Gone: \t♫ ♫ ♫ ♫ \n00:30    Middle watch,    One Bell Gone: \t♪\n01:00    Middle watch,    Two Bells Gone: \t♫ \n01:30    Middle watch,  Three Bells Gone: \t♫ ♪\n02:00    Middle watch,   Four Bells Gone: \t♫ ♫ \n02:30    Middle watch,   Five Bells Gone: \t♫ ♫ ♪\n03:00    Middle watch,    Six Bells Gone: \t♫ ♫ ♫ \n03:30    Middle watch,  Seven Bells Gone: \t♫ ♫ ♫ ♪\n04:00    Middle watch,  Eight Bells Gone: \t♫ ♫ ♫ ♫ \n04:30   Morning watch,    One Bell Gone: \t♪\n05:00   Morning watch,    Two Bells Gone: \t♫ \n05:30   Morning watch,  Three Bells Gone: \t♫ ♪\n06:00   Morning watch,   Four Bells Gone: \t♫ ♫ \n06:30   Morning watch,   Five Bells Gone: \t♫ ♫ ♪\n07:00   Morning watch,    Six Bells Gone: \t♫ ♫ ♫ \n07:30   Morning watch,  Seven Bells Gone: \t♫ ♫ ♫ ♪\n08:00   Morning watch,  Eight Bells Gone: \t♫ ♫ ♫ ♫ \n08:30  Forenoon watch,    One Bell Gone: \t♪\n09:00  Forenoon watch,    Two Bells Gone: \t♫ \n09:30  Forenoon watch,  Three Bells Gone: \t♫ ♪\n10:00  Forenoon watch,   Four Bells Gone: \t♫ ♫ \n10:30  Forenoon watch,   Five Bells Gone: \t♫ ♫ ♪\n11:00  Forenoon watch,    Six Bells Gone: \t♫ ♫ ♫ \n11:30  Forenoon watch,  Seven Bells Gone: \t♫ ♫ ♫ ♪\n12:00  Forenoon watch,  Eight Bells Gone: \t♫ ♫ ♫ ♫ \n12:30 Afternoon watch,    One Bell Gone: \t♪\n13:00 Afternoon watch,    Two Bells Gone: \t♫ \n13:30 Afternoon watch,  Three Bells Gone: \t♫ ♪\n14:00 Afternoon watch,   Four Bells Gone: \t♫ ♫ \n14:30 Afternoon watch,   Five Bells Gone: \t♫ ♫ ♪\n15:00 Afternoon watch,    Six Bells Gone: \t♫ ♫ ♫ \n15:30 Afternoon watch,  Seven Bells Gone: \t♫ ♫ ♫ ♪\n16:00 Afternoon watch,  Eight Bells Gone: \t♫ ♫ ♫ ♫ \n16:30       Dog watch,    One Bell Gone: \t♪\n17:00       Dog watch,    Two Bells Gone: \t♫ \n17:30       Dog watch,  Three Bells Gone: \t♫ ♪\n18:00       Dog watch,   Four Bells Gone: \t♫ ♫ \n18:30       Dog watch,   Five Bells Gone: \t♫ ♫ ♪\n19:00       Dog watch,    Six Bells Gone: \t♫ ♫ ♫ \n19:30       Dog watch,  Seven Bells Gone: \t♫ ♫ ♫ ♪\n20:00       Dog watch,  Eight Bells Gone: \t♫ ♫ ♫ ♫ \n20:30     First watch,    One Bell Gone: \t♪\n21:00     First watch,    Two Bells Gone: \t♫ \n21:30     First watch,  Three Bells Gone: \t♫ ♪\n22:00     First watch,   Four Bells Gone: \t♫ ♫ \n22:30     First watch,   Five Bells Gone: \t♫ ♫ ♪\n23:00     First watch,    Six Bells Gone: \t♫ ♫ ♫ \n23:30     First watch,  Seven Bells Gone: \t♫ ♫ ♫ ♪\n```"}]}
{"messages": [{"role": "user", "content": "Negative base numbers are an alternate way to encode numbers without the need for a minus sign. Various negative bases may be used including negadecimal (base -10), negabinary (-2) and negaternary (-3).[1][2]\n\nTask\n\n* Encode the decimal number 10 as negabinary (expect 11110)\n* Encode the decimal number 146 as negaternary (expect 21102)\n* Encode the decimal number 15 as negadecimal (expect 195)\n* In each of the above cases, convert the encoded number back to decimal.\n\nextra credit\n\n* supply an integer, that when encoded to base   -62   (or something \"higher\"),   expresses the   \n  name of the language being used   (with correct capitalization).   If the computer language has   \n  non-alphanumeric characters,   try to encode them into the negatory numerals,   or use other   \n  characters instead."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Explicit\n\n**Works with**: Rakudo version 2016.11\n\nRaku provides built-in methods / routines base and parse-base to convert to and from bases 2 through 36. We'll just shadow the core routines with versions that accept negative bases.\n\nAs a stretch goal, rather than implement something that can \"Spell the name of the language with correct capitalization\" (which is silly, trivial, and has absolutely ***nothing*** to do with negative base numbers,) we'll implement routines that correctly work with any Real number, not just integers.\n\nThe Real candidate has a 'precision' parameter, default -15, (15 places after the decimal point,) to limit the length of the fractional portion of the converted value. Change it if you need or want different precision. The Integer only routine is kept here as a multi-dispatch candidate since it is potentially much faster than the Real capable routine. The dispatcher will automatically use the most appropriate (fastest) routine.\n\nNote that the parse-base routine will handle 'illegal' negative negative-base values without blowing up.\n\n```\nmulti sub base ( Int $value is copy, Int $radix where -37 < * < -1) {\n    my $result;\n    while $value {\n        my $r = $value mod $radix;\n        $value div= $radix;\n        if $r < 0 {\n            $value++;\n            $r -= $radix\n        }\n        $result ~= $r.base(-$radix);\n    }\n    flip $result || ~0;\n}\n\nmulti sub base ( Real $num, Int $radix where -37 < * < -1, :$precision = -15 ) {\n    return '0' unless $num;\n    my $value  = $num;\n    my $result = '';\n    my $place  = 0;\n    my $upper-bound = 1 / (-$radix + 1);\n    my $lower-bound = $radix * $upper-bound;\n\n    $value = $num / $radix ** ++$place until $lower-bound <= $value < $upper-bound;\n\n    while ($value or $place > 0) and $place > $precision {\n        my $digit = ($radix * $value - $lower-bound).Int;\n        $value    =  $radix * $value - $digit;\n        $result ~= '.' unless $place or $result.contains: '.';\n        $result ~= $digit == -$radix ?? ($digit-1).base(-$radix)~'0' !! $digit.base(-$radix);\n        $place--\n    }\n    $result\n}\n\nmulti sub parse-base (Str $str, Int $radix where -37 < * < -1) {\n    return -1 * $str.substr(1).&parse-base($radix) if $str.substr(0,1) eq '-';\n    my ($whole, $frac) = $str.split: '.';\n    my $fraction = 0;\n    $fraction = [+] $frac.comb.kv.map: { $^v.parse-base(-$radix) * $radix ** -($^k+1) } if $frac;\n    $fraction + [+] $whole.flip.comb.kv.map: { $^v.parse-base(-$radix) * $radix ** $^k }\n}\n\n# TESTING\nfor <4 -4 0 -7  10 -2  146 -3  15 -10  -19 -10  107 -16\n    227.65625 -16  2.375 -4 -1.3e2 -8 41371457.268272761 -36> -> $v, $r {\n    my $nbase = $v.&base($r, :precision(-5));\n    printf \"%20s.&base\\(%3d\\) = %-11s : %13s.&parse-base\\(%3d\\) = %s\\n\",\n      $v, $r, $nbase, \"'$nbase'\", $r, $nbase.&parse-base($r);\n}\n\n# 'Illegal' negative-base value\nsay q|  '-21'.&parse-base(-10) = |, '-21'.&parse-base(-10);\n\n```\n\nOutput:\n\n```\n                   4.&base( -4) = 130         :         '130'.&parse-base( -4) = 4\n                   0.&base( -7) = 0           :           '0'.&parse-base( -7) = 0\n                  10.&base( -2) = 11110       :       '11110'.&parse-base( -2) = 10\n                 146.&base( -3) = 21102       :       '21102'.&parse-base( -3) = 146\n                  15.&base(-10) = 195         :         '195'.&parse-base(-10) = 15\n                 -19.&base(-10) = 21          :          '21'.&parse-base(-10) = -19\n                 107.&base(-16) = 1AB         :         '1AB'.&parse-base(-16) = 107\n           227.65625.&base(-16) = 124.68      :      '124.68'.&parse-base(-16) = 227.65625\n               2.375.&base( -4) = 3.32        :        '3.32'.&parse-base( -4) = 2.375\n              -1.3e2.&base( -8) = 1616        :        '1616'.&parse-base( -8) = -130\n  41371457.268272761.&base(-36) = PERL6.ROCKS : 'PERL6.ROCKS'.&parse-base(-36) = 41371457.268272761\n  '-21'.&parse-base(-10) = 19\n```\n\n### Module\n\n**Works with**: Rakudo version 2020.02\n\nUsing the module Base::Any from the Raku ecosystem.\n\nDoes everything the explicit version does but also handles a **much** larger range of negative bases.\n\nDoing pretty much the same tests as the explicit version.\n\n```\nuse Base::Any;\n\nfor < 4 -4 0 -7  10 -2  146 -3  15 -10  -19 -10  107 -16\n    227.65625 -16  2.375 -4 -1.3e2 -8 41371457.268272761 -36\n    -145115966751439403/3241792 -1184 > -> $v, $r {\n    my $nbase = $v.&to-base($r, :precision(-5));\n    printf \"%21s.&to-base\\(%5d\\) = %-11s : %13s.&from-base\\(%5d\\) = %s\\n\",\n      +$v, $r, $nbase, \"'$nbase'\", $r, $nbase.&from-base($r);\n}\n\n```\n\nOutput:\n\n```\n                    4.&to-base(   -4) = 130         :         '130'.&from-base(   -4) = 4\n                    0.&to-base(   -7) = 0           :           '0'.&from-base(   -7) = 0\n                   10.&to-base(   -2) = 11110       :       '11110'.&from-base(   -2) = 10\n                  146.&to-base(   -3) = 21102       :       '21102'.&from-base(   -3) = 146\n                   15.&to-base(  -10) = 195         :         '195'.&from-base(  -10) = 15\n                  -19.&to-base(  -10) = 21          :          '21'.&from-base(  -10) = -19\n                  107.&to-base(  -16) = 1AB         :         '1AB'.&from-base(  -16) = 107\n            227.65625.&to-base(  -16) = 124.68      :      '124.68'.&from-base(  -16) = 227.65625\n                2.375.&to-base(   -4) = 3.32        :        '3.32'.&from-base(   -4) = 2.375\n                 -130.&to-base(   -8) = 1616        :        '1616'.&from-base(   -8) = -130\n   41371457.268272761.&to-base(  -36) = PERL6.ROCKS : 'PERL6.ROCKS'.&from-base(  -36) = 41371457.268272761\n-44764120200.01264825.&to-base(-1184) = Raku.FTW    :    'Raku.FTW'.&from-base(-1184) = -44764120200.01264825\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show primes p such that p\\*q+2 is prime, where q is next prime after p and **p < 500**\n  \n  \nSee also:\n\n* Special neighbor primes"}, {"role": "assistant", "content": "```\nmy @primes = grep &is-prime, ^Inf;\nmy $last_p = @primes.first: :k, * >= 500;\nmy $last_q = $last_p + 1;\n\nmy @cousins = @primes.head( $last_q )\n                     .rotor( 2 => -1 )\n                     .map(-> (\\p, \\q) { p, q, p*q+2 } )\n                     .grep( *.[2].is-prime );\n\nsay .fmt('%6d') for @cousins;\n\n```\n\nOutput:\n\n```\n     3      5     17\n     5      7     37\n     7     11     79\n    13     17    223\n    19     23    439\n    67     71   4759\n   149    151  22501\n   179    181  32401\n   229    233  53359\n   239    241  57601\n   241    251  60493\n   269    271  72901\n   277    281  77839\n   307    311  95479\n   313    317  99223\n   397    401 159199\n   401    409 164011\n   419    421 176401\n   439    443 194479\n   487    491 239119\n\n```"}]}
{"messages": [{"role": "user", "content": "In many languages, functions can be nested, resulting in outer functions and inner functions. The inner function can access variables from the outer function. In most languages, the inner function can also modify variables in the outer function.\n\nTask\n\nWrite a program consisting of two nested functions that prints the following text.\n\n```\n1. first\n2. second\n3. third\n\n```\n\nThe outer function (called MakeList or equivalent) is responsible for creating the list as a whole and is given the separator \". \" as argument. It also defines a counter variable to keep track of the item number. This demonstrates how the inner function can influence the variables in the outer function.\n\nThe inner function (called MakeItem or equivalent) is responsible for creating a list item. It accesses the separator from the outer function and modifies the counter.\n\nReferences\n:   * Nested function"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub make-List ($separator = ') '){\n    my $count = 1;\n\n    sub make-Item ($item) { \"{$count++}$separator$item\" }\n\n    join \"\\n\", <first second third>».&make-Item;\n}\n\nput make-List('. ');\n\n```\n\nOutput:\n\n```\n1. first\n2. second\n3. third\n```"}]}
{"messages": [{"role": "user", "content": "A template for data is an arbitrarily nested tree of integer indices.\n\nData payloads are given as a separate mapping, array or other simpler, flat,\nassociation of indices to individual items of data, and are strings.  \nThe idea is to create a data structure with the templates' nesting, and the\npayload corresponding to each index appearing at the position of each index.\n\nAnswers using simple string replacement or regexp are to be avoided. The idea is\nto use the native, or usual implementation of lists/tuples etc of the language\nand to hierarchically traverse the template to generate the output.\n\nTask Detail\n\nGiven the following input template `t` and list of payloads `p`:\n\n```\n# Square brackets are used here to denote nesting but may be changed for other,\n# clear, visual representations of nested data appropriate to ones programming \n# language.\nt = [\n    [[1, 2],\n     [3, 4, 1], \n     5]]\n\np = 'Payload#0' ... 'Payload#6'\n\n```\n\nThe correct output should have the following structure, (although spacing and\nlinefeeds may differ, the nesting and order should follow):\n\n```\n[[['Payload#1', 'Payload#2'],\n  ['Payload#3', 'Payload#4', 'Payload#1'],\n  'Payload#5']]\n\n```\n\n1. Generate the output for the above template, `t`.\n\nOptional Extended tasks\n\n2. Show which payloads remain unused.  \n3. Give some indication/handling of indices without a payload.\n\n*Show output on this page.*"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\nExplicitly not using strings, using one data structure to fill in another. Since it *isn't* a string, the output format removes the newlines from the template; line feed (white space in general) isn't particularly significant in Raku data structures. It does preserve the nesting though. In the second example, payload \"buckets\" that don't exist result in an undefined value being inserted; by default: Any.\n\n```\nsay join \"\\n  \", '##PAYLOADS:', |my @payloads = 'Payload#' X~ ^7;\n\nfor [\n     (((1, 2),\n       (3, 4, 1),\n       5),),\n\n     (((1, 2),\n       (10, 4, 1),\n       5),)\n    ] {\n    say \"\\n      Template: \", $_.raku;\n    say \"Data structure: { @payloads[|$_].raku }\";\n}\n\n```\n\nOutput:\n\n```\n##PAYLOADS:\n  Payload#0\n  Payload#1\n  Payload#2\n  Payload#3\n  Payload#4\n  Payload#5\n  Payload#6\n\n      Template: $(((1, 2), (3, 4, 1), 5),)\nData structure: (((\"Payload#1\", \"Payload#2\"), (\"Payload#3\", \"Payload#4\", \"Payload#1\"), \"Payload#5\"),)\n\n      Template: $(((1, 2), (10, 4, 1), 5),)\nData structure: (((\"Payload#1\", \"Payload#2\"), (Any, \"Payload#4\", \"Payload#1\"), \"Payload#5\"),)\n```"}]}
{"messages": [{"role": "user", "content": "Given a zero or positive integer, the task is to generate the next largest integer with the same digits\\*1.\n\n* Numbers will not be padded to the left with zeroes.\n* Use all given digits, with their given multiplicity. (If a digit appears twice in the input number, it should appear twice in the result).\n* If there is no next highest integer return zero.\n\n:   \\*1   Alternatively phrased as:   \"Find the smallest integer larger than the (positive or zero) integer   **N**\n\n    :   which can be obtained by reordering the (base ten) digits of   **N**\".\n\nAlgorithm 1\n\n1. Generate all the permutations of the digits and sort into numeric order.\n2. Find the number in the list.\n3. Return the next highest number from the list.\n\nThe above could prove slow and memory hungry for numbers with large numbers of\ndigits, but should be easy to reason about its correctness.\n\nAlgorithm 2\n\n1. Scan right-to-left through the digits of the number until you find a digit with a larger digit somewhere to the right of it.\n2. Exchange that digit with the smallest digit on the right that is greater than it.\n3. Order the digits to the right of this position, after the swap; lowest-to-highest, left-to-right. (that is, so they form the lowest numerical representation)\n\n**E.g.:**\n\n```\n    n = 12453\n<scan>\n    12_4_53\n<swap>\n    12_5_43\n<order-right>\n    12_5_34\n\n    return: 12534\n\n```\n\nThis second algorithm is faster and more memory efficient, but implementations\nmay be harder to test.\n\nOne method of testing, (as used in developing the task),   is to compare results from both\nalgorithms for random numbers generated from a range that the first algorithm can handle.\n\nTask requirements\n\nCalculate the next highest integer from the digits of the following numbers:\n\n:   * 0\n    * 9\n    * 12\n    * 21\n    * 12453\n    * 738440\n    * 45072010\n    * 95322020\n\nOptional stretch goal\n:   * 9589776899767587796600"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.01\n\nMinimal error trapping. Assumes that the passed number is an integer. Handles positive or negative integers, always returns next largest regardless (if possible).\n\n```\nuse Lingua::EN::Numbers;\n\nsub next-greatest-index ($str, &op = &infix:«<» ) {\n    my @i = $str.comb;\n    (1..^@i).first: { &op(@i[$_ - 1], @i[$_]) }, :end, :k;\n}\n\nmulti next-greatest-integer (Int $num where * >= 0) {\n    return 0 if $num.chars < 2;\n    return $num.flip > $num ?? $num.flip !! 0 if $num.chars == 2;\n    return 0 unless my $i = next-greatest-index( $num ) // 0;\n    my $digit = $num.substr($i, 1);\n    my @rest  = (flat $num.substr($i).comb).sort(+*);\n    my $next  = @rest.first: * > $digit, :k;\n    $digit    = @rest.splice($next,1);\n    join '', flat $num.substr(0,$i), $digit, @rest;\n}\n\nmulti next-greatest-integer (Int $num where * < 0) {\n    return 0 if $num.chars < 3;\n    return $num.abs.flip < -$num ?? -$num.abs.flip !! 0 if $num.chars == 3;\n    return 0 unless my $i = next-greatest-index( $num, &CORE::infix:«>» ) // 0;\n    my $digit = $num.substr($i, 1);\n    my @rest  = (flat $num.substr($i).comb).sort(-*);\n    my $next  = @rest.first: * < $digit, :k;\n    $digit    = @rest.splice($next,1);\n    join '', flat $num.substr(0,$i), $digit, @rest;\n}\n\nsay \"Next largest integer able to be made from these digits, or zero if no larger exists:\";\nprintf \"%30s  -> %s%s\\n\", .&comma, .&next-greatest-integer < 0 ?? '' !! ' ', .&next-greatest-integer.&comma for\n    flat 0, (9, 12, 21, 12453, 738440, 45072010, 95322020, 9589776899767587796600, 3345333,\n    95897768997675877966000000000000000000000000000000000000000000000000000000000000000000).map: { $_, -$_ };\n\n```\n\nOutput:\n\n```\nNext largest integer able to be made from these digits, or zero if no larger exists:\n                             0  ->  0\n                             9  ->  0\n                            -9  ->  0\n                            12  ->  21\n                           -12  ->  0\n                            21  ->  0\n                           -21  -> -12\n                        12,453  ->  12,534\n                       -12,453  -> -12,435\n                       738,440  ->  740,348\n                      -738,440  -> -738,404\n                    45,072,010  ->  45,072,100\n                   -45,072,010  -> -45,072,001\n                    95,322,020  ->  95,322,200\n                   -95,322,020  -> -95,322,002\n 9,589,776,899,767,587,796,600  ->  9,589,776,899,767,587,900,667\n-9,589,776,899,767,587,796,600  -> -9,589,776,899,767,587,796,060\n                     3,345,333  ->  3,353,334\n                    -3,345,333  -> -3,343,533\n95,897,768,997,675,877,966,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000  ->  95,897,768,997,675,879,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,667\n-95,897,768,997,675,877,966,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000  -> -95,897,768,997,675,877,960,600,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n**n**   is smallest prime such that the difference of successive terms is strictly increasing,\nwhere     **n**   <   **1050**."}, {"role": "assistant", "content": "```\nsub is-special ( ($previous, $gap) ) {\n    state @primes = grep *.is-prime, 2..*;\n    shift @primes while @primes[0] <= $previous + $gap;\n    return ( @primes[0], @primes[0] - $previous );\n}\n\nmy @specials = (2, 0), &is-special … *;\n\nmy $limit = @specials.first: :k, *.[0] > 1050;\n\nsay .fmt('%4d') for @specials.head($limit);\n\n```\n\nOutput:\n\n```\n   2    0\n   3    1\n   5    2\n  11    6\n  19    8\n  29   10\n  41   12\n  59   18\n  79   20\n 101   22\n 127   26\n 157   30\n 191   34\n 227   36\n 269   42\n 313   44\n 359   46\n 409   50\n 461   52\n 521   60\n 587   66\n 659   72\n 733   74\n 809   76\n 887   78\n 967   80\n1049   82\n```"}]}
{"messages": [{"role": "user", "content": "Task\n:   :   1. Take an positive integer   **n**\n        2. **sumn**   is the sum of the decimal digits of   **n**\n        3. If  **sumn'**s  length is greater than   **1**   (unity),   repeat step 2 for   **n = sumn**\n        4. Stop when  **sumn'**s  length is equal to   **1**   (unity)\n\nIf   **n**   and   **sumn**   are prime,   then   **n**   is a   **Nice prime**\n\nLet     **500   <   n   <   1000**\n\nExample\n\n```\n       853 (prime)\n       8 + 5 + 3 = 16\n       1 + 6 = 7 (prime)\n\n```\n\nAlso see\n:   :   * The OEIS article:   A78403 Primes such that digital root is prime."}, {"role": "assistant", "content": "```\nsub digroot ($r) { .tail given $r, { [+] .comb } ... { .chars == 1 } }\nmy @is-nice = lazy (0..*).map: { .&is-prime && .&digroot.&is-prime ?? $_ !! False };\nsay @is-nice[500 ^..^ 1000].grep(*.so).batch(11)».fmt(\"%4d\").join: \"\\n\";\n\n```\n\nOutput:\n\n```\n 509  547  563  569  587  599  601  617  619  641  653\n 659  673  677  691  709  727  743  761  797  821  839\n 853  857  887  907  911  929  941  947  977  983  997\n```\n\nAlternately, with somewhat better separation of concerns.\n\n```\nsub digroot ($r) { ($r, { .comb.sum } … { .chars == 1 }).tail }\nsub is-nice ($_) { .is-prime && .&digroot.is-prime }\nsay (500 ^..^ 1000).grep( *.&is-nice ).batch(11)».fmt(\"%4d\").join: \"\\n\";\n\n```\n\nSame output."}]}
{"messages": [{"role": "user", "content": "Nim is a simple game where the second player─if they know the trick─will always win.\n\nThe game has only 3 rules:\n\n:   :   * start with   **12**   tokens\n        * each player takes   **1,  2,  or  3**   tokens in turn\n        * the player who takes the last token wins.\n\nTo win every time,   the second player simply takes 4 minus the number the first player took.   So if the first player takes 1,   the second takes 3; if the first player takes 2,   the second should take 2; and if the first player takes 3,   the second player will take 1.\n\nTask\n\nDesign a simple Nim game where the human player goes first, and the computer always wins. The game should enforce the rules."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\n```\nsay my $tokens = 12, \" tokens remaining.\\n\";\n\nloop {\n    my $player = trim prompt \"How many tokens do you want to remove; 1, 2 or 3? : \";\n    say \"Nice try. $tokens tokens remaining.\\n\" and\n    next unless $player eq any <1 2 3>;\n    $tokens -= 4;\n    say \"Computer takes {4 - $player}.\\n$tokens tokens remaining.\\n\";\n    say \"Computer wins.\" and last if $tokens <= 0;\n}\n\n```\n\nSample output:\n\n```\n12 tokens remaining.\n\nHow many tokens do you want to remove; 1, 2 or 3? : 3\nComputer takes 1.\n8 tokens remaining.\n\nHow many tokens do you want to remove; 1, 2 or 3? : 6\nNice try. 8 tokens remaining.\n\nHow many tokens do you want to remove; 1, 2 or 3? : G\nNice try. 8 tokens remaining.\n\nHow many tokens do you want to remove; 1, 2 or 3? : 2\nComputer takes 2.\n4 tokens remaining.\n\nHow many tokens do you want to remove; 1, 2 or 3? : 1\nComputer takes 3.\n0 tokens remaining.\n\nComputer wins.\n```"}]}
{"messages": [{"role": "user", "content": "The **nimbers**, also known as **Grundy** numbers, are the values of the heaps in the game of Nim. They have **addition** and **multiplication** operations, unrelated to the addition and multiplication of the integers. Both operations are defined recursively:\n\nThe **nim-sum** of two integers m and n, denoted m⊕n is given by\n\nm⊕n=mex(m'⊕n, m⊕ n' : m'<m, n'<n),\n\nwhere the mex function returns the smallest integer *not* in the set. More simply: collect all the nim-sums of *m* and numbers smaller than *n*, and all nim-sums of *n* with all numbers less than *m* and find the smallest number not in that set. Fortunately, this also turns out to be equal to the bitwise xor of the two.\n\nThe **nim-product** is also defined recursively:\n\nm⊗n=mex([m'⊗n]⊕[m⊗n']⊕[m'⊗n'] : m'<m, n'<n)\n\nThe product is more complicated and time-consuming to evaluate, but there are a few facts which may help:\n\n* The operators ⊕ and ⊗ are commutative and distributive\n* the nim-product of a Fermat power (22k) and a smaller number is their ordinary product\n* the nim-square of a Fermat power x is the ordinary product 3x/2\n\nTasks\n\n1. Create nimber addition and multiplication tables up to at least 15\n2. Find the nim-sum and nim-product of two five digit integers of your choice"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.05\n\n**Translation of**: FreeBasic\n\n(or at least, heavily inspired by FreeBasic)\n\nNot limited by integer size. Doesn't rely on twos complement bitwise and.\n\n```\nsub infix:<⊕> (Int $x, Int $y) { $x +^ $y }\n\nsub infix:<⊗> (Int $x, Int $y) {\n    return $x × $y if so $x|$y < 2;\n    my $h = exp $x.lsb, 2;\n    return ($h ⊗ $y) ⊕ (($x ⊕ $h) ⊗ $y) if $x > $h;\n    return ($y ⊗ $x) if $y.lsb < $y.msb;\n    return $x × $y unless my $comp = $x.lsb +& $y.lsb;\n    $h = exp $comp.lsb, 2;\n    (($x +> $h) ⊗ ($y +> $h)) ⊗ (3 +< ($h - 1))\n}\n\n# TESTING\n\nmy $upto = 26;\n\nfor <⊕>, &infix:<⊕>,\n    <⊗>, &infix:<⊗>\n  -> $op, &f {\n\n    put \" $op │\", ^$upto .fmt('%3s'), \"\\n───┼\", '────' x $upto;\n    -> $r { put $r.fmt('%2s'), ' │', ^$upto .map: { &f($r, $_).fmt('%3s')} } for ^$upto;\n    put \"\\n\";\n}\n\nput \"21508 ⊕ 42689 = \", 21508 ⊕ 42689;\nput \"21508 ⊗ 42689 = \", 21508 ⊗ 42689;\n\nput \"2150821508215082150821508 ⊕ 4268942689426894268942689 = \", 2150821508215082150821508 ⊕ 4268942689426894268942689;\nput \"2150821508215082150821508 ⊗ 4268942689426894268942689 = \", 2150821508215082150821508 ⊗ 4268942689426894268942689;\n\n```\n\nOutput:\n\n```\n ⊕ │  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25\n───┼────────────────────────────────────────────────────────────────────────────────────────────────────────\n 0 │  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25\n 1 │  1   0   3   2   5   4   7   6   9   8  11  10  13  12  15  14  17  16  19  18  21  20  23  22  25  24\n 2 │  2   3   0   1   6   7   4   5  10  11   8   9  14  15  12  13  18  19  16  17  22  23  20  21  26  27\n 3 │  3   2   1   0   7   6   5   4  11  10   9   8  15  14  13  12  19  18  17  16  23  22  21  20  27  26\n 4 │  4   5   6   7   0   1   2   3  12  13  14  15   8   9  10  11  20  21  22  23  16  17  18  19  28  29\n 5 │  5   4   7   6   1   0   3   2  13  12  15  14   9   8  11  10  21  20  23  22  17  16  19  18  29  28\n 6 │  6   7   4   5   2   3   0   1  14  15  12  13  10  11   8   9  22  23  20  21  18  19  16  17  30  31\n 7 │  7   6   5   4   3   2   1   0  15  14  13  12  11  10   9   8  23  22  21  20  19  18  17  16  31  30\n 8 │  8   9  10  11  12  13  14  15   0   1   2   3   4   5   6   7  24  25  26  27  28  29  30  31  16  17\n 9 │  9   8  11  10  13  12  15  14   1   0   3   2   5   4   7   6  25  24  27  26  29  28  31  30  17  16\n10 │ 10  11   8   9  14  15  12  13   2   3   0   1   6   7   4   5  26  27  24  25  30  31  28  29  18  19\n11 │ 11  10   9   8  15  14  13  12   3   2   1   0   7   6   5   4  27  26  25  24  31  30  29  28  19  18\n12 │ 12  13  14  15   8   9  10  11   4   5   6   7   0   1   2   3  28  29  30  31  24  25  26  27  20  21\n13 │ 13  12  15  14   9   8  11  10   5   4   7   6   1   0   3   2  29  28  31  30  25  24  27  26  21  20\n14 │ 14  15  12  13  10  11   8   9   6   7   4   5   2   3   0   1  30  31  28  29  26  27  24  25  22  23\n15 │ 15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  31  30  29  28  27  26  25  24  23  22\n16 │ 16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31   0   1   2   3   4   5   6   7   8   9\n17 │ 17  16  19  18  21  20  23  22  25  24  27  26  29  28  31  30   1   0   3   2   5   4   7   6   9   8\n18 │ 18  19  16  17  22  23  20  21  26  27  24  25  30  31  28  29   2   3   0   1   6   7   4   5  10  11\n19 │ 19  18  17  16  23  22  21  20  27  26  25  24  31  30  29  28   3   2   1   0   7   6   5   4  11  10\n20 │ 20  21  22  23  16  17  18  19  28  29  30  31  24  25  26  27   4   5   6   7   0   1   2   3  12  13\n21 │ 21  20  23  22  17  16  19  18  29  28  31  30  25  24  27  26   5   4   7   6   1   0   3   2  13  12\n22 │ 22  23  20  21  18  19  16  17  30  31  28  29  26  27  24  25   6   7   4   5   2   3   0   1  14  15\n23 │ 23  22  21  20  19  18  17  16  31  30  29  28  27  26  25  24   7   6   5   4   3   2   1   0  15  14\n24 │ 24  25  26  27  28  29  30  31  16  17  18  19  20  21  22  23   8   9  10  11  12  13  14  15   0   1\n25 │ 25  24  27  26  29  28  31  30  17  16  19  18  21  20  23  22   9   8  11  10  13  12  15  14   1   0\n\n\n ⊗ │  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25\n───┼────────────────────────────────────────────────────────────────────────────────────────────────────────\n 0 │  0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0\n 1 │  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25\n 2 │  0   2   3   1   8  10  11   9  12  14  15  13   4   6   7   5  32  34  35  33  40  42  43  41  44  46\n 3 │  0   3   1   2  12  15  13  14   4   7   5   6   8  11   9  10  48  51  49  50  60  63  61  62  52  55\n 4 │  0   4   8  12   6   2  14  10  11  15   3   7  13   9   5   1  64  68  72  76  70  66  78  74  75  79\n 5 │  0   5  10  15   2   7   8  13   3   6   9  12   1   4  11  14  80  85  90  95  82  87  88  93  83  86\n 6 │  0   6  11  13  14   8   5   3   7   1  12  10   9  15   2   4  96 102 107 109 110 104 101  99 103  97\n 7 │  0   7   9  14  10  13   3   4  15   8   6   1   5   2  12  11 112 119 121 126 122 125 115 116 127 120\n 8 │  0   8  12   4  11   3   7  15  13   5   1   9   6  14  10   2 128 136 140 132 139 131 135 143 141 133\n 9 │  0   9  14   7  15   6   1   8   5  12  11   2  10   3   4  13 144 153 158 151 159 150 145 152 149 156\n10 │  0  10  15   5   3   9  12   6   1  11  14   4   2   8  13   7 160 170 175 165 163 169 172 166 161 171\n11 │  0  11  13   6   7  12  10   1   9   2   4  15  14   5   3   8 176 187 189 182 183 188 186 177 185 178\n12 │  0  12   4   8  13   1   9   5   6  10   2  14  11   7  15   3 192 204 196 200 205 193 201 197 198 202\n13 │  0  13   6  11   9   4  15   2  14   3   8   5   7  10   1  12 208 221 214 219 217 212 223 210 222 211\n14 │  0  14   7   9   5  11   2  12  10   4  13   3  15   1   8   6 224 238 231 233 229 235 226 236 234 228\n15 │  0  15   5  10   1  14   4  11   2  13   7   8   3  12   6   9 240 255 245 250 241 254 244 251 242 253\n16 │  0  16  32  48  64  80  96 112 128 144 160 176 192 208 224 240  24   8  56  40  88  72 120 104 152 136\n17 │  0  17  34  51  68  85 102 119 136 153 170 187 204 221 238 255   8  25  42  59  76  93 110 127 128 145\n18 │  0  18  35  49  72  90 107 121 140 158 175 189 196 214 231 245  56  42  27   9 112  98  83  65 180 166\n19 │  0  19  33  50  76  95 109 126 132 151 165 182 200 219 233 250  40  59   9  26 100 119  69  86 172 191\n20 │  0  20  40  60  70  82 110 122 139 159 163 183 205 217 229 241  88  76 112 100  30  10  54  34 211 199\n21 │  0  21  42  63  66  87 104 125 131 150 169 188 193 212 235 254  72  93  98 119  10  31  32  53 203 222\n22 │  0  22  43  61  78  88 101 115 135 145 172 186 201 223 226 244 120 110  83  69  54  32  29  11 255 233\n23 │  0  23  41  62  74  93  99 116 143 152 166 177 197 210 236 251 104 127  65  86  34  53  11  28 231 240\n24 │  0  24  44  52  75  83 103 127 141 149 161 185 198 222 234 242 152 128 180 172 211 203 255 231  21  13\n25 │  0  25  46  55  79  86  97 120 133 156 171 178 202 211 228 253 136 145 166 191 199 222 233 240  13  20\n\n\n21508 ⊕ 42689 = 62149\n21508 ⊗ 42689 = 35202\n2150821508215082150821508 ⊕ 4268942689426894268942689 = 2722732241575131661744101\n2150821508215082150821508 ⊗ 4268942689426894268942689 = 221974472829844568827862736061997038065\n```"}]}
{"messages": [{"role": "user", "content": "Suppose you have a sequence of integers, starting with 1. Each integer that gets added to the sequence must be lexicographically later, and must have the property that when added, there is no subsequence that will sum to a prime number.\n\nNote\n\nfor the purposes of this task, \"lexicographically later\" means \"greater than\" - see the Mathematical discussion of ordering link below.\n\nE.G.\n\n```\n   Sequence starts with: (1)\n   testing integers...\n   1  - is not lexicographically later\n   2  - 2 + 1 is 3, a prime\n   3  - is prime ( a sum can be of a single element )\n   4  - 4 + 1 is 5, a prime\n   5  - is prime\n   6  - 6 + 1 is 7, a prime\n   7  - is prime \n   8  - 8 is later than 1, is not prime and 8 + 1 is not prime, so 8 is added to the sequence\n   and so on...\n\n```\n\nThere are variations of this sequence that have some further constraints.\n\n* Same premise except that each added integer must also be odd.\n* Same premise except that each added integer must also be even.\n\nTask\n\nFind the first **eight** elements of each variation, starting with **1**, where each added element is:\n\n* Lexicographically later, and yields no non-prime subsequence sum.\n* Lexicographically later, yields no non-prime subsequence sum, and is odd.\n* Lexicographically later, yields no non-prime subsequence sum, and is even.\n\nStretch\n\nThe numbers grow quite large very quickly. Find the first **ten** elements of each sequence, with an approximate elapsed time.\n\nSee also\n\n* OEIS A052349 - Lexicographically earliest sequence of distinct positive integers such that no subsequence sums to a prime * OEIS A128687 - Smallest odd nonprime such that every subset sums to a nonprime * OEIS A128688 - a(1)=1. For n>1, a(n) is the smallest even number such that every subset sums to a nonprime * Mathematical discussion of Ordering"}, {"role": "assistant", "content": "This version is multi-threaded to take advantage of multicore processors. When run on a Ryzen 5950 16 core processor, it takes a little under 1 second total to produce the first 8 elements of all three sequences. Stepping up to 10 elements of each takes just over 31 minutes total. :-( The timing will scale inversely with the number of cores available.\n\nAttempt This Online! (8 elements only)\n\n```\nsay \"Sequence, starting with 1, then:\";\n\nfor '', (*), 'odd ', (* % 2), 'even ', (* %% 2) -> $label, $filter {\n    my @check = 0, 1;\n    my @seq = 1, |lazy gather loop {\n        state $last = 1;\n        take $last = ($last^..Inf).grep($filter).hyper.grep({ none (@check.grep({.defined}) »+» $_)».is-prime })[0];\n        @check.append: @check »+» $last;\n    }\n\n    say \"\\nlexicographically  earliest {$label}integer such that no subsequence sums to a prime:\\n\", \n    @seq[^10];\n}\n\n```\n\nOutput:\n\n```\nSequence, starting with 1, then:\n\nlexicographically earliest integer such that no subsequence sums to a prime:\n(1 8 24 25 86 1260 1890 14136 197400 10467660)\n\nlexicographically earliest odd integer such that no subsequence sums to a prime:\n(1 9 15 39 105 731 2805 59535 2658795 78060135)\n\nlexicographically earliest even integer such that no subsequence sums to a prime:\n(1 8 24 86 90 780 5940 52350 278460 40768260)\n```"}]}
{"messages": [{"role": "user", "content": "Consider some sequence of elements. (It differs from a mere set of elements by having an ordering among members.)\n\nA *subsequence* contains some subset of the elements of this sequence, in the same order.\n\nA *continuous* subsequence is one in which no elements are missing between the first and last elements of the subsequence.\n\nNote: Subsequences are defined *structurally*, not by their contents.\nSo a sequence *a,b,c,d* will always have the same subsequences and continuous subsequences, no matter which values are substituted; it may even be the same value.\n\n**Task**: Find all non-continuous subsequences for a given sequence.\n\nExample\n\nFor the sequence   *1,2,3,4*,   there are five non-continuous subsequences, namely:\n\n:   :   :   :   * *1,3*\n                * *1,4*\n                * *2,4*\n                * *1,3,4*\n                * *1,2,4*\n\nGoal\n\nThere are different ways to calculate those subsequences.\n\nDemonstrate algorithm(s) that are natural for the language.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-24\n\n```\nsub non_continuous_subsequences ( *@list ) {\n    @list.combinations.grep: { 1 != all( .[ 0 ^.. .end] Z- .[0 ..^ .end] ) }\n}\n\nsay non_continuous_subsequences( 1..3 )».gist;\nsay non_continuous_subsequences( 1..4 )».gist;\nsay non_continuous_subsequences(   ^4 ).map: {[<a b c d>[.list]].gist};\n\n```\n\nOutput:\n\n```\n((1 3))\n((1 3) (1 4) (2 4) (1 2 4) (1 3 4))\n([a c] [a d] [b d] [a b d] [a c d])\n```"}]}
{"messages": [{"role": "user", "content": "Number base conversion is when you express a stored integer in an integer base, such as in octal (base 8) or binary (base 2). It also is involved when you take a string representing a number in a given base and convert it to the stored integer form. Normally, a stored integer is in binary, but that's typically invisible to the user, who normally enters or sees stored integers as decimal.\n\nTask\n\nWrite a function (or identify the built-in function) which is passed a non-negative integer to convert, and another integer representing the base.\n\nIt should return a string containing the digits of the resulting number, without leading zeros except for the number   **0**   itself.\n\nFor the digits beyond 9, one should use the lowercase English alphabet, where the digit   **a** = 9+1,   **b** = a+1,   etc.\n\nFor example:   the decimal number   **26**   expressed in base   **16**   would be   **1a**.\n\nWrite a second function which is passed a string and an integer base, and it returns an integer representing that string interpreted in that base.\n\nThe programs may be limited by the word size or other such constraint of a given language. There is no need to do error checking for negatives, bases less than 2, or inappropriate digits."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub from-base(Str $str, Int $base) {\n    +\":$base\\<$str>\";\n}\n\nsub to-base(Real $num, Int $base) {\n    $num.base($base);\n}\n\n```\n\nThese work on any real type including integer types. There is also a build in method/function for Strings: parse-base."}]}
{"messages": [{"role": "user", "content": "It is common to have a string containing a number written in some format, with the most common ones being decimal, hexadecimal, octal and binary. Such strings are found in many places (user interfaces, configuration files, XML data, network protocols, etc.)\n\nThis task requires parsing of such a string (which may be assumed to contain nothing else) using the language's built-in facilities if possible. Parsing of decimal strings is required, parsing of other formats is optional but should be shown (i.e., if the language can parse in base-19 then that should be illustrated).\n\nThe solutions may assume that the base of the number in the string is known. In particular, if your language has a facility to guess the base of a number by looking at a prefix (e.g. \"0x\" for hexadecimal) or other distinguishing syntax as it parses it, please show that.\n\nThe reverse operation is in task Non-decimal radices/Output\n\nFor general number base conversion, see Non-decimal radices/Convert."}, {"role": "assistant", "content": "(formerly Perl 6)\nBy default, all strings of digits are parsed as base 10 numbers, including those with a leading zero. Numbers with a prefix 0b, 0o, 0d or 0x are parsed as binary, octal, decimal or hexadecimal respectively.\n\n```\nsay 0b11011;  # -> 27\nsay 0o11011;  # -> 4617\nsay 0d11011;  # -> 11011\nsay 0x11011;  # -> 69649\n\n```\n\nAdditionally, there are built-in adverbial prefix operators to parse strings of \"digits\" of radix 2 through radix 36 into decimal. They will fail with a runtime error if they are fed a digit that is not valid in that radix.\n\n```\nmy $n = '11011';\n\nsay  :2($n); # -> 27\nsay  :3($n); # -> 112\nsay  :4($n); # -> 325\nsay  :5($n); # -> 756\nsay  :6($n); # -> 1519\nsay  :7($n); # -> 2752\nsay  :8($n); # -> 4617\nsay  :9($n); # -> 7300\nsay :10($n); # -> 11011\nsay :11($n); # -> 15984\nsay :12($n); # -> 22477\nsay :13($n); # -> 30772\nsay :14($n); # -> 41175\nsay :15($n); # -> 54016\nsay :16($n); # -> 69649\nsay :17($n); # -> 88452\nsay :18($n); # -> 110827\nsay :19($n); # -> 137200\nsay :20($n); # -> 168021\nsay :21($n); # -> 203764\nsay :22($n); # -> 244927\nsay :23($n); # -> 292032\nsay :24($n); # -> 345625\nsay :25($n); # -> 406276\nsay :26($n); # -> 474579\nsay :27($n); # -> 551152\nsay :28($n); # -> 636637\nsay :29($n); # -> 731700\nsay :30($n); # -> 837031\nsay :31($n); # -> 953344\nsay :32($n); # -> 1081377\nsay :33($n); # -> 1221892\nsay :34($n); # -> 1375675\nsay :35($n); # -> 1543536\nsay :36($n); # -> 1726309\n\n```"}]}
{"messages": [{"role": "user", "content": "Programming languages often have built-in routines to convert a non-negative integer for printing in different number bases. Such common number bases might include binary, Octal and Hexadecimal.\n\nTask\n\nPrint a small range of integers in some different bases, as supported by standard routines of your programming language.\n\nNote\n\nThis is distinct from Number base conversion as a user-defined conversion function is **not** asked for.)\n\nThe reverse operation is Common number base parsing."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nCalling the `.base` method on a number returns a string. It can handle all bases between 2 and 36:\n\n```\nsay 30.base(2);   # \"11110\"\nsay 30.base(8);   # \"36\"\nsay 30.base(10);  # \"30\"\nsay 30.base(16);  # \"1E\"\nsay 30.base(30);  # \"10\"\n\n```\n\nAlternatively, `printf` can be used for some common number bases:\n\n```\nfor 0..33 -> $n {\n  printf \" %6b %3o %2d %2X\\n\", $n xx 4;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Let our dice select numbers on their faces with equal probability, i.e. fair dice.\nDice may have more or less than six faces. (The possibility of there being a\n3D physical shape that has that many \"faces\" that allow them to be fair dice,\nis ignored for this task - a die with 3 or 33 defined sides is defined by the\nnumber of faces and the numbers on each face).\n\nThrowing dice will randomly select a face on each die with equal probability.\nTo show which die of dice thrown multiple times is more likely to win over the\nothers:\n\n1. calculate all possible combinations of different faces from each die\n2. Count how many times each die wins a combination\n3. Each *combination* is equally likely so the die with more winning face combinations is statistically more likely to win against the other dice.\n\n**If two dice X and Y are thrown against each other then X likely to: win, lose, or break-even against Y can be shown as: `X > Y, X < Y, or X = Y` respectively.**\n\nExample 1\n\nIf X is the three sided die with 1, 3, 6 on its faces and Y has 2, 3, 4 on its\nfaces then the equal possibility outcomes from throwing both, and the winners\nis:\n\n```\n   X   Y   Winner\n   =   =   ======\n   1   2   Y\n   1   3   Y\n   1   4   Y\n   3   2   X\n   3   3   -\n   3   4   Y\n   6   2   X\n   6   3   X\n   6   4   X\n   \n   TOTAL WINS: X=4, Y=4\n\n```\n\nBoth die will have the same statistical probability of winning, i.e.their comparison can be written as `X = Y`\n\nTransitivity\n\nIn mathematics transitivity are rules like:\n\n```\n   if a op b and b op c then a op c\n\n```\n\nIf, for example, the op, (for operator), is the familiar less than, <, and it's applied to integers\nwe get the familiar `if a < b and b < c then a < c`\n\nNon-transitive dice\n\nThese are an ordered list of dice where the '>' operation between successive\ndice pairs applies but a comparison between the first and last of the list\nyields the opposite result, '<'.  \n*(Similarly '<' successive list comparisons with a final '>' between first and last is also non-transitive).*\n\nThree dice S, T, U with appropriate face values could satisfy\n\n```\n   S < T, T < U and yet S > U\n\n```\n\nTo be non-transitive.\n\nNotes\n\n* The order of numbers on the faces of a die is not relevant. For example, three faced die described with face numbers of 1, 2, 3 or 2, 1, 3 or any other permutation are equivalent. For the purposes of the task **show only the permutation in lowest-first sorted order i.e. 1, 2, 3** (and remove any of its perms).\n* A die can have more than one instance of the same number on its faces, e.g. `2, 3, 3, 4`\n* **Rotations**: Any rotation of non-transitive dice from an answer is also an answer. You may *optionally* compute and show only one of each such rotation sets, ideally the first when sorted in a natural way. If this option is used then prominently state in the output that rotations of results are also solutions.\n\nTask\n\n\n====\n\nFind all the ordered lists of *three* non-transitive dice S, T, U of the form\nS < T, T < U and yet S > U; where the dice are selected from all *four-faced die*\n, (unique w.r.t the notes), possible by having selections from the integers\n*one to four* on any dies face.\n\nSolution can be found by generating all possble individual die then testing all\npossible permutations, (permutations are ordered), of three dice for\nnon-transitivity.\n\nOptional stretch goal\n\nFind lists of **four** non-transitive dice selected from the same possible dice from the non-stretch goal.\n\nShow the results here, on this page.\n\nReferences\n\n* The Most Powerful Dice - Numberphile Video.\n* Nontransitive dice - Wikipedia."}, {"role": "assistant", "content": "Thanks to Thundergnat for the nice \"less-is-more\" tweaks now the 4 dice portion takes around 10 (down from 17 ) minutes to run ..\n\n**Translation of**: Go\n\n```\n# 20201225 Raku programming solution\n\nmy @dicepool = ^4 xx 4 ;\n\nsub FaceCombs(\\N, @dp) { # for brevity, changed to use 0-based dice on input\n   my @res = my @found = [];\n   for [X] @dp {\n      unless @found[ my \\key = [+] ( N «**« (N-1…0) ) Z* .sort ] {\n         @found[key] = True;\n         @res.push: $_ »+» 1\n      }\n   }\n   @res\n}\n\nsub infix:<⚖️>(@x, @y) { +($_{Less} <=> $_{More}) given (@x X<=> @y).Bag }\n\nsub findIntransitive(\\N, \\cs) {\n   my @res = [];\n   race for [X] ^+cs xx N -> @lot {\n      my $skip = False;\n      for @lot.rotor(2 => -1) {\n         { $skip = True and last } unless cs[ @_[0] ] ⚖️ cs[ @_[1] ] == -1\n      }\n      next if $skip;\n      if cs[ @lot[0] ] ⚖️ cs[ @lot[*-1] ] == 1 { @res.push: [ cs[ @lot ] ] }\n   }\n   @res\n}\n\nsay \"Number of eligible 4-faced dice : \", +(my \\combs = FaceCombs(4,@dicepool));\nfor 3, 4 {\n   my @output = findIntransitive($_, combs);\n   say +@output, \" ordered lists of $_ non-transitive dice found, namely:\";\n   .say for @output;\n}\n\n```\n\nOutput:\n\n```\nNumber of eligible 4-faced dice : 35\n3 ordered lists of 3 non-transitive dice found, namely:\n[(1 1 4 4) (2 2 2 4) (1 3 3 3)]\n[(1 3 3 3) (1 1 4 4) (2 2 2 4)]\n[(2 2 2 4) (1 3 3 3) (1 1 4 4)]\n4 ordered lists of 4 non-transitive dice found, namely:\n[(1 1 4 4) (2 2 2 4) (2 2 3 3) (1 3 3 3)]\n[(1 3 3 3) (1 1 4 4) (2 2 2 4) (2 2 3 3)]\n[(2 2 2 4) (2 2 3 3) (1 3 3 3) (1 1 4 4)]\n[(2 2 3 3) (1 3 3 3) (1 1 4 4) (2 2 2 4)]\n```"}]}
{"messages": [{"role": "user", "content": "Nonoblock is a chip off the old Nonogram puzzle.\n\nGiven\n\n* The number of cells in a row.\n* The size of each, (space separated), connected block of cells to fit in the row, in left-to right order.\n\nTask\n\n* show all possible positions.\n* show the number of positions of the blocks for the following cases within the row.\n* show all output on this page.\n* use a \"neat\" diagram of the block positions.\n\nEnumerate the following configurations\n\n1. **5**   cells   and   **[2, 1]**   blocks\n2. **5**   cells   and   **[]**   blocks   (no blocks)\n3. **10**   cells   and   **[8]**   blocks\n4. **15**   cells   and   **[2, 3, 2, 3]**   blocks\n5. **5**   cells   and   **[2, 3]**   blocks   (should give some indication of this not being possible)\n\nExample\n\nGiven a row of five cells and a block of two cells followed by a block of one cell - in that order, the example could be shown as:\n\n```\n   |_|_|_|_|_| # 5 cells and [2, 1] blocks\n\n```\n\nAnd would expand to the following 3 possible rows of block positions:\n\n```\n   |A|A|_|B|_|\n   |A|A|_|_|B|\n   |_|A|A|_|B|\n\n```\n\nNote how the sets of blocks are always separated by a space.\n\nNote also that it is not necessary for each block to have a separate letter.\nOutput approximating\n\nThis:\n\n```\n                       |#|#|_|#|_|\n                       |#|#|_|_|#|\n                       |_|#|#|_|#|\n\n```\n\nThis would also work:\n\n```\n                       ##.#.\n                       ##..#\n                      .##.#\n\n```\n\nAn algorithm\n\n* Find the minimum space to the right that is needed to legally hold all but the leftmost block of cells (with a space between blocks remember).\n* The leftmost cell can legitimately be placed in all positions from the LHS up to a RH position that allows enough room for the rest of the blocks.\n* for each position of the LH block recursively compute the position of the rest of the blocks in the *remaining* space to the right of the current placement of the LH block.\n\n(This is the algorithm used in the Nonoblock#Python solution).\n\nReference\n\n* The blog post Nonogram puzzle solver (part 1) Inspired this task and donated its Nonoblock#Python solution."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nfor (5, [2,1]), (5, []), (10, [8]), (5, [2,3]), (15, [2,3,2,3]) -> ($cells, @blocks) {\n    say $cells, ' cells with blocks: ', @blocks ?? join ', ', @blocks !! '∅';\n    my $letter = 'A';\n    my $row = join '.', map { $letter++ x $_ }, @blocks;\n    say \"no solution\\n\" and next if $cells < $row.chars;\n    say $row ~= '.' x $cells - $row.chars;\n    say $row while $row ~~ s/^^ (\\.*) <|w> (.*?) <|w> (\\w+) \\.<!|w> /$1$0.$2/;\n    say '';\n}\n\n```\n\nOutput:\n\n```\n5 cells with blocks: 2, 1\nAA.B.\nAA..B\n.AA.B\n\n5 cells with blocks: ∅\n.....\n\n10 cells with blocks: 8\nAAAAAAAA..\n.AAAAAAAA.\n..AAAAAAAA\n\n5 cells with blocks: 2, 3\nno solution\n\n15 cells with blocks: 2, 3, 2, 3\nAA.BBB.CC.DDD..\nAA.BBB.CC..DDD.\nAA.BBB..CC.DDD.\nAA..BBB.CC.DDD.\n.AA.BBB.CC.DDD.\nAA.BBB.CC...DDD\nAA.BBB..CC..DDD\nAA..BBB.CC..DDD\n.AA.BBB.CC..DDD\nAA.BBB...CC.DDD\nAA..BBB..CC.DDD\n.AA.BBB..CC.DDD\nAA...BBB.CC.DDD\n.AA..BBB.CC.DDD\n..AA.BBB.CC.DDD\n```"}]}
{"messages": [{"role": "user", "content": "A nonogram is a puzzle that provides\nnumeric clues used to fill in a grid of cells,\nestablishing for each cell whether it is filled or not.\nThe puzzle solution is typically a picture of some kind.\n\nEach row and column of a rectangular grid is annotated with the lengths\nof its distinct runs of occupied cells.\nUsing only these lengths you should find one valid configuration\nof empty and occupied cells, or show a failure message.\n\nExample\n\n```\nProblem:                 Solution:\n\n. . . . . . . .  3       . # # # . . . .  3\n. . . . . . . .  2 1     # # . # . . . .  2 1\n. . . . . . . .  3 2     . # # # . . # #  3 2\n. . . . . . . .  2 2     . . # # . . # #  2 2\n. . . . . . . .  6       . . # # # # # #  6\n. . . . . . . .  1 5     # . # # # # # .  1 5\n. . . . . . . .  6       # # # # # # . .  6\n. . . . . . . .  1       . . . . # . . .  1\n. . . . . . . .  2       . . . # # . . .  2\n1 3 1 7 5 3 4 3          1 3 1 7 5 3 4 3\n2 1 5 1                  2 1 5 1\n```\n\nThe problem above could be represented by two lists of lists:\n\n```\nx = [[3], [2,1], [3,2], [2,2], [6], [1,5], [6], [1], [2]]\ny = [[1,2], [3,1], [1,5], [7,1], [5], [3], [4], [3]]\n```\n\nA more compact representation of the same problem uses strings,\nwhere the letters represent the numbers, A=1, B=2, etc:\n\n```\nx = \"C BA CB BB F AE F A B\"\ny = \"AB CA AE GA E C D C\"\n```\n\nTask\n\nFor this task, try to solve the 4 problems below, read from a “nonogram\\_problems.txt” file that has this content\n(the blank lines are separators):\n\n```\nC BA CB BB F AE F A B\nAB CA AE GA E C D C\n\nF CAC ACAC CN AAA AABB EBB EAA ECCC HCCC\nD D AE CD AE A DA BBB CC AAB BAA AAB DA AAB AAA BAB AAA CD BBA DA\n\nCA BDA ACC BD CCAC CBBAC BBBBB BAABAA ABAD AABB BBH BBBD ABBAAA CCEA AACAAB BCACC ACBH DCH ADBE ADBB DBE ECE DAA DB CC\nBC CAC CBAB BDD CDBDE BEBDF ADCDFA DCCFB DBCFC ABDBA BBF AAF BADB DBF AAAAD BDG CEF CBDB BBB FC\n\nE BCB BEA BH BEK AABAF ABAC BAA BFB OD JH BADCF Q Q R AN AAN EI H G\nE CB BAB AAA AAA AC BB ACC ACCA AGB AIA AJ AJ ACE AH BAF CAG DAG FAH FJ GJ ADK ABK BL CM\n```\n\n**Extra credit**: generate nonograms with unique solutions, of desired height and width.\n  \n  \nThis task is the problem n.98 of the \"99 Prolog Problems\" (archived) by Werner Hett (also thanks to Paul Singleton for the idea and the examples).\n\nRelated tasks\n\n* Nonoblock.\n\nSee also\n\n* Arc Consistency Algorithm\n* http://www.haskell.org/haskellwiki/99\\_questions/Solutions/98 (Haskell)\n* http://twanvl.nl/blog/haskell/Nonograms (Haskell)\n* http://picolisp.com/5000/!wiki?99p98 (PicoLisp)"}, {"role": "assistant", "content": "### Translation of Go\n\n**Translation of**: Go\n\n```\n# 20220401 Raku programming solution\n\nsub reduce(\\a, \\b) {\n   my \\countRemoved = $ = 0;\n   for ^+a -> \\i {\n      my \\commonOn  = @ =  True xx b.elems;\n      my \\commonOff = @ = False xx b.elems; \n\n      a[i].map: -> \\candidate { commonOn  <<?&=>> candidate ; \n                                commonOff <<?|=>> candidate }\n      # remove from b[j] all candidates that don't share the forced values\n      for ^+b -> \\j {\n         my (\\fi,\\fj) = i, j;\n         for ((+b[j])^...0) -> \\k {\n            my \\cnd = b[j][k];\n            if (commonOn[fj] ?& !cnd[fi]) ?| (!commonOff[fj] ?& cnd[fi]) {\n\t       b[j][k..*-2] = b[j][k+1..*-1];\n               b[j].pop; \n               countRemoved++\n            }\n         }\n         return -1 if b[j].elems == 0 \n      }\n   }\n   return countRemoved\n}\n\nsub genSequence(\\ones, \\numZeros) {\n   if ( my \\le = ones.elems ) == 0 { return [~] '0' xx numZeros }\n    \n   my @result;\n   loop ( my $x = 1; $x < ( numZeros -le+2); $x++ ) {\n      my @skipOne = ones[1..*];\n      for genSequence(@skipOne, numZeros -$x) -> \\tail {\n         @result.push:  ( '0' x $x )~ones[0]~tail\n      }\n   }\n   return @result\n}\n\n# If all the candidates for a row have a value in common for a certain cell,\n#   then it's the only possible outcome, and all the candidates from the\n#   corresponding column need to have that value for that cell too. The ones\n#   that don't, are removed. The same for all columns. It goes back and forth,\n#   until no more candidates can be removed or a list is empty (failure).\n\nsub reduceMutual(\\cols, \\rows) {\n   return -1 if ( my \\countRemoved1 = reduce(cols, rows) ) == -1 ;\n   return -1 if ( my \\countRemoved2 = reduce(rows, cols) ) == -1 ; \n   \n   return countRemoved1 + countRemoved2\n}\n\n# collect all possible solutions for the given clues\nsub getCandidates(@data, \\len) { \n   return gather for @data -> \\s {\n      my \\sumBytes = [+] (my @a = s.ords)>>.&{ $_ - 'A'.ord + 1 } \n      my @prep = @a.values.map: { [~] '1' xx ($_ - 'A'.ord + 1) } \n      take ( gather for genSequence(@prep, len -sumBytes+1) -> \\r {\n         my \\bits = r.substr(1..*).ords;\n\t take ( bits.values.map: *.chr == '1' ).Array\n      } ).Array\n   }\n}\n\nsub  newPuzzle (@data) {\n\n   my (@rowData,@colData) := @data.map: *.split: ' ' ;\n\n   my \\rows = getCandidates(@rowData, @colData.elems);\n   my \\cols = getCandidates(@colData, @rowData.elems);\n\n   loop {\n      my \\numChanged = reduceMutual(cols, rows);\n      given (numChanged) { when -1 { say \"No solution\" andthen return }\n                           when  0 { last }                             }\n   }\n\n   for rows -> \\row {\n      for ^+cols -> \\k { print row[0][k] ?? '# ' !! '. ' }\n      print \"\\n\" \n   }\n   print \"\\n\" \n}\n\nnewPuzzle $_ for (\n   ( \"C BA CB BB F AE F A B\", \"AB CA AE GA E C D C\" ),\n\n   ( \"F CAC ACAC CN AAA AABB EBB EAA ECCC HCCC\",\n     \"D D AE CD AE A DA BBB CC AAB BAA AAB DA AAB AAA BAB AAA CD BBA DA\" ),\n\n   ( \"CA BDA ACC BD CCAC CBBAC BBBBB BAABAA ABAD AABB BBH \"\n       ~\"BBBD ABBAAA CCEA AACAAB BCACC ACBH DCH ADBE ADBB DBE ECE DAA DB CC\",\n     \"BC CAC CBAB BDD CDBDE BEBDF ADCDFA DCCFB DBCFC ABDBA BBF AAF BADB DBF \"\n        ~\"AAAAD BDG CEF CBDB BBB FC\" ),\n\n   ( \"E BCB BEA BH BEK AABAF ABAC BAA BFB OD JH BADCF Q Q R AN AAN EI H G\",\n     \"E CB BAB AAA AAA AC BB ACC ACCA AGB AIA AJ AJ \"\n        ~\"ACE AH BAF CAG DAG FAH FJ GJ ADK ABK BL CM\" ),\n);\n\n```\n\n### Translation of Perl\n\n**Translation of**: Perl\n\n```\nfor './nonogram_problems.txt'.IO.lines.rotor(3, :partial) {\n\n   my (@rpats,@cpats) := @_[0,1]>>.&makepatterns;\n   my @rows            = ( '.' x +@cpats ) xx +@rpats ;   \n\n   loop (my $prev = ''; $prev ne ~@rows; ) {\n      $prev = ~@rows;\n      try(@rows, @rpats);\n      my @cols = (^+@cpats).map: { [~] @rows.map: { ~ s/.// } }\n      try(@cols, @cpats);\n      @rows    = (^+@rpats).map: { [~] @cols.map: { ~ s/.// } } \n   }   \n   say();\n   @rows ~~ /\\./ ?? say \"Failed\" !! say TR/01/.@/ for @rows\n}\n\nsub try(@lines, @patterns) {\n   for ^+@lines -> $i { \n      my $pos = 0;\n      while ( @lines[$i] ~~ m:g/\\./ and $pos < @lines[$i].chars ) {\n         for 0, 1 -> $try {\n\t    with @lines[$i] { S:pos($pos)/\\./$try/ ~~ /<{@patterns[$i]}>/ or\n                              s:pos($pos)/./{ 1 - $try }/                   }\n         }\n\t $pos++;\n      }\n   }\n}\n\nsub makepatterns($input) {   \n   $input ==> split( ' ' ) \n          ==>   map( *.comb )  \n\t  ==>   map( *>>.&{ .ord - 64 } )  \n\t  ==>   map( '<[1.]>**' <<~<< * )  \n\t  ==>   map( *.join:  '<[0.]>+' ) \n\t  ==>   map( '^<[0.]>*' ~ * ~ '<[0.]>*$' )\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement the algorithm to compute the principal   nth   root   \n\nA\n\nn\n{\\displaystyle {\\displaystyle {\\sqrt[{n}]{A}}}}\n   of a positive real number   *A*,   as explained at the   Wikipedia page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub infix:<√>($n, $A) {\n    .tail given $A / $n, { (($n-1) * $_+ $A / ($_** ($n-1))) / $n } ... * ≅ *;\n}\n\nuse Test;\nplan 9;\nis-approx ($_√pi)**$_, pi for 2 .. 10;\n\n```"}]}
{"messages": [{"role": "user", "content": "**Null** (or **nil**) is the computer science concept of an undefined or unbound object.\nSome languages have an explicit way to access the null object, and some don't.\nSome languages distinguish the null object from undefined values, and some don't.\n\nTask\n\nShow how to access null in your language by checking to see if an object is equivalent to the null object.\n\n*This task is not about whether a variable is defined. The task is about \"null\"-like values in various languages, which may or may not be related to the defined-ness of variables in your language.*"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Haskell\n\n(as it were...)\n\nIn Raku you can name the concept of Nil, but it not considered an object, but rather the *absence* of an object, more of a \"bottom\" type. The closest analog in real objects is an empty list, but an empty list is considered defined, while Nil.defined always returns false. Nil is what you get if you try to read off the end of a list, and () is just very easy to read off the end of... :-)\n\nIf you try to put Nil into a container, you don't end up with a container that has Nil in it. Instead the container reverts to an uninitialized state that is consistent with the declared type. Hence, Raku has the notion of typed undefined values, that are real objects in the sense of \"being there\", but are generic in the sense of representing type information without being instantiated as a real object. We call these *type objects* since they can stand in for real objects when one reasons about the types of objects. So type objects fit into the type hierarchy just as normal objects do. In physics terms, think of them as \"type charge carriers\" that are there for bookkeeping between the \"real\" particles.\n\nAll type objects derive from Mu, the most-undefined type\nobject, and the object most like \"null\" in many languages. All other object types derive from Mu,\nso it is like Object in other languages as well, except Mu also encompasses various objects that are not discrete, such as junctions. So Raku distinguishes Mu from Any, which is the type that functions the most like a discrete, mundane object.\n\nMostly the user doesn't have to think about it. All object containers behave like \"Maybe\" types in Haskell terms; they may either hold a valid value or a \"nothing\" of an appropriate type.\nMost containers default to an object of type Any so you don't accidentally send quantum superpositions (junctions) around in your program.\n\n```\nmy $var;\nsay $var.WHAT;      # Any()\n$var = 42;\nsay $var.WHAT;      # Int()\nsay $var.defined;   # True\n$var = Nil;\nsay $var.WHAT;      # Any()\nsay $var.defined    # False\n\n```\n\nYou can declare a variable of type Mu if you wish to propagate superpositional types:\n\n```\nmy Mu $junction;\nsay $junction.WHAT;      # Mu()\n$junction = 1 | 2 | 3;\nsay $junction.WHAT;      # Junction()\n\n```\n\nOr you can declare a more restricted type than Any\n\n```\nmy Str $str;\nsay $str.WHAT;      # Str()\n$str = \"I am a string.\";\nsay $str.WHAT;      # Str()\n$str = 42;          # (fails)\n\n```\n\nBut in the Raku view of reality, it's completely bogus to ask\nfor a way \"to see if an object is equivalent to the null object.\"\nThe whole point of such a non-object object is that it doesn't exist,\nand can't participate in computations. If you think you mean the\nnull object in Raku, you really mean some kind of generic object\nthat is uninstantiated, and hence undefined. One of those is your \"null object\",\nexcept there are many of them, so you can't just check for equivalence. Use the defined predicate (or match on a subclass of your type that forces recognition of abstraction or definedness).\n\nRaku also has Failure objects that, in addition to being\nundefined carriers of type, are also carriers of the *reason*\nfor the value's undefinedness. We tend view them as lazily thrown\nexceptions, at least until you try to use them as defined values,\nin which case they're thrown for real."}]}
{"messages": [{"role": "user", "content": "Task\n\nShow how to spell out a number in English.\n\nYou can use a preexisting implementation or roll your own, but you should support inputs up to at least one million (or the maximum value of your language's default bounded integer type, if that's less).\n\nSupport for inputs other than positive integers (like zero, negative integers, and floating-point numbers) is optional.\n\nRelated task\n\n* Spelling of ordinal numbers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nApart from the $m++ this can be viewed as a purely functional program; we use nested gather/take constructs to avoid accumulators.\n\n```\nconstant @I = <zero one    two    three    four     five    six     seven     eight    nine\n               ten  eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen>;\nconstant @X = <0    X      twenty thirty   forty    fifty   sixty   seventy   eighty   ninety>;\nconstant @C = @I X~ ' hundred';\nconstant @M = (<0 thousand>,\n    ((<m b tr quadr quint sext sept oct non>,\n    (map { ('', <un duo tre quattuor quin sex septen octo novem>).flat X~ $_ },\n    <dec vigint trigint quadragint quinquagint sexagint septuagint octogint nonagint>),\n    'cent').flat X~ 'illion')).flat;\n\nsub int-name ($num) {\n    if $num.substr(0,1) eq '-' { return \"negative {int-name($num.substr(1))}\" }\n    if $num eq '0' { return @I[0] }\n    my $m = 0;\n    return join ', ', reverse gather for $num.flip.comb(/\\d ** 1..3/) {\n        my ($i,$x,$c) = .comb».Int;\n        if $i or $x or $c {\n            take join ' ', gather {\n                if $c { take @C[$c] }\n                if $x and $x == 1 { take @I[$i+10] }\n                else {\n                    if $x { take @X[$x] }\n                    if $i { take @I[$i] }\n                }\n                take @M[$m] // die \"WOW! ZILLIONS!\\n\" if $m;\n            }\n        }\n        $m++;\n    }\n}\n\nwhile '' ne (my $n = prompt(\"Number: \")) {\n    say int-name($n);\n}\n\n```\n\nOutput:\n\n```\nNumber: 0\nzero\nNumber: 17\nseventeen\nNumber: -1,234,567,890          \nnegative one billion, two hundred thirty four million, five hundred sixty seven thousand, eight hundred ninety\nNumber: 42 000\nforty two thousand\nNumber: 1001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001\none novemseptuagintillion, one octoseptuagintillion, one septenseptuagintillion, one sexseptuagintillion, one quinseptuagintillion, one quattuorseptuagintillion, one treseptuagintillion, one duoseptuagintillion, one unseptuagintillion, one septuagintillion, one novemsexagintillion, one octosexagintillion, one septensexagintillion, one sexsexagintillion, one quinsexagintillion, one quattuorsexagintillion, one tresexagintillion, one duosexagintillion, one unsexagintillion, one sexagintillion, one novemquinquagintillion, one octoquinquagintillion, one septenquinquagintillion, one sexquinquagintillion, one quinquinquagintillion, one quattuorquinquagintillion, one trequinquagintillion, one duoquinquagintillion, one unquinquagintillion, one quinquagintillion, one novemquadragintillion, one octoquadragintillion, one septenquadragintillion, one sexquadragintillion, one quinquadragintillion, one quattuorquadragintillion, one trequadragintillion, one duoquadragintillion, one unquadragintillion, one quadragintillion, one novemtrigintillion, one octotrigintillion, one septentrigintillion, one sextrigintillion, one quintrigintillion, one quattuortrigintillion, one tretrigintillion, one duotrigintillion, one untrigintillion, one trigintillion, one novemvigintillion, one octovigintillion, one septenvigintillion, one sexvigintillion, one quinvigintillion, one quattuorvigintillion, one trevigintillion, one duovigintillion, one unvigintillion, one vigintillion, one novemdecillion, one octodecillion, one septendecillion, one sexdecillion, one quindecillion, one quattuordecillion, one tredecillion, one duodecillion, one undecillion, one decillion, one nonillion, one octillion, one septillion, one sextillion, one quintillion, one quadrillion, one trillion, one billion, one million, one thousand, one\nNumber: 198723483017417\none hundred ninety eight trillion, seven hundred twenty three billion, four hundred eighty three million, seventeen thousand, four hundred seventeen\n```\n\nAlternately, we could use the Lingua::EN::Numbers module from the Raku ecosystem. It will return similar output for similar inputs as above, but also handles fractions with configurable reduction and denominator, exponential notation, and ordinal notation.\n\n```\nuse Lingua::EN::Numbers; # Version 2.4.0 or higher\n\nput join \"\\n\", .&cardinal, .&cardinal(:improper) with -7/4;\n\nprintf \"%-7s : %19s : %s\\n\", $_, cardinal($_), cardinal($_, :denominator(16)) for 1/16, 2/16 ... 1;\n\nput join \"\\n\", .&cardinal, .&cardinal-year, .&ordinal, .&ordinal-digit with 1999;\n\n.&cardinal.put for 6.022e23, 42000, π;\n\n```\n\n```\nnegative one and three quarters\nnegative seven quarters\n0.0625  :       one sixteenth : one sixteenth\n0.125   :          one eighth : two sixteenths\n0.1875  :    three sixteenths : three sixteenths\n0.25    :         one quarter : four sixteenths\n0.3125  :     five sixteenths : five sixteenths\n0.375   :       three eighths : six sixteenths\n0.4375  :    seven sixteenths : seven sixteenths\n0.5     :            one half : eight sixteenths\n0.5625  :     nine sixteenths : nine sixteenths\n0.625   :        five eighths : ten sixteenths\n0.6875  :   eleven sixteenths : eleven sixteenths\n0.75    :      three quarters : twelve sixteenths\n0.8125  : thirteen sixteenths : thirteen sixteenths\n0.875   :       seven eighths : fourteen sixteenths\n0.9375  :  fifteen sixteenths : fifteen sixteenths\n1       :                 one : one\none thousand, nine hundred ninety-nine\nnineteen ninety-nine\none thousand, nine hundred ninety-ninth\n1999th\nsix point zero two two times ten to the twenty-third\nforty-two thousand\nthree point one four one five nine two six five three five eight nine seven nine\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a jumbled list of the numbers   **1**   to   **9**   that are definitely   *not*   in\nascending order.\n\nShow the list,   and then ask the player how many digits from the\nleft to reverse.\n\nReverse those digits,   then ask again,   until all the digits end up in ascending order.\n\nThe score is the count of the reversals needed to attain the ascending order.\n\nNote: Assume the player's input does not need extra validation.\n\nRelated tasks\n\n* Sorting algorithms/Pancake sort\n* Pancake sorting.\n* Topswops"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nDo-at-least-once loops are fairly rare, but this program wants to have two of them. We use the built-in .pick(\\*) method to shuffle the numbers. We use .= to dispatch a mutating method in two spots; the first is just a different way to write ++, while the second of these reverses an array slice in place. The [<] is a reduction operator on less than, so it returns true if the elements of the list are strictly ordered. We also see in the first repeat loop that, although the while condition is not tested till after the loop, the while condition can in fact declare the variable that will be initialized the first time through the loop, which is a neat trick, and not half unreadable once you get used to it.\n\n```\nrepeat while [<] my @jumbled-list {\n    @jumbled-list = (1..9).pick(*)\n}\n\nmy $turn = 0;\nrepeat until [<] @jumbled-list {\n    my $d = prompt $turn.=succ.fmt('%2d: ') ~\n                   @jumbled-list ~\n                   \" - Flip how many digits? \"\n        or exit;\n    @jumbled-list[^$d] .= reverse;\n}\n\nsay \"    @jumbled-list[]\";\nsay \"You won in $turn turns.\";\n\n```\n\nOutput:\n\n```\n 1: 3 5 8 2 7 9 6 1 4 - Flip how many digits ? 6\n 2: 9 7 2 8 5 3 6 1 4 - Flip how many digits ? 9\n 3: 4 1 6 3 5 8 2 7 9 - Flip how many digits ? 6\n 4: 8 5 3 6 1 4 2 7 9 - Flip how many digits ? 8\n 5: 7 2 4 1 6 3 5 8 9 - Flip how many digits ? 7\n 6: 5 3 6 1 4 2 7 8 9 - Flip how many digits ? 3\n 7: 6 3 5 1 4 2 7 8 9 - Flip how many digits ? 6\n 8: 2 4 1 5 3 6 7 8 9 - Flip how many digits ? 4\n 9: 5 1 4 2 3 6 7 8 9 - Flip how many digits ? 5\n10: 3 2 4 1 5 6 7 8 9 - Flip how many digits ? 3\n11: 4 2 3 1 5 6 7 8 9 - Flip how many digits ? 4\n12: 1 3 2 4 5 6 7 8 9 - Flip how many digits ? 2\n13: 3 1 2 4 5 6 7 8 9 - Flip how many digits ? 3\n14: 2 1 3 4 5 6 7 8 9 - Flip how many digits ? 2\n    1 2 3 4 5 6 7 8 9\nYou won in 14 turns.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show positive decimal integers divisible by their individual digits,   but not divisible by the product of their digits,\n  \nwhere   **n   <   1,000**"}, {"role": "assistant", "content": "```\nsay \"{+$_} matching numbers:\\n{.batch(10)».fmt('%3d').join: \"\\n\"}\" given\n   (^1000).grep: -> $n { $n.contains(0) ?? False !! all |($n.comb).map($n %% *), $n % [*] $n.comb };\n\n```\n\nOutput:\n\n```\n45 matching numbers:\n 22  33  44  48  55  66  77  88  99 122\n124 126 155 162 168 184 222 244 248 264\n288 324 333 336 366 396 412 424 444 448\n488 515 555 636 648 666 728 777 784 824\n848 864 888 936 999\n```"}]}
{"messages": [{"role": "user", "content": "Task\n:   Find numbers in base 10 that are palindromic in bases 2, 4, and 16, where **n < 25,000**"}, {"role": "assistant", "content": "```\nput \"{+$_} such numbers:\\n\", .batch(10)».fmt('%5d').join(\"\\n\") given\n(^25000).grep: -> $n { all (2,4,16).map: { $n.base($_) eq $n.base($_).flip } }\n\n```\n\nOutput:\n\n```\n23 such numbers:\n    0     1     3     5    15    17    51    85   255   257\n  273   771   819  1285  1365  3855  4095  4097  4369 12291\n13107 20485 21845\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind positive integers for which the base 16 (hexadecimal) representation does not contain any decimal digits '0'..'9',   where   **n   <   50010**"}, {"role": "assistant", "content": "> Find numbers in base-16 representation that cannot be written with decimal digits, where n < 500\n\nThis is **literally** the exact same task as (the horribly named) Base-16 representation task.\n\nLeaving aside the requirement that it be base 16 (well, base negative 16 according to the task title); assume it really means *hexadecimal*, otherwise all bets are off.\n\nI challenge anyone to demonstrate how, say 46510, can be written in hexadecimal using only decimal digits.\n\nThe task as written:\n\n```\nput \"{+$_} such numbers:\\n\", .batch(20)».fmt('%3d').join(\"\\n\")\n    given (1..500).grep( { so any |.map: { .polymod(16 xx *) »>» 9 } } );\n\n```\n\nOutput:\n\n```\n301 such numbers:\n 10  11  12  13  14  15  26  27  28  29  30  31  42  43  44  45  46  47  58  59\n 60  61  62  63  74  75  76  77  78  79  90  91  92  93  94  95 106 107 108 109\n110 111 122 123 124 125 126 127 138 139 140 141 142 143 154 155 156 157 158 159\n160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179\n180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199\n200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219\n220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239\n240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 266 267 268 269\n270 271 282 283 284 285 286 287 298 299 300 301 302 303 314 315 316 317 318 319\n330 331 332 333 334 335 346 347 348 349 350 351 362 363 364 365 366 367 378 379\n380 381 382 383 394 395 396 397 398 399 410 411 412 413 414 415 416 417 418 419\n420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439\n440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459\n460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479\n480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499\n500\n```\n\nWhat the task author *probably* meant.\n\nFind numbers in decimal that when written in hexadecimal are expressed using **only** alphabetic glyphs.\n\nWhich is a **tiny** (2 character) change from Base-16 representation. Add some other (possibly useful) functionality.\n\n```\n#Filter out such numbers from a range:\nput \"Filter: {+$_} such numbers:\\n\", .batch(20)».fmt('%3d').join(\"\\n\")\n    given (1..500).grep( { so all |.map: { .polymod(16 xx *) »>» 9 } } );\n\n#Generate such numbers directly, up to a threshold:\nput \"\\nGenerate: first {+$_}:\\n\", .batch(10)».map({ \"{$_}({:16($_)})\" })».fmt('%9s').join(\"\\n\") given\n    ((1..^Inf).grep(* % 7).map( { .base(7).trans: [1..6] => ['A'..'F'] } )).grep(!*.contains: 0)[^42];\n\n#Count such numbers directly, up to a threshold \nmy $upto = 500;\nput \"\\nCount: \" ~ [+] flat (map {exp($_, 6)}, 1..($upto.log(16).floor)),\n+(exp($upto.log(16).floor, 16) .. $upto).grep( { so all |.map: { .polymod(16 xx *) »>» 9 } });\n\n```\n\nOutput:\n\n```\nFilter: 42 such numbers:\n 10  11  12  13  14  15 170 171 172 173 174 175 186 187 188 189 190 191 202 203\n204 205 206 207 218 219 220 221 222 223 234 235 236 237 238 239 250 251 252 253\n254 255\n\nGenerate: first 42:\n    A(10)     B(11)     C(12)     D(13)     E(14)     F(15)   AA(170)   AB(171)   AC(172)   AD(173)\n  AE(174)   AF(175)   BA(186)   BB(187)   BC(188)   BD(189)   BE(190)   BF(191)   CA(202)   CB(203)\n  CC(204)   CD(205)   CE(206)   CF(207)   DA(218)   DB(219)   DC(220)   DD(221)   DE(222)   DF(223)\n  EA(234)   EB(235)   EC(236)   ED(237)   EE(238)   EF(239)   FA(250)   FB(251)   FC(252)   FD(253)\n  FE(254)   FF(255)\n\nCount: 42\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nFor the purposes of this task, a **qualifying number** is a non-negative integer, k, whose last letter is the same as the first letter of k+1 when written in English.\n\nFor example, 18 (i.e 'eighteen' in English) is a qualifying number because its last letter 'n' is the same as the first letter of 'nineteen'.\n\nTake the English equivalent of 0 to be 'zero' and not 'nought' or similar words.\n\nFor numbers such as 100 or 1000, the equivalent English should be taken as 'one hundred' or 'one thousand' and not 'a hundred' or 'a thousand'.\n\nTask\n\n1. Find and show here the first 50 qualifying numbers.\n\n2. What are the 1,000th and 10,000th qualifying numbers?\n\n3. For the first 1,000 and 10,000 qualifying numbers, show their breakdown by final digit. This can be shown numerically, graphically or both.\n\nIf it is difficult for your language to meet all of these requirements, then just do what you reasonably can.\n\nStretch\n\n4. What are the 100,000th and millionth qualifying numbers?\n\n5. For the first 100,000 and million qualifying numbers, show their breakdown by final digit.\n\nReferences\n\n* OEIS sequence A363659:Numbers k such that the last letter of k is the same as the first letter of k+1 when written in English.\n\n* GCHQ, The GCHQ Puzzle Book, Penguin, 2016. See Puzzle 31, page 37 (referred to in OEIS link).\n\n* Number names"}, {"role": "assistant", "content": "**Translation of**: Wren\n\n```\n# 20230713 Raku programming solution\n\n###### https://rosettacode.org/wiki/Number_names#Raku\n\nconstant @I = <zero one    two    three    four     five    six     seven     eight    nine\n               ten  eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen>;\nconstant @X = <0    X      twenty thirty   forty    fifty   sixty   seventy   eighty   ninety>;\nconstant @C = @I X~ ' hundred';\nconstant @M = (<0 thousand>,\n    ((<m b tr quadr quint sext sept oct non>,\n    (map { ('', <un duo tre quattuor quin sex septen octo novem>).flat X~ $_ },\n    <dec vigint trigint quadragint quinquagint sexagint septuagint octogint nonagint>),\n    'cent').flat X~ 'illion')).flat;\n\nsub int-name ($num) {\n    if $num.substr(0,1) eq '-' { return \"negative {int-name($num.substr(1))}\" }\n    if $num eq '0' { return @I[0] }\n    my $m = 0;\n    return join ', ', reverse gather for $num.flip.comb(/\\d ** 1..3/) {\n        my ($i,$x,$c) = .comb».Int;\n        if $i or $x or $c {\n            take join ' ', gather {\n                if $c { take @C[$c] }\n                if $x and $x == 1 { take @I[$i+10] }\n                else {\n                    if $x { take @X[$x] }\n                    if $i { take @I[$i] }\n                }\n                take @M[$m] // die \"WOW! ZILLIONS!\\n\" if $m;\n            }\n        }\n        $m++;\n    }\n}\n######\n\nmy ($i, $c, $limit, $prev, @nums, @lastDigs) = 0, 0, 1000, int-name(0);\n\nwhile $limit <= 1e4 {\n   my $next = int-name $i+1;\n   if $prev.substr(*-1) eq $next.substr(0,1) {\n      if ($c < 50) { @nums.append: $i };\n      @lastDigs[$i % 10] += 1;\n      $c++;\n      if $c == 50 {\n         say \"First 50 numbers:\";\n         say [~] $_>>.fmt('%4s') for @nums.rotor(10);\n         say(); \n      } elsif $c == $limit {\n         print \"The {$c}th number is $i.\\n\";\n         say \"Breakdown by last digit of first {$c}th numbers\";\n         say 'N Freq';\n         for 0..9 -> $d { \n            say \"$d {@lastDigs[$d].fmt('%4s')} \",\n                '█' x (@lastDigs[$d]/@lastDigs.max*72).Int;\n         }\n         say(); \n         $limit *= 10\n      }\n   }\n   $prev = $next;\n   $i++;\n}\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Find the numbers **k** whose divisor sum is equal to the divisor sum of **k + 1**.\n\n*Divisor sum is also known as sigma-sum.*\n\nFor example\n\n```\n   14 has divisors 1, 2, 7, 14 that sum to 24.\n   15 has divisors 1, 3, 5, 15 that sum to 24.\n\n```\n\nSo 14 is a member of this sequence.\n\nTask\n\nFind the first 25 members of this sequence.\n\nStretch\n\nFind the first 50 members of this sequence.\n\nSee also\n\n:   * **OEIS A002961 - Numbers k such that k and k+1 have same sum of divisors**"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\nuse Lingua::EN::Numbers;\n\nsay ++$, ': ', .&comma for (^Inf).hyper.grep( {\n    state $next = .&sigma-sum;\n    my $test = $next == my $this = ($_ + 1).&sigma-sum;\n    $next = $this;\n    $test\n})[^50];\n\n```\n\nOutput:\n\n```\n1: 14\n2: 206\n3: 957\n4: 1,334\n5: 1,364\n6: 1,634\n7: 2,685\n8: 2,974\n9: 4,364\n10: 14,841\n11: 18,873\n12: 19,358\n13: 20,145\n14: 24,957\n15: 33,998\n16: 36,566\n17: 42,818\n18: 56,564\n19: 64,665\n20: 74,918\n21: 79,826\n22: 79,833\n23: 84,134\n24: 92,685\n25: 109,214\n26: 111,506\n27: 116,937\n28: 122,073\n29: 138,237\n30: 147,454\n31: 161,001\n32: 162,602\n33: 166,934\n34: 174,717\n35: 190,773\n36: 193,893\n37: 201,597\n38: 230,390\n39: 274,533\n40: 289,454\n41: 347,738\n42: 383,594\n43: 416,577\n44: 422,073\n45: 430,137\n46: 438,993\n47: 440,013\n48: 445,874\n49: 455,373\n50: 484,173\n```"}]}
{"messages": [{"role": "user", "content": "Integer squares are the set of integers multiplied by themselves: 1 x 1 = **1**, 2 × 2 = **4**, 3 × 3 = **9**, etc. ( 1, 4, 9, 16 ... )\n\nMost positive integers can be generated as the sum of 1 or more distinct integer squares.\n\n```\n     1 == 1\n     5 == 4 + 1\n    25 == 16 + 9\n    77 == 36 + 25 + 16\n   103 == 49 + 25 + 16 + 9 + 4\n\n```\n\nMany can be generated in multiple ways:\n\n```\n    90 == 36 + 25 + 16 + 9 + 4 == 64 + 16 + 9 + 1 == 49 + 25 + 16 == 64 + 25 + 1 == 81 + 9\n   130 == 64 + 36 + 16 + 9 + 4 + 1 == 49 + 36 + 25 + 16 + 4 == 100 + 16 + 9 + 4 + 1 == 81 + 36 + 9 + 4 == 64 + 49 + 16 + 1 == 100 + 25 + 4 + 1 == 81 + 49 == 121 + 9    \n\n```\n\nThe number of positive integers that **cannot** be generated by any combination of distinct squares is in fact finite:\n\n```\n   2, 3, 6, 7, etc.\n\n```\n\nTask\n\nFind and show here, on this page, **every** positive integer than cannot be generated as the sum of distinct squares.\n\nDo not use magic numbers or pre-determined limits. Justify your answer mathematically.\n\nSee also\n\n* OEIS: A001422 Numbers which are not the sum of distinct squares"}, {"role": "assistant", "content": "Try it online!\n\n**Spoiler:** *(highlight to read)*  \nOnce the longest run of consecutive generated sums is longer the the next square, every number after can be generated by adding the next square to every number in the run. Find the *new* longest run, add the *next* square, etc.\n\n```\nmy @squares = ^∞ .map: *²; # Infinite series of squares\n\nfor 1..∞ -> $sq {          # for every combination of all squares\n    my @sums = @squares[^$sq].combinations».sum.unique.sort;\n    my @run;\n    for @sums {\n        @run.push($_) and next unless @run.elems;\n        if $_ == @run.tail + 1 { @run.push: $_ } else { last if @run.elems > @squares[$sq]; @run = () }\n    }\n    put grep * ∉ @sums, 1..@run.tail and last if @run.elems > @squares[$sq];\n}\n\n```\n\nOutput:\n\n```\n2 3 6 7 8 11 12 15 18 19 22 23 24 27 28 31 32 33 43 44 47 48 60 67 72 76 92 96 108 112 128\n```"}]}
{"messages": [{"role": "user", "content": "Example\n\nConsider the number 24. Its proper divisors are: 1, 2, 3, 4, 6, 8 and 12. Their product is 13,824 and the cube root of this is 24. So 24 satisfies the definition in the task title.\n\nTask\n\nCompute and show here the first **50** positive integers which are the cube roots of the product of their proper divisors.\n\nAlso show the **500th** and **5,000th** such numbers.\n\nStretch\n\nCompute and show the **50,000th** such number.\n\nReference\n\n* OEIS:A111398 - Numbers which are the cube roots of the product of their proper divisors.\n\nNote\n\nOEIS considers 1 to be the first number in this sequence even though, strictly speaking, it has no proper divisors. Please therefore do likewise."}, {"role": "assistant", "content": "```\nuse Prime::Factor;\nuse Lingua::EN::Numbers;\nmy @cube-div = lazy 1, |(2..∞).hyper.grep: { .³ == [×] .&proper-divisors }\n\nput \"First 50 numbers which are the cube roots of the products of their proper divisors:\\n\" ~\n  @cube-div[^50]».fmt(\"%3d\").batch(10).join: \"\\n\";\n\nprintf \"\\n%16s: %s\\n\", .Int.&ordinal.tc, comma @cube-div[$_ - 1] for 5e2, 5e3, 5e4;\n\n```\n\nOutput:\n\n```\nFirst 50 numbers which are the cube roots of the products of their proper divisors:\n  1  24  30  40  42  54  56  66  70  78\n 88 102 104 105 110 114 128 130 135 136\n138 152 154 165 170 174 182 184 186 189\n190 195 222 230 231 232 238 246 248 250\n255 258 266 273 282 285 286 290 296 297\n\n  Five hundredth: 2,526\n\n Five thousandth: 23,118\n\nFifty thousandth: 223,735\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow positive integers   **n**   whose binary and ternary digits sum are prime,   where   **n   <   200**."}, {"role": "assistant", "content": "```\nsay (^200).grep(-> $n {all (2,3).map({$n.base($_).comb.sum.is-prime}) }).batch(10)».fmt('%3d').join: \"\\n\";\n\n```\n\nOutput:\n\n```\n  5   6   7  10  11  12  13  17  18  19\n 21  25  28  31  33  35  36  37  41  47\n 49  55  59  61  65  67  69  73  79  82\n 84  87  91  93  97 103 107 109 115 117\n121 127 129 131 133 137 143 145 151 155\n157 162 167 171 173 179 181 185 191 193\n199\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind positive integers   **n**   which count of divisors is prime,   but not equal to  **2**,   where   **n   <   1,000**.\n\nStretch goal:   (as above),   but where   **n   <   100,000**."}, {"role": "assistant", "content": "```\nuse Prime::Factor;\n\nmy $ceiling = ceiling sqrt 1e5;\n\nsay display :10cols, :fmt('%6d'), (^$ceiling)».² .grep: { .&divisors.is-prime };\n\nsub display ($list, :$cols = 10, :$fmt = '%6d', :$title = \"{+$list} matching:\\n\" )   {\n    cache $list;\n    $title ~ $list.batch($cols)».fmt($fmt).join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\n79 matching:\n     4      9     16     25     49     64     81    121    169    289\n   361    529    625    729    841    961   1024   1369   1681   1849\n  2209   2401   2809   3481   3721   4096   4489   5041   5329   6241\n  6889   7921   9409  10201  10609  11449  11881  12769  14641  15625\n 16129  17161  18769  19321  22201  22801  24649  26569  27889  28561\n 29929  32041  32761  36481  37249  38809  39601  44521  49729  51529\n 52441  54289  57121  58081  59049  63001  65536  66049  69169  72361\n 73441  76729  78961  80089  83521  85849  94249  96721  97969\n```"}]}
{"messages": [{"role": "user", "content": "When a number is written in base 10,   adjacent digits may \"rise\" or \"fall\" as the number is read   (usually from left to right).\n\nDefinition\n\nGiven the decimal digits of the number are written as a series   d:\n\n:   * A   *rise*   is an index   i   such that    d(i)  <  d(i+1)\n    * A   *fall*    is an index   i   such that    d(i)  >  d(i+1)\n\nExamples\n:   * The number   **726,169**   has   **3**   rises and   **2**   falls,   so it isn't in the sequence.\n    * The number     **83,548**   has   **2**   rises and   **2**   falls,   so it   is   in the sequence.\n\nTask\n:   * Print the first   **200**   numbers in the sequence\n    * Show that the   **10 millionth**   (10,000,000th)   number in the sequence is   **41,909,002**\n\nSee also\n\n* OEIS Sequence  A296712   describes numbers whose digit sequence in base 10 have equal \"rises\" and \"falls\".\n\nRelated tasks\n\n* Esthetic numbers"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.09\n\n```\nuse Lingua::EN::Numbers;\nuse Base::Any;\n\nsub rf (int $base = 10, $batch = Any, &op = &infix:<==>) {\n    my %batch = batch => $batch if $batch;\n    flat (1 .. ∞).hyper(|%batch).map: {\n        my int ($this, $last) = $_, $_ % $base;\n        my int ($rise, $fall) = 0, 0;\n        while $this {\n            my int $rem = $this % $base;\n            $this = $this div $base;\n            if    $rem > $last { $fall = $fall + 1 }\n            elsif $rem < $last { $rise = $rise + 1 }\n            $last = $rem\n        }\n        next unless &op($rise, $fall);\n        $_\n    }\n}\n\n# The task\nmy $upto = 200;\nput \"Rise = Fall:\\nFirst {$upto.&cardinal} (base 10):\";\n.put for rf[^$upto]».fmt(\"%3d\").batch(20);\n\n$upto = 10_000_000;\nput \"\\nThe {$upto.&ordinal} (base 10): \", comma rf(10, 65536)[$upto - 1];\n\n# Other bases and comparisons\nput \"\\n\\nGeneralized for other bases and other comparisons:\";\n$upto = ^5;\nmy $which = \"{tc $upto.map({.exp(10).&ordinal}).join: ', '}, values in some other bases:\";\n\nput \"\\nRise = Fall: $which\";\nfor <3 296691 4 296694 5 296697 6 296700 7 296703 8 296706 9 296709 10 296712\n     11 296744 12 296747 13 296750 14 296753 15 296756 16 296759 20 296762 60 296765>\n  -> $base, $oeis {\n    put \"Base {$base.fmt(<%2d>)} (https://oeis.org/A$oeis): \",\n    $upto.map({rf(+$base, Any)[.exp(10) - 1].&to-base($base)}).join: ', '\n}\n\nput \"\\nRise > Fall: $which\";\nfor <3 296692 4 296695 5 296698 6 296701 7 296704 8 296707 9 296710 10 296713\n     11 296745 12 296748 13 296751 14 296754 15 296757 16 296760 20 296763 60 296766>\n  -> $base, $oeis {\n     put \"Base {$base.fmt(<%2d>)} (https://oeis.org/A$oeis): \",\n     $upto.map({rf(+$base, Any, &infix:«>»)[.exp(10) - 1].&to-base($base)}).join: ', '\n }\n\nput \"\\nRise < Fall: $which\";\nfor <3 296693 4 296696 5 296699 6 296702 7 296705 8 296708 9 296711 10 296714\n     11 296746 12 296749 13 296752 14 296755 15 296758 16 296761 20 296764 60 296767>\n  -> $base, $oeis {\n     put \"Base {$base.fmt(<%2d>)} (https://oeis.org/A$oeis): \",\n     $upto.map({rf(+$base, Any, &infix:«<»)[.exp(10) - 1].&to-base($base)}).join: ', '\n }\n\n```\n\nOutput:\n\n```\nRise = Fall:\nFirst two hundred (base 10):\n  1   2   3   4   5   6   7   8   9  11  22  33  44  55  66  77  88  99 101 102\n103 104 105 106 107 108 109 111 120 121 130 131 132 140 141 142 143 150 151 152\n153 154 160 161 162 163 164 165 170 171 172 173 174 175 176 180 181 182 183 184\n185 186 187 190 191 192 193 194 195 196 197 198 201 202 203 204 205 206 207 208\n209 212 213 214 215 216 217 218 219 222 230 231 232 240 241 242 243 250 251 252\n253 254 260 261 262 263 264 265 270 271 272 273 274 275 276 280 281 282 283 284\n285 286 287 290 291 292 293 294 295 296 297 298 301 302 303 304 305 306 307 308\n309 312 313 314 315 316 317 318 319 323 324 325 326 327 328 329 333 340 341 342\n343 350 351 352 353 354 360 361 362 363 364 365 370 371 372 373 374 375 376 380\n381 382 383 384 385 386 387 390 391 392 393 394 395 396 397 398 401 402 403 404\n\nThe ten millionth (base 10): 41,909,002\n\n\nGeneralized for other bases and other comparisons:\n\nRise = Fall: First, tenth, one hundredth, one thousandth, ten thousandth, values in some other bases:\nBase  3 (https://oeis.org/A296691): 1, 201, 22112, 10101111, 1100022001\nBase  4 (https://oeis.org/A296694): 1, 111, 3333, 221012, 13002120\nBase  5 (https://oeis.org/A296697): 1, 102, 1441, 40011, 1431201\nBase  6 (https://oeis.org/A296700): 1, 55, 512, 20424, 400402\nBase  7 (https://oeis.org/A296703): 1, 44, 365, 12620, 155554\nBase  8 (https://oeis.org/A296706): 1, 33, 316, 7466, 60404\nBase  9 (https://oeis.org/A296709): 1, 22, 275, 5113, 40217\nBase 10 (https://oeis.org/A296712): 1, 11, 252, 3396, 29201\nBase 11 (https://oeis.org/A296744): 1, A, 216, 2240, 21718\nBase 12 (https://oeis.org/A296747): 1, A, 201, 10AA, 19723\nBase 13 (https://oeis.org/A296750): 1, A, 1B8, A0A, 172A7\nBase 14 (https://oeis.org/A296753): 1, A, 1B5, 8B9, 14B81\nBase 15 (https://oeis.org/A296756): 1, A, 1B2, 7D4, 11BBA\nBase 16 (https://oeis.org/A296759): 1, A, 1A9, 716, 10424\nBase 20 (https://oeis.org/A296762): 1, A, 196, 523, 8011\nBase 60 (https://oeis.org/A296765): 1, A, ff, 1f2, 63Q\n\nRise > Fall: First, tenth, one hundredth, one thousandth, ten thousandth, values in some other bases:\nBase  3 (https://oeis.org/A296692): 12, 1222, 122202, 12222001, 2001200001\nBase  4 (https://oeis.org/A296695): 12, 233, 12113, 1003012, 13131333\nBase  5 (https://oeis.org/A296698): 12, 122, 2302, 112013, 1342223\nBase  6 (https://oeis.org/A296701): 12, 45, 1305, 20233, 333134\nBase  7 (https://oeis.org/A296704): 12, 34, 1166, 11612, 140045\nBase  8 (https://oeis.org/A296707): 12, 26, 1013, 4557, 106756\nBase  9 (https://oeis.org/A296710): 12, 25, 348, 2808, 36781\nBase 10 (https://oeis.org/A296713): 12, 24, 249, 2345, 23678\nBase 11 (https://oeis.org/A296745): 12, 23, 223, 1836, 15806\nBase 12 (https://oeis.org/A296748): 12, 1B, 166, 1623, 12534\nBase 13 (https://oeis.org/A296751): 12, 1B, 145, 149B, A069\nBase 14 (https://oeis.org/A296754): 12, 1B, 12B, 1393, 6BC9\nBase 15 (https://oeis.org/A296757): 12, 1B, 11A, 12B7, 568E\nBase 16 (https://oeis.org/A296760): 12, 1B, CD, 1206, 466A\nBase 20 (https://oeis.org/A296763): 12, 1B, 7E, 6BF, 2857\nBase 60 (https://oeis.org/A296766): 12, 1B, 2i, Lp, 66U\n\nRise < Fall: First, tenth, one hundredth, one thousandth, ten thousandth, values in some other bases:\nBase  3 (https://oeis.org/A296693): 10, 221, 22220, 10021001, 1012110000\nBase  4 (https://oeis.org/A296696): 10, 210, 3330, 231210, 13132000\nBase  5 (https://oeis.org/A296699): 10, 43, 2420, 43033, 2030042\nBase  6 (https://oeis.org/A296702): 10, 43, 1540, 25543, 403531\nBase  7 (https://oeis.org/A296705): 10, 43, 1010, 10051, 206260\nBase  8 (https://oeis.org/A296708): 10, 43, 660, 5732, 75051\nBase  9 (https://oeis.org/A296711): 10, 43, 643, 5010, 60873\nBase 10 (https://oeis.org/A296714): 10, 43, 621, 4120, 44100\nBase 11 (https://oeis.org/A296746): 10, 43, 544, 3243, 31160\nBase 12 (https://oeis.org/A296749): 10, 43, 520, 2A71, 18321\nBase 13 (https://oeis.org/A296752): 10, 43, 422, 2164, B624\nBase 14 (https://oeis.org/A296755): 10, 43, 310, 1CA3, A506\nBase 15 (https://oeis.org/A296758): 10, 43, E8, 1A20, 9518\nBase 16 (https://oeis.org/A296761): 10, 43, E8, 10D0, 860D\nBase 20 (https://oeis.org/A296764): 10, 43, E8, G33, 5F43\nBase 60 (https://oeis.org/A296767): 10, 43, E8, j9, ZUT\n```"}]}
{"messages": [{"role": "user", "content": "Find all the positive integers whose decimal digits are all primes and sum to   **13**."}, {"role": "assistant", "content": "```\nput join ', ', sort +*, unique flat\n   < 2 2 2 2 2 3 3 3 5 5 7 >.combinations\n   .grep( *.sum == 13 )\n   .map( { .join => $_ } )\n   .map: { .value.permutations».join }\n\n```\n\nOutput:\n\n```\n337, 355, 373, 535, 553, 733, 2227, 2272, 2335, 2353, 2533, 2722, 3235, 3253, 3325, 3352, 3523, 3532, 5233, 5323, 5332, 7222, 22225, 22252, 22333, 22522, 23233, 23323, 23332, 25222, 32233, 32323, 32332, 33223, 33232, 33322, 52222, 222223, 222232, 222322, 223222, 232222, 322222\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind decimal numbers   **n**   that when converted to **hexadecimal** produce a number that uses the same set of digits (regardless of order and ignoring duplicates) as the original number,   where   **n  <  100000**\n\nExample\n\nThe decimal number   **2339**   is   **923**   when written in hexadecimal.\n\nThe set of digits used,   ignoring order and duplicates,   is   **{2, 3, 9}**   in both cases and hence this number satisfies the task requirements."}, {"role": "assistant", "content": "Only bother to check numbers that could possibly match.\n\nSeveral different interpretations of the (originally very vague) task instructions. It has now been clarified to mean the second.\n\n```\nsay \"Numbers up to 100,000 which when expressed in hexadecimal and in decimal\nare composed of the same digit glyphs. (All the same glyphs, all the same\nquantity.)\\n\";\ndisplay-numbers calculated-with &infix:<eqv>, <Bag>;\n\nsay \"\\nNumbers up to 100,000 which when expressed in hexadecimal and in decimal\nare composed from the same digit glyphs. (All the same glyphs  are present,\npossibly different quantity.)\\n\";\ndisplay-numbers calculated-with &infix:<eqv>, <Set>;\n\nsay \"\\nNumbers up to 100,000 which, when expressed in hexadecimal use glyphs\nthat are a subset of those used when expressed in decimal. (Every glyph in\ndecimal is present in hexadecimal the same or fewer (possibly zero) times)\\n\";\ndisplay-numbers calculated-with &infix:<⊆>, <Bag>;\n\nsay \"\\nNumbers up to 100,000 which, when expressed in hexadecimal use glyphs\nthat are a subset of those used when expressed in decimal. (Every glyph in\ndecimal is present in hexadecimal in some quantity, possibly zero, possibly more\nthan in decimal)\\n\";\ndisplay-numbers calculated-with &infix:<⊆>, <Set>;\n\nsub display-numbers ($_) { say .elems ~ \" found:\\n\" ~ .batch(20)».fmt('%5d').join: \"\\n\" }\n\nsub calculated-with ( &op, $container ) {\n    cache ^18699 .map( {:16(.Str)} ).hyper(:1000batch).grep( {\n        reduce( &op, (.fmt('%x'), $_).map: { .comb.\"$container\"() } )\n    } )\n}\n\n```\n\nOutput:\n\n```\nNumbers which when expressed in hexadecimal and in decimal are composed of\nthe same digit glyphs. (All the same glyphs, all the same quantity.)\n\n34 found:\n    0     1     2     3     4     5     6     7     8     9    53   371   913  4100  5141  5412  6182  8200  9241 75120\n75121 75122 75123 75124 75125 75126 75127 75128 75129 75621 86150 91465 98711 99481\n\nNumbers which when expressed in hexadecimal and in decimal are composed\nfrom the same digit glyphs. (All the same glyphs are present, possibly\ndifferent quantity.)\n\n69 found:\n    0     1     2     3     4     5     6     7     8     9    53   371   913  1040  2080  2339  4100  5141  5412  5441\n 6182  8200  9241 13593 13665 13969 16406 20530 26946 30979 32803 33638 33840 33841 33842 33843 33844 33845 33846 33847\n33848 33849 34883 37943 38931 38966 38995 66310 71444 71497 71511 75120 75121 75122 75123 75124 75125 75126 75127 75128\n75129 75621 86150 88165 91465 91769 96617 98711 99481\n\nNumbers which, when expressed in hexadecimal use glyphs that are a subset\nof those used when expressed in decimal. (Every glyph in decimal is present in\nhexadecimal the same or fewer (possibly zero) times)\n\n141 found:\n    0     1     2     3     4     5     6     7     8     9    53   371   913  1040  1041  1042  1043  1044  1045  1046\n 1047  1048  1049  1345  1937  2080  2081  2082  2083  2084  2085  2086  2087  2088  2089  2339  4100  5141  5412  6182\n 8200  9241 12306 13593 13665 13969 16400 16401 16402 16403 16404 16405 16406 16407 16408 16409 16743 18453 20513 20530\n20546 21025 25169 25896 25986 26370 26738 26913 26930 26946 29217 29714 30768 30784 30979 32800 32801 32802 32803 32804\n32805 32806 32807 32808 32809 32850 33589 33840 33841 33842 33843 33844 33845 33846 33847 33848 33849 34868 34880 34881\n34882 34883 34884 34885 34886 34887 34888 34889 36902 36950 37492 37943 38931 38960 38961 38962 38963 38964 38965 38966\n38967 38968 38969 38984 38995 39298 75120 75121 75122 75123 75124 75125 75126 75127 75128 75129 75621 86150 91465 98711\n99481\n\nNumbers which, when expressed in hexadecimal use glyphs that are a subset\nof those used when expressed in decimal. (Every glyph in decimal is present in\nhexadecimal in some quantity, possibly zero, possibly more than in decimal)\n\n514 found:\n    0     1     2     3     4     5     6     7     8     9    17    53    85   371   853   913  1024  1040  1041  1042\n 1043  1044  1045  1046  1047  1048  1049  1345  1365  1604  1633  1635  1638  1689  1937  2048  2080  2081  2082  2083\n 2084  2085  2086  2087  2088  2089  2178  2184  2339  4100  4160  4371  4417  4471  4481  4721  4913  4931  5140  5141\n 5412  5441  5461  6168  6182  8200  8210  8320  8721  9241  9284  9523  9625  9762  9826  9862 10248 10258 10280 10529\n12304 12305 12306 12307 12320 12340 12563 12593 12643 12803 12833 12834 12835 12853 12953 13056 13057 13059 13062 13072\n13073 13075 13079 13080 13104 13105 13107 13124 13171 13175 13185 13187 13209 13364 13384 13427 13448 13459 13585 13587\n13589 13593 13651 13653 13654 13665 13846 13862 13926 13969 14385 14387 14388 14739 16400 16401 16402 16403 16404 16405\n16406 16407 16408 16409 16420 16480 16640 16704 16740 16742 16743 17408 17409 17425 17426 17428 17431 17442 17463 17473\n17476 17479 17480 17495 17524 17745 18247 18440 18449 18452 18453 18456 18472 18483 18497 18504 18564 20485 20501 20512\n20513 20514 20517 20530 20531 20533 20544 20546 20548 20549 20560 20561 20562 20563 20564 20565 20566 20567 20568 20569\n20576 20597 21025 21395 21504 21524 21540 21541 21845 21905 22357 22568 22658 24608 24610 24630 24640 24680 25106 25126\n25169 25186 25361 25604 25634 25684 25896 25961 25986 26129 26130 26131 26134 26145 26146 26148 26150 26163 26184 26208\n26210 26214 26248 26370 26407 26470 26471 26487 26658 26728 26738 26758 26913 26914 26918 26921 26930 26931 26934 26937\n26946 26948 26965 26978 26982 26984 26985 28704 28706 28740 28807 29217 29337 29714 29764 29847 30467 30471 30517 30547\n30567 30576 30579 30728 30768 30784 30976 30979 31097 32800 32801 32802 32803 32804 32805 32806 32807 32808 32809 32840\n32850 33280 33587 33589 33638 33689 33840 33841 33842 33843 33844 33845 33846 33847 33848 33849 33864 34678 34820 34852\n34867 34868 34871 34872 34880 34881 34882 34883 34884 34885 34886 34887 34888 34889 34948 34968 36902 36950 36960 37139\n37169 37492 37529 37689 37779 37924 37940 37943 37945 38195 38791 38792 38793 38920 38931 38952 38960 38961 38962 38963\n38964 38965 38966 38967 38968 38969 38984 38995 39048 39185 39187 39193 39200 39201 39202 39203 39204 39205 39206 39207\n39208 39209 39217 39218 39219 39225 39234 39241 39250 39251 39253 39257 39266 39267 39287 39298 39313 39315 39321 66310\n67140 67190 69910 69913 69921 70001 70162 70513 71025 71206 71265 71266 71286 71440 71441 71442 71443 71444 71445 71446\n71447 71448 71449 71462 71473 71489 71492 71495 71497 71504 71505 71509 71511 71526 71537 71539 71540 71541 71543 71569\n71680 71748 71800 71808 71809 71815 71816 71940 71953 71957 71959 71961 71993 74129 75120 75121 75122 75123 75124 75125\n75126 75127 75128 75129 75621 76129 78103 78131 78135 78136 78193 79153 79731 81940 82194 82241 82471 82514 84100 84104\n86150 87315 87351 87415 88145 88152 88165 90163 91465 91665 91670 91671 91673 91682 91760 91761 91762 91763 91764 91765\n91766 91767 91768 91769 92561 94617 95761 96017 96617 98581 98711 98712 98713 99481\n```"}]}
{"messages": [{"role": "user", "content": "If   **f**,   **a**,   and   **b**   are values with uncertainties   σf,   σa,   and   σb,   and   **c**   is a constant;\n  \nthen if   **f**   is derived from   **a**,   **b**,   and   **c**   in the following ways,\n  \nthen   σf   can be calculated as follows:\n\n:   Addition/Subtraction\n\n    * If   f = a ± c,   or   f = c ± a   then   **σf = σa**\n    * If   f = a ± b   then   **σf2 = σa2 + σb2**\n\n:   Multiplication/Division\n\n    * If   f = ca   or   f = ac       then   **σf = |cσa|**\n    * If   f = ab   or   f = a / b   then   **σf2 = f2( (σa / a)2 + (σb / b)2)**\n\n:   Exponentiation\n\n    * If   f = ac   then   **σf = |fc(σa / a)|**\n\nCaution:\n\n:   :   This implementation of error propagation does not address issues of dependent and independent values.   It is assumed that   **a**   and   **b**   are independent and so the formula for multiplication should not be applied to   **a\\*a**   for example.   See   the talk page   for some of the implications of this issue.\n\nTask details\n\n1. Add an uncertain number type to your language that can support addition, subtraction, multiplication, division, and exponentiation between numbers with an associated error term together with 'normal' floating point numbers without an associated error term.   \n   Implement enough functionality to perform the following calculations.\n2. Given coordinates and their errors:  \n   x1 = 100 ± 1.1  \n   y1 = 50 ± 1.2  \n   x2 = 200 ± 2.2  \n   y2 = 100 ± 2.3  \n    if point p1 is located at (x1, y1) and p2 is at (x2, y2); calculate the distance between the two points using the classic Pythagorean formula:   \n     d = √   (x1 - x2)²   +   (y1 - y2)²\n3. Print and display both    **d**    and its error.\n\nReferences\n\n* A Guide to Error Propagation B. Keeney, 2005.\n* Propagation of uncertainty Wikipedia.\n\nRelated task\n\n* Quaternion type"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n**Translation of**: Perl\n\n```\n# cache of independent sources so we can make them all the same length.\n# (Because Raku does not yet have a longest-zip metaoperator.)\nmy @INDEP;\n\nclass Approx does Numeric {\n    has Real $.x;\t# The mean.\n    has $.c;\t\t# The components of error.\n\n    multi method Str  { sprintf \"%g±%.3g\", $!x, $.σ }\n    multi method Bool { abs($!x) > $.σ }\n\n    method variance { [+] @.c X** 2 }\n    method σ { sqrt self.variance }\n}\n\nmulti approx($x,$c) { Approx.new: :$x, :$c }\nmulti approx($x) { Approx.new: :$x, :c[0 xx +@INDEP] }\n\n# Each ± gets its own source slot.\nmulti infix:<±>($a, $b) {\n    .push: 0 for @INDEP; # lengthen older component lists\n    my $c = [ flat 0 xx @INDEP, $b ];\n    @INDEP.push: $c;\t # add new component list\n\n    approx $a, $c;\n}\n\nmulti prefix:<->(Approx $a) { approx -$a.x, [$a.c.map: -*] }\n\nmulti infix:<+>($a, Approx $b) { approx($a) + $b }\nmulti infix:<+>(Approx $a, $b) { $a + approx($b) }\nmulti infix:<+>(Approx $a, Approx $b) { approx $a.x + $b.x, [$a.c Z+ $b.c] }\n\nmulti infix:<->($a, Approx $b) { approx($a) - $b }\nmulti infix:<->(Approx $a, $b) { $a - approx($b) }\nmulti infix:<->(Approx $a, Approx $b) { approx $a.x - $b.x, [$a.c Z- $b.c] }\n \nmulti covariance(Real   $a, Real   $b) { 0 }\nmulti covariance(Approx $a, Approx $b) { [+] $a.c Z* $b.c }\n\nmulti infix:«<=>»(Approx $a, Approx $b) { $a.x <=> $b.x }\nmulti infix:<cmp>(Approx $a, Approx $b) { $a.x <=> $b.x }\n \nmulti infix:<*>($a, Approx $b) { approx($a) * $b }\nmulti infix:<*>(Approx $a, $b) { $a * approx($b) }\nmulti infix:<*>(Approx $a, Approx $b) {\n    approx $a.x * $b.x,\n           [$a.c.map({$b.x * $_}) Z+ $b.c.map({$a.x * $_})];\n}\n \nmulti infix:</>($a, Approx $b) { approx($a) / $b }\nmulti infix:</>(Approx $a, $b) { $a / approx($b) }\nmulti infix:</>(Approx $a, Approx $b) {\n    approx $a.x / $b.x,\n           [ $a.c.map({ $_ / $b.x }) Z+ $b.c.map({ $a.x * $_ / $b.x / $b.x }) ];\n}\n \nmulti sqrt(Approx $a) {\n    my $x = sqrt($a.x);\n    approx $x, [ $a.c.map: { $_ / 2 / $x } ];\n}\n \nmulti infix:<**>(Approx $a, Real $b) { $a ** approx($b) }\nmulti infix:<**>(Approx $a is copy, Approx $b) {\n\tmy $ax = $a.x;\n\tmy $bx = $b.x;\n\tmy $fbx = floor $b.x;\n\tif $ax < 0 {\n\t    if $fbx != $bx or $fbx +& 1 {\n\t\tdie \"Can't take power of negative number $ax\";\n\t    }\n\t    $a = -$a;\n\t}\n\texp($b * log $a);\n}\n \nmulti exp(Approx $a) {\n\tmy $x = exp($a.x);\n\tapprox $x, [ $a.c.map: { $x * $_ } ];\n}\n \nmulti log(Approx $a) {\n\tmy $x0 = $a.x;\n\tapprox log($x0), [ $a.c.map: { $_ / $x0 }];\n}\n \n# Each ± sets up an independent source component.\nmy $x1 = 100 ± 1.1;\nmy $x2 = 200 ± 2.2;\nmy $y1 = 50  ± 1.2;\nmy $y2 = 100 ± 2.3;\n\n# The standard task.\nmy $z1 = sqrt(($x1 - $x2) ** 2 + ($y1 - $y2) ** 2);\nsay \"distance: $z1\\n\";\n\n# Just showing off.\nmy $a = $x1 + $x2;\nmy $b = $y1 - 2 * $x2;\nsay \"covariance between $a and $b: \", covariance($a,$b);\n\n```\n\nOutput:\n\n```\ndistance: 111.803±2.49\n\ncovariance between 300±2.46 and -350±4.56: -9.68\n```"}]}
{"messages": [{"role": "user", "content": "Several programming languages allow separators in numerals in order to group digits together.\n\nTask\n\nShow the numeric separator syntax and describe its specification.\n\nE.G.\n:   * What separators are eligible?\n    * Can there be multiple consecutive separators?\n    * What position can a separator be in?\n    * Etc."}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku allows underscore as a grouping / separator character in numeric inputs, though there are a few restrictions.\n\n```\n# Any numeric input value may use an underscore as a grouping/separator character.\n# May occur in nearly any position, in any* number. * See restrictions below.\n\n# Int\nsay 1_2_3;  # 123\n\n# Binary Int\nsay 0b1_0_1_0_1; # 21\n\n# Hexadecimal Int\nsay 0xa_bc_d; # 43981\n\n# Rat\nsay 1_2_3_4.2_5; # 1234.25\n\n# Num\nsay 6.0_22e4; # 60220\n\n# There are some restrictions on the placement.\n# An underscore may not be on an edge boundary, or next to another underscore.\n# The following are all syntax errors.\n\n# say _1234.25;\n# say 1234_.25;\n# say 1234._25;\n# say 1234.25_;\n# say 12__34.25;\n\n```"}]}
{"messages": [{"role": "user", "content": "This task is about expressing numbers with an attached (abutted) suffix multiplier(s),   the suffix(es) could be:\n\n:   :   * an alphabetic (named) multiplier which could be abbreviated\n        * metric  multiplier(s) which can be specified multiple times\n        * \"binary\" multiplier(s) which can be specified multiple times\n        * explanation marks (**!**) which indicate a factorial or multifactorial\n\nThe (decimal) numbers can be expressed generally as:\n\n```\n             {±}   {digits}   {.}   {digits}\n                                 ────── or ──────\n             {±}   {digits}   {.}   {digits}   {E or e}   {±}   {digits}\n\n```\n\nwhere:\n\n:   :   * numbers won't have embedded blanks   (contrary to the expaciated examples above where whitespace was used for readability)\n        * this task will only be dealing with decimal numbers,   both in the   *mantissa*   and   *exponent*\n        * ±   indicates an optional plus or minus sign   (**+**   or   **-**)\n        * digits are the decimal digits   (**0** ──► **9**)\n        * the digits can have comma(s) interjected to separate the   *periods*   (thousands)   such as:   **12,467,000**\n        * **.**   is the decimal point, sometimes also called a   *dot*\n        * **e**   or   **E**   denotes the use of decimal exponentiation   (a number multiplied by raising ten to some power)\n\nThis isn't a pure or perfect definition of the way we express decimal numbers,   but it should convey the intent for this task.\n\nThe use of the word   *periods*   (thousands) is not meant to confuse, that word (as used above) is what the **comma** separates;\n  \nthe groups of decimal digits are called *periods*,   and in almost all cases, are groups of three decimal digits.\n\nIf an   **e**   or   **E**   is specified, there must be a legal number expressed before it,   and there must be a legal (exponent) expressed after it.\n\nAlso, there must be some digits expressed in all cases,   not just a sign and/or decimal point.\n\nSuperfluous signs, decimal points, exponent numbers, and zeros   need not be preserved.\n\nI.E.:      \n**+7**   **007**   **7.00**   **7E-0**   **7E000**   **70e-1**     could all be expressed as **7**\n\nAll numbers to be \"expanded\" can be assumed to be valid and there won't be a requirement to verify their validity.\n\nAbbreviated alphabetic suffixes to be supported   (where the capital letters signify the minimum abbreation that can be used)\n\n```\n     PAIRs         multiply the number by  2         (as in pairs of shoes or pants)\n     SCOres        multiply the number by  20        (as 3score would be 60)\n     DOZens        multiply the number by  12\n     GRoss         multiply the number by  144       (twelve dozen)\n     GREATGRoss    multiply the number by  1,728     (a dozen gross)\n     GOOGOLs       multiply the number by  10^100    (ten raised to the 100&sup>th power)\n\n```\n\nNote that the plurals are supported, even though they're usually used when expressing exact numbers   (She has 2 dozen eggs, and dozens of quavas)\n\nMetric suffixes to be supported   (whether or not they're officially sanctioned)\n\n```\n     K     multiply the number by  10^3              kilo      (1,000)\n     M     multiply the number by  10^6              mega      (1,000,000)\n     G     multiply the number by  10^9              giga      (1,000,000,000)\n     T     multiply the number by  10^12             tera      (1,000,000,000,000)\n     P     multiply the number by  10^15             peta      (1,000,000,000,000,000)\n     E     multiply the number by  10^18             exa       (1,000,000,000,000,000,000)\n     Z     multiply the number by  10^21             zetta     (1,000,000,000,000,000,000,000)\n     Y     multiply the number by  10^24             yotta     (1,000,000,000,000,000,000,000,000)\n     X     multiply the number by  10^27             xenta     (1,000,000,000,000,000,000,000,000,000)\n     W     multiply the number by  10^30             wekta     (1,000,000,000,000,000,000,000,000,000,000)\n     V     multiply the number by  10^33             vendeka   (1,000,000,000,000,000,000,000,000,000,000,000)\n     U     multiply the number by  10^36             udekta    (1,000,000,000,000,000,000,000,000,000,000,000,000)\n\n```\n\nBinary suffixes to be supported   (whether or not they're officially sanctioned)\n\n```\n     Ki    multiply the number by  2^10              kibi      (1,024)\n     Mi    multiply the number by  2^20              mebi      (1,048,576)\n     Gi    multiply the number by  2^30              gibi      (1,073,741,824)\n     Ti    multiply the number by  2^40              tebi      (1,099,571,627,776)\n     Pi    multiply the number by  2^50              pebi      (1,125,899,906,884,629)\n     Ei    multiply the number by  2^60              exbi      (1,152,921,504,606,846,976)\n     Zi    multiply the number by  2^70              zeb1      (1,180,591,620,717,411,303,424)\n     Yi    multiply the number by  2^80              yobi      (1,208,925,819,614,629,174,706,176)\n     Xi    multiply the number by  2^90              xebi      (1,237,940,039,285,380,274,899,124,224)\n     Wi    multiply the number by  2^100             webi      (1,267,650,600,228,229,401,496,703,205,376)\n     Vi    multiply the number by  2^110             vebi      (1,298,074,214,633,706,907,132,624,082,305,024)\n     Ui    multiply the number by  2^120             uebi      (1,329,227,995,784,915,872,903,807,060,280,344,576)\n\n```\n\nAll of the metric and binary suffixes can be expressed in   lowercase,   uppercase,   *or*   mixed case.\n\nAll of the metric and binary suffixes can be   *stacked*   (expressed multiple times),   and also be intermixed:\n  \nI.E.:       **123k**   **123K**   **123GKi**   **12.3GiGG**   **12.3e-7T**   **.78E100e**\n\nFactorial suffixes to be supported\n\n```\n     !      compute the (regular) factorial product:   5!   is  5 × 4 × 3 × 2 × 1  =  120\n     !!     compute the  double   factorial product:   8!   is  8 × 6 × 4 × 2      =  384\n     !!!    compute the  triple   factorial product:   8!   is  8 × 5 × 2          =   80\n     !!!!   compute the quadruple factorial product:   8!   is  8 × 4              =   32\n     !!!!!  compute the quintuple factorial product:   8!   is  8 × 3              =   24\n     ··· the number of factorial symbols that can be specified is to be unlimited   (as per what can be entered/typed) ···\n\n```\n\nFactorial suffixes aren't, of course, the usual type of multipliers, but are used here in a similar vein.\n\nMultifactorials aren't to be confused with   *super─factorials*     where   **(4!)!**   would be   **(24)!**.\n\nTask\n:   :   * Using the test cases (below),   show the \"expanded\" numbers here, on this page.\n        * For each list, show the input on one line,   and also show the output on one line.\n        * When showing the input line, keep the spaces (whitespace) and case (capitalizations) as is.\n        * For each result (list) displayed on one line, separate each number with two blanks.\n        * Add commas to the output numbers were appropriate.\n\nTest cases\n\n```\n    2greatGRo   24Gros  288Doz  1,728pairs  172.8SCOre\n    1,567      +1.567k    0.1567e-2m\n    25.123kK    25.123m   2.5123e-00002G\n    25.123kiKI  25.123Mi  2.5123e-00002Gi  +.25123E-7Ei\n    -.25123e-34Vikki      2e-77gooGols\n    9!   9!!   9!!!   9!!!!   9!!!!!   9!!!!!!   9!!!!!!!   9!!!!!!!!   9!!!!!!!!!\n\n```\n\nwhere the last number for the factorials has nine factorial symbols   (**!**)   after the   **9**\n\nRelated tasks\n\n* Multifactorial                 (which has a clearer and more succinct definition of multifactorials.)\n* Factorial\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\nScientific notation, while supported in Raku, is limited to IEEE-754 64bit accuracy so there is some rounding on values using it. Implements a custom \"high precision\" conversion routine.\n\nUnfortunately, this suffix routine is of limited use for practical everyday purposes. It focuses on handling excessively large and archaic units (googol, greatgross) and completely ignores or makes unusable (due to forcing case insensitivity) many common current ones: c(centi), m(milli), μ(micro). Ah well.\n\nNote: I am blatantly and deliberately ignoring the task guidelines for formatting the output. It has no bearing on the core of the task. If you really, *really*, ***REALLY*** want to see badly formatted output, uncomment the last line.\n\n```\nuse Rat::Precise;\n\nmy $googol = 10**100;\n«PAIRs 2 SCOres 20 DOZens 12 GRoss 144  GREATGRoss 1728 GOOGOLs $googol»\n  ~~ m:g/ ((<.:Lu>+) <.:Ll>*) \\s+ (\\S+) /;\n\nmy %abr = |$/.map: {\n    my $abbrv = .[0].Str.fc;\n    my $mag   = +.[1];\n    |map { $abbrv.substr( 0, $_ ) => $mag },\n    .[0][0].Str.chars .. $abbrv.chars\n}\n\nmy %suffix = flat %abr,\n(<K  M  G  T  P  E  Z  Y  X  W  V  U>».fc  Z=> (1000, * * 1000 … *)),\n(<Ki Mi Gi Ti Pi Ei Zi Yi Xi Wi Vi Ui>».fc Z=> (1024, * * 1024 … *));\n\nmy $reg = %suffix.keys.join('|');\n\nsub comma ($i is copy) {\n    my $s = $i < 0 ?? '-' !! '';\n    my ($whole, $frac) = $i.split('.');\n    $frac = $frac.defined ?? \".$frac\" !! '';\n    $s ~ $whole.abs.flip.comb(3).join(',').flip ~ $frac\n}\n\nsub units (Str $str) {\n    $str.fc ~~ /^(.+?)(<alpha>*)('!'*)$/;\n    my ($val, $unit, $fact) = $0, $1.Str.fc, $2.Str;\n    $val.=subst(',', '', :g);\n    if $val ~~ m:i/'e'/ {\n        my ($m,$e) = $val.split(/<[eE]>/);\n        $val = ($e < 0)\n            ?? $m * FatRat.new(1,10**-$e)\n            !! $m * 10**$e;\n    }\n    my @suf = $unit;\n    unless %suffix{$unit}:exists {\n        $unit ~~ /(<$reg>)+/;\n        @suf = $0;\n    }\n    my $ret = $val<>;\n    $ret = [*] $ret, |@suf.map: { %suffix{$_} } if @suf[0];\n    $ret = [*] ($ret, * - $fact.chars …^ * < 2) if $fact.chars;\n    $ret.?precise // $ret\n}\n\nmy $test = q:to '===';\n2greatGRo   24Gros  288Doz  1,728pairs  172.8SCOre\n1,567      +1.567k    0.1567e-2m\n25.123kK    25.123m   2.5123e-00002G\n25.123kiKI  25.123Mi  2.5123e-00002Gi  +.25123E-7Ei\n-.25123e-34Vikki      2e-77gooGols\n9!   9!!   9!!!   9!!!!   9!!!!!   9!!!!!!   9!!!!!!!   9!!!!!!!!   9!!!!!!!!!\n.017k!!\n===\n\nprintf \"%16s: %s\\n\", $_, comma .&units for $test.words;\n\n# Task required stupid layout\n# say \"\\n In: $_\\nOut: \", .words.map({comma .&units}).join('  ') for $test.lines;\n\n```\n\nOutput:\n\n```\n       2greatGRo: 3,456\n          24Gros: 3,456\n          288Doz: 3,456\n      1,728pairs: 3,456\n      172.8SCOre: 3,456\n           1,567: 1,567\n         +1.567k: 1,567\n      0.1567e-2m: 1,567\n        25.123kK: 25,123,000\n         25.123m: 25,123,000\n  2.5123e-00002G: 25,123,000\n      25.123kiKI: 26,343,374.848\n        25.123Mi: 26,343,374.848\n 2.5123e-00002Gi: 26,975,615.844352\n    +.25123E-7Ei: 28,964,846,960.237816578048\n-.25123e-34Vikki: -33,394.194938104441474962344775423096782848\n    2e-77gooGols: 200,000,000,000,000,000,000,000\n              9!: 362,880\n             9!!: 945\n            9!!!: 162\n           9!!!!: 45\n          9!!!!!: 36\n         9!!!!!!: 27\n        9!!!!!!!: 18\n       9!!!!!!!!: 9\n      9!!!!!!!!!: 9\n         .017k!!: 34,459,425\n```"}]}
{"messages": [{"role": "user", "content": "Write functions to calculate the definite integral of a function  *ƒ(x)*  using *all* five of the following methods:\n\n:   * rectangular\n      + left\n      + right\n      + midpoint\n    * trapezium\n    * Simpson's\n      + composite\n\nYour functions should take in the upper and lower bounds (*a* and *b*), and the number of approximations to make in that range (*n*).\n\nAssume that your example already has a function that gives values for  *ƒ(x)* .\n\nSimpson's method is defined by the following pseudo-code:\n\nPseudocode: Simpson's method, composite\n\n|  |\n| --- |\n| ``` procedure quad_simpson_composite(f, a, b, n)     h := (b - a) / n     sum1 := f(a + h/2)     sum2 := 0      loop on i from 1 to (n - 1)         sum1 := sum1 + f(a + h * i + h/2)         sum2 := sum2 + f(a + h * i)                                                  answer := (h / 6) * (f(a) + f(b) + 4*sum1 + 2*sum2)  ``` |\n\nDemonstrate your function by showing the results for:\n\n* ƒ(x) = x3,       where   **x**   is     [0,1],       with           100 approximations.   The exact result is     0.25               (or 1/4)\n* ƒ(x) = 1/x,     where   **x**   is   [1,100],     with        1,000 approximations.   The exact result is     4.605170+     (natural log of 100)\n* ƒ(x) = x,         where   **x**   is   [0,5000],   with 5,000,000 approximations.   The exact result is   12,500,000\n* ƒ(x) = x,         where   **x**   is   [0,6000],   with 6,000,000 approximations.   The exact result is   18,000,000\n\nSee also\n\n* Active object for integrating a function of real time.\n* Special:PrefixIndex/Numerical integration for other integration methods."}, {"role": "assistant", "content": "(formerly Perl 6)\nThe addition of **Promise**/**await** allows for concurrent computation, and brings a significant speed-up in running time. Which is not to say that it makes this code fast, but it does make it less slow.\n\nNote that these integrations are done with rationals rather than floats, so should be fairly precise (though of course with so few iterations they are not terribly accurate (except when they are)). Some of the sums do overflow into Num (floating point)--currently Rakudo allows 64-bit denominators--but at least all of the interval arithmetic is exact.\n\n**Works with**: Rakudo version 2018.09\n\n```\nuse MONKEY-SEE-NO-EVAL;\n\nsub leftrect(&f, $a, $b, $n) {\n    my $h = ($b - $a) / $n;\n    my $end = $b-$h;\n    my $sum = 0;\n    loop (my $i = $a; $i <= $end; $i += $h) { $sum += f($i) }\n    $h * $sum;\n}\n\nsub rightrect(&f, $a, $b, $n) {\n    my $h = ($b - $a) / $n;\n    my $sum = 0;\n    loop (my $i = $a+$h; $i <= $b; $i += $h) { $sum += f($i) }\n    $h * $sum;\n}\n\nsub midrect(&f, $a, $b, $n) {\n    my $h = ($b - $a) / $n;\n    my $sum = 0;\n    my ($start, $end) = $a+$h/2, $b-$h/2;\n    loop (my $i = $start; $i <= $end; $i += $h) { $sum += f($i) }\n    $h * $sum;\n}\n\nsub trapez(&f, $a, $b, $n) {\n    my $h = ($b - $a) / $n;\n    my $partial-sum = 0;\n    my ($start, $end) = $a+$h, $b-$h;\n    loop (my $i = $start; $i <= $end; $i += $h) { $partial-sum += f($i) * 2 }\n    $h / 2 * ( f($a) + f($b) + $partial-sum );\n}\n\nsub simpsons(&f, $a, $b, $n) {\n    my $h = ($b - $a) / $n;\n    my $h2 = $h/2;\n    my ($start, $end) = $a+$h, $b-$h;\n    my $sum1 = f($a + $h2);\n    my $sum2 = 0;\n    loop (my $i = $start; $i <= $end; $i += $h) {\n        $sum1 += f($i + $h2);\n        $sum2 += f($i);\n    }\n    ($h / 6) * (f($a) + f($b) + 4*$sum1 + 2*$sum2);\n}\n\nsub integrate($f, $a, $b, $n, $exact) {\n    my $e = 0.000001;\n    my $r0 = \"$f\\n   in [$a..$b] / $n\\n\"\n        ~ '              exact result: '~ $exact.round($e);\n\n    my ($r1,$r2,$r3,$r4,$r5);\n    my &f;\n    EVAL \"&f = $f\";\n    my $p1 = Promise.start( { $r1 = '     rectangle method left: '~  leftrect(&f, $a, $b, $n).round($e) } );\n    my $p2 = Promise.start( { $r2 = '    rectangle method right: '~ rightrect(&f, $a, $b, $n).round($e) } );\n    my $p3 = Promise.start( { $r3 = '      rectangle method mid: '~   midrect(&f, $a, $b, $n).round($e) } );\n    my $p4 = Promise.start( { $r4 = 'composite trapezoidal rule: '~    trapez(&f, $a, $b, $n).round($e) } );\n    my $p5 = Promise.start( { $r5 = '   quadratic simpsons rule: '~  simpsons(&f, $a, $b, $n).round($e) } );\n\n    await $p1, $p2, $p3, $p4, $p5;\n    $r0, $r1, $r2, $r3, $r4, $r5;\n}\n\n.say for integrate '{ $_ ** 3 }', 0,     1,       100,       0.25; say '';\n.say for integrate '1 / *',       1,   100,      1000,   log(100); say '';\n.say for integrate '*.self',      0, 5_000, 5_000_000, 12_500_000; say '';\n.say for integrate '*.self',      0, 6_000, 6_000_000, 18_000_000;\n\n```\n\nOutput:\n\n```\n{ $_ ** 3 }\n   in [0..1] / 100\n              exact result: 0.25\n     rectangle method left: 0.245025\n    rectangle method right: 0.255025\n      rectangle method mid: 0.249988\ncomposite trapezoidal rule: 0.250025\n   quadratic simpsons rule: 0.25\n\n1 / *\n   in [1..100] / 1000\n              exact result: 4.60517\n     rectangle method left: 4.654991\n    rectangle method right: 4.556981\n      rectangle method mid: 4.604763\ncomposite trapezoidal rule: 4.605986\n   quadratic simpsons rule: 4.60517\n\n*.self\n   in [0..5000] / 5000000\n              exact result: 12500000\n     rectangle method left: 12499997.5\n    rectangle method right: 12500002.5\n      rectangle method mid: 12500000\ncomposite trapezoidal rule: 12500000\n   quadratic simpsons rule: 12500000\n\n*.self\n   in [0..6000] / 6000000\n              exact result: 18000000\n     rectangle method left: 17999997\n    rectangle method right: 18000003\n      rectangle method mid: 18000000\ncomposite trapezoidal rule: 18000000\n   quadratic simpsons rule: 18000000\n```"}]}
{"messages": [{"role": "user", "content": "Lyness's (1969) Modified Adaptive Simpson's method (doi:10.1145/321526.321537) is a numerical quadrature method that recursively bisects the interval until the precision is high enough.\n\nWrite an implementation of quadrature by adaptive Simpson’s method. Use the implementation to estimate the definite integral of sin(x) from 0 to 1. Show your output.\n\nYou can use the following pseudocode, which includes Lyness's modifications 1, 2, and 3.\n\nPseudocode: Simpson's method, adaptive\n\n|  |\n| --- |\n| ``` ; Lyness's Adaptive Simpson's Rule, Modifications 1, 2, 3 procedure simpson_rule(f, a, fa, b, fb)     m := (a + b) / 2     fm := f(m)     h := b - a     return multiple [m, fm, (h / 6) * (fa + 4*fm + fb)]  procedure recursive_simpson(f, a, fa, b, fb, tol, whole, m, fm, depth)     lm, flm, left  := simpson_rule(f, a, fa, m, fm)     rm, frm, right := simpson_rule(f, m, fm, b, fb)     delta := left + right - whole     tol' := tol / 2     if depth <= 0 or tol' == tol or abs(delta) <= 15 * tol:         return left + right + (delta / 15)     else:         return recursive_simpson(f, a, fa, m, fm, tol', left , lm, flm, depth - 1) +                recursive_simpson(f, m, fm, b, fb, tol', right, rm, frm, depth - 1)  procedure quad_asr(f, a, b, tol, depth)    fa := f(a)    fb := f(b)    m, fm, whole := simpson_rule(f, a, fa, b, fb)    return recursive_simpson(f, a, fa, b, fb, tol, whole, m, fm, depth)  ``` |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.10\n\nFairly direct translation of the Python code.\n\n```\nsub adaptive-Simpson-quadrature(&f, $left, $right, \\ε = 1e-9) {\n    my $lf = f($left);\n    my $rf = f($right);\n    my ($mid, $midf, $whole) = Simpson-quadrature-mid(&f, $left, $lf, $right, $rf);\n    return recursive-Simpsons-asr(&f, $left, $lf, $right, $rf, ε, $whole, $mid, $midf);\n\n    sub Simpson-quadrature-mid(&g, $l, $lf, $r, $rf){\n        my $mid = ($l + $r) / 2;\n        my $midf = g($mid);\n        ($mid, $midf, ($r - $l).abs / 6 * ($lf + 4 * $midf + $rf))\n    }\n\n    sub recursive-Simpsons-asr(&h, $a, $fa, $b, $fb, $eps, $whole, $m, $fm){\n        my ($lm, $flm, $left)  = Simpson-quadrature-mid(&h, $a, $fa, $m, $fm);\n        my ($rm, $frm, $right) = Simpson-quadrature-mid(&h, $m, $fm, $b, $fb);\n        my $delta = $left + $right - $whole;\n        $delta.abs <= 15 * $eps\n            ?? $left + $right + $delta / 15\n            !! recursive-Simpsons-asr(&h, $a, $fa, $m, $fm, $eps/2, $left,  $lm, $flm) +\n               recursive-Simpsons-asr(&h, $m, $fm, $b, $fb, $eps/2, $right, $rm, $frm)\n    }\n}\n\nmy ($a, $b) = 0e0, 1e0;\nmy $sin = adaptive-Simpson-quadrature(&sin, $a, $b, 1e-9).round(10**-9);;\nsay \"Simpson's integration of sine from $a to $b = $sin\";\n\n```\n\nOutput:\n\n```\nSimpson's integration of sine from 0 to 1 = 0.459697694\n```"}]}
{"messages": [{"role": "user", "content": "|  |  |\n| --- | --- |\n| In a general Gaussian quadrature rule, an definite integral of       f ( x ) {\\displaystyle {\\displaystyle f(x)}}  is first approximated over the interval       [ − 1 , 1 ] {\\displaystyle {\\displaystyle [-1,1]}}  by a polynomial approximable function       g ( x ) {\\displaystyle {\\displaystyle g(x)}}  and a known weighting function       W ( x ) {\\displaystyle {\\displaystyle W(x)}} . | ∫  − 1  1 f ( x )  d x =  ∫  − 1  1 W ( x ) g ( x )  d x {\\displaystyle {\\displaystyle \\int \\_{-1}^{1}f(x)\\,dx=\\int \\_{-1}^{1}W(x)g(x)\\,dx}} |\n| Those are then approximated by a sum of function values at specified points        x  i {\\displaystyle {\\displaystyle x\\_{i}}}  multiplied by some weights        w  i {\\displaystyle {\\displaystyle w\\_{i}}} : | ∫  − 1  1 W ( x ) g ( x )  d x ≈  ∑  i = 1  n  w  i g (  x  i ) {\\displaystyle {\\displaystyle \\int \\_{-1}^{1}W(x)g(x)\\,dx\\approx \\sum \\_{i=1}^{n}w\\_{i}g(x\\_{i})}} |\n| In the case of Gauss-Legendre quadrature, the weighting function       W ( x ) = 1 {\\displaystyle {\\displaystyle W(x)=1}} , so we can approximate an integral of       f ( x ) {\\displaystyle {\\displaystyle f(x)}}  with: | ∫  − 1  1 f ( x )  d x ≈  ∑  i = 1  n  w  i f (  x  i ) {\\displaystyle {\\displaystyle \\int \\_{-1}^{1}f(x)\\,dx\\approx \\sum \\_{i=1}^{n}w\\_{i}f(x\\_{i})}} |\n\nFor this, we first need to calculate the nodes and the weights, but after we have them, we can reuse them for numerious integral evaluations, which greatly speeds up the calculation compared to more simple numerical integration methods.\n\n|  |  |\n| --- | --- |\n| The       n {\\displaystyle {\\displaystyle n}}  evaluation points        x  i {\\displaystyle {\\displaystyle x\\_{i}}}  for a n-point rule, also called \"nodes\", are roots of n-th order Legendre Polynomials        P  n ( x ) {\\displaystyle {\\displaystyle P\\_{n}(x)}} . Legendre polynomials are defined by the following recursive rule: | P  0 ( x ) = 1 {\\displaystyle {\\displaystyle P\\_{0}(x)=1}}   P  1 ( x ) = x {\\displaystyle {\\displaystyle P\\_{1}(x)=x}}         n  P  n ( x ) = ( 2 n − 1 ) x  P  n − 1 ( x ) − ( n − 1 )  P  n − 2 ( x ) {\\displaystyle {\\displaystyle nP\\_{n}(x)=(2n-1)xP\\_{n-1}(x)-(n-1)P\\_{n-2}(x)}} |\n| There is also a recursive equation for their derivative: | P  n ′ ( x ) =   n   x  2 − 1  (  x  P  n ( x ) −  P  n − 1 ( x ) ) {\\displaystyle {\\displaystyle P\\_{n}'(x)={\\frac {n}{x^{2}-1}}\\left(xP\\_{n}(x)-P\\_{n-1}(x)\\right)}} |\n| The roots of those polynomials are in general not analytically solvable, so they have to be approximated numerically, for example by Newton-Raphson iteration: | x  n + 1 =  x  n −    f (  x  n )   f ′ (  x  n ) {\\displaystyle {\\displaystyle x\\_{n+1}=x\\_{n}-{\\frac {f(x\\_{n})}{f'(x\\_{n})}}}} |\n| The first guess        x  0 {\\displaystyle {\\displaystyle x\\_{0}}}  for the       i {\\displaystyle {\\displaystyle i}} -th root of a       n {\\displaystyle {\\displaystyle n}} -order polynomial        P  n {\\displaystyle {\\displaystyle P\\_{n}}}  can be given by | x  0 = cos ⁡  (  π     i −   1 4  n +   1 2 ) {\\displaystyle {\\displaystyle x\\_{0}=\\cos \\left(\\pi \\,{\\frac {i-{\\frac {1}{4}}}{n+{\\frac {1}{2}}}}\\right)}} |\n| After we get the nodes        x  i {\\displaystyle {\\displaystyle x\\_{i}}} , we compute the appropriate weights by: | w  i =   2   (  1 −  x  i  2 ) [  P  n ′ (  x  i )  ]  2 {\\displaystyle {\\displaystyle w\\_{i}={\\frac {2}{\\left(1-x\\_{i}^{2}\\right)[P'\\_{n}(x\\_{i})]^{2}}}}} |\n| After we have the nodes and the weights for a n-point quadrature rule, we can approximate an integral over any interval       [ a , b ] {\\displaystyle {\\displaystyle [a,b]}}  by | ∫  a  b f ( x )  d x ≈    b − a 2  ∑  i = 1  n  w  i f  (     b − a 2  x  i +    a + b 2 ) {\\displaystyle {\\displaystyle \\int \\_{a}^{b}f(x)\\,dx\\approx {\\frac {b-a}{2}}\\sum \\_{i=1}^{n}w\\_{i}f\\left({\\frac {b-a}{2}}x\\_{i}+{\\frac {a+b}{2}}\\right)}} |\n\n**Task description**\n\nSimilar to the task Numerical Integration, the task here is to calculate the definite integral of a function \n\nf\n(\nx\n)\n{\\displaystyle {\\displaystyle f(x)}}\n, but by applying an n-point Gauss-Legendre quadrature rule, as described here, for example. The input values should be an function f to integrate, the bounds of the integration interval a and b, and the number of gaussian evaluation points n. An reference implementation in Common Lisp is provided for comparison.\n\nTo demonstrate the calculation, compute the weights and nodes for an 5-point quadrature rule and then use them to compute:\n\n```\n         \n  \n    \n      \n        \n          \n            \n              ∫\n              \n                −\n                3\n              \n              \n                3\n              \n            \n            exp\n            ⁡\n            (\n            x\n            )\n            \n            d\n            x\n            ≈\n            \n              ∑\n              \n                i\n                =\n                1\n              \n              \n                5\n              \n            \n            \n              w\n              \n                i\n              \n            \n            \n            exp\n            ⁡\n            (\n            \n              x\n              \n                i\n              \n            \n            )\n            ≈\n            20.036\n          \n        \n      \n    \n    {\\displaystyle {\\displaystyle \\int _{-3}^{3}\\exp(x)\\,dx\\approx \\sum _{i=1}^{5}w_{i}\\;\\exp(x_{i})\\approx 20.036}}\n  \n\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-24\n\nA free translation of the OCaml solution. We save half the effort to calculate the nodes by exploiting the (skew-)symmetry of the Legendre Polynomials.\nThe evaluation of Pn(x) is kept linear in n by also passing Pn-1(x) in the recursion.\n\nThe quadrature function allows passing in a precalculated list of nodes for repeated integrations.\n\nNote: The calculations of Pn(x) and P'n(x) could be combined to further reduce duplicated effort. We also could cache P'n(x) from the last Newton-Raphson step for the weight calculation.\n\n```\nmulti legendre-pair(    1 , $x) { $x, 1 }\nmulti legendre-pair(Int $n, $x) {\n    my ($m1, $m2) = legendre-pair($n - 1, $x);\n    my \\u = 1 - 1 / $n;\n    (1 + u) * $x * $m1 - u * $m2, $m1;\n}\n \nmulti legendre(    0 , $ ) { 1 }\nmulti legendre(Int $n, $x) { legendre-pair($n, $x)[0] }\n \nmulti legendre-prime(    0 , $ ) { 0 }\nmulti legendre-prime(    1 , $ ) { 1 }\nmulti legendre-prime(Int $n, $x) {\n    my ($m0, $m1) = legendre-pair($n, $x);\n    ($m1 - $x * $m0) * $n / (1 - $x**2);\n}\n \nsub approximate-legendre-root(Int $n, Int $k) {\n    # Approximation due to Francesco Tricomi\n    my \\t = (4*$k - 1) / (4*$n + 2);\n    (1 - ($n - 1) / (8 * $n**3)) * cos(pi * t);\n}\n \nsub newton-raphson(&f, &f-prime, $r is copy, :$eps = 2e-16) {\n    while abs(my \\dr = - f($r) / f-prime($r)) >= $eps {\n        $r += dr;\n    }\n    $r;\n}\n \nsub legendre-root(Int $n, Int $k) {\n    newton-raphson(&legendre.assuming($n), &legendre-prime.assuming($n),\n                   approximate-legendre-root($n, $k));\n}\n \nsub weight(Int $n, $r) { 2 / ((1 - $r**2) * legendre-prime($n, $r)**2) }\n \nsub nodes(Int $n) {\n    flat gather {\n        take 0 => weight($n, 0) if $n !%% 2;\n        for 1 .. $n div 2 {\n            my $r = legendre-root($n, $_);\n            my $w = weight($n, $r);\n            take $r => $w, -$r => $w;\n        }\n    }\n}\n \nsub quadrature(Int $n, &f, $a, $b, :@nodes = nodes($n)) {\n    sub scale($x) { ($x * ($b - $a) + $a + $b) / 2 }\n    ($b - $a) / 2 * [+] @nodes.map: { .value * f(scale(.key)) }\n}\n \nsay \"Gauss-Legendre $_.fmt('%2d')-point quadrature ∫₋₃⁺³ exp(x) dx ≈ \",\n         quadrature($_, &exp, -3, +3) for flat 5 .. 10, 20;\n\n```\n\nOutput:\n\n```\nGauss-Legendre  5-point quadrature ∫₋₃⁺³ exp(x) dx ≈ 20.0355777183856\nGauss-Legendre  6-point quadrature ∫₋₃⁺³ exp(x) dx ≈ 20.0357469750923\nGauss-Legendre  7-point quadrature ∫₋₃⁺³ exp(x) dx ≈ 20.0357498197266\nGauss-Legendre  8-point quadrature ∫₋₃⁺³ exp(x) dx ≈ 20.0357498544945\nGauss-Legendre  9-point quadrature ∫₋₃⁺³ exp(x) dx ≈ 20.0357498548174\nGauss-Legendre 10-point quadrature ∫₋₃⁺³ exp(x) dx ≈ 20.0357498548198\nGauss-Legendre 20-point quadrature ∫₋₃⁺³ exp(x) dx ≈ 20.0357498548198\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at NYSIIS. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThe New York State Identification and Intelligence System phonetic code, commonly known as NYSIIS, is a phonetic algorithm for creating indices for words based on their pronunciation.\n\nThe goal is for homophones to be encoded to the same representation so that they can be matched despite minor differences in spelling.\n\nTask\n\nImplement the original NYSIIS algorithm, shown in Wikipedia, rather than any other subsequent modification.\n\nAlso, before the algorithm is applied the input string should be converted to upper case with all white space removed.\n\nAn optional step is to handle multiple names, including double-barrelled names or double surnames (e.g. 'Hoyle-Johnson' or 'Vaughan Williams') and unnecessary suffixes/honours that are not required for indexing purposes (e.g. 'Jnr', 'Sr', 'III', etc) - a small selection will suffice.\n\nThe original implementation is also restricted to six characters, but this is not a requirement.\n\nNote\n\nrules 7, 8 and 9 in the Wikipedia article are not mutually exclusive, Willis encodes to WAL, for example.\n\nSee also\n\n* Soundex"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2017.05\n\nThis implementation removes common name suffixes similar to the reference implementation, even though it is not specified in the task description or on the linked NYSIIS page. This algorithm isn't too friendly to certain French kings. :)\n\n```\nsub no_suffix ($name) {\n    $name.uc.subst: /\\h (<[JS]>R) | (<[IVX]>+) $/, '';\n}\n\nsub nysiis ($name is copy) {\n    given $name .= uc {\n        s:g/<-[A..Z]>//;\n        s/^MAC/MCC/;\n        s/^P<[FH]>/FF/;\n        s/^SCH/SSS/;\n        s/^KN/N/;\n        s/<[IE]>E$  /Y/;\n        s/<[DRN]>T$ /D/;\n        s/<[RN]>D$  /D/;\n        s:c(1):g/EV/AF/;\n        s:c(1):g/<[AEIOU]>+/A/;\n        s:c(1):g/Q/G/;\n        s:c(1):g/Z/S/;\n        s:c(1):g/M/N/;\n        s:c(1):g/KN/N/;\n        s:c(1):g/K/C/;\n        s:c(1):g/SCH/S/;\n        s:c(1):g/PF/F/;\n        s:c(1):g/K/C/;\n        s:c(1):g/H(<-[AEIOU]>)/$0/;\n        s:g/(<-[AEIOU]>)H/$0/;\n        s:g/(.)W/$0/;\n        s/ AY$ /Y/;\n        s/  S$ //;\n        s/  A$ //;\n        s:g/ (.)$0+ /$0/;\n     }\n     return $name;\n}\n\n\nfor «\n    knight      mitchell        \"o'daniel\"      \"brown  sr\"     \"browne III\"\n    \"browne IV\" \"O'Banion\"      Mclaughlin      McCormack       Chapman\n    Silva       McDonald        Lawson          Jacobs          Greene\n    \"O'Brien\"   Morrison        Larson          Willis          Mackenzie\n    Carr        Lawrence        Matthews        Richards        Bishop\n    Franklin    McDaniel        Harper          Lynch           Watkins\n    Carlson     Wheeler         \"Louis XVI\"\n» {\n    my $nysiis = nysiis no_suffix $_;\n    if $nysiis.chars > 6 {\n        $nysiis .= subst: rx/ <after .**6> .+ /, -> $/ { \"[$/]\" };\n    }\n    printf \"%10s,  %s\\n\", $_, $nysiis;\n}\n\n```\n\nOutput:\n\n```\n    knight,  NAGT\n  mitchell,  MATCAL\n  o'daniel,  ODANAL\n  brown sr,  BRAN\nbrowne III,  BRAN\n browne IV,  BRAN\n  O'Banion,  OBANAN\nMclaughlin,  MCLAGL[AN]\n McCormack,  MCARNA[C]\n   Chapman,  CAPNAN\n     Silva,  SALV\n  McDonald,  MCDANA[LD]\n    Lawson,  LASAN\n    Jacobs,  JACAB\n    Greene,  GRAN\n   O'Brien,  OBRAN\n  Morrison,  MARASA[N]\n    Larson,  LARSAN\n    Willis,  WAL\n Mackenzie,  MCANSY\n      Carr,  CAR\n  Lawrence,  LARANC\n  Matthews,  MAT\n  Richards,  RACARD\n    Bishop,  BASAP\n  Franklin,  FRANCL[AN]\n  McDaniel,  MCDANA[L]\n    Harper,  HARPAR\n     Lynch,  LYNC\n   Watkins,  WATCAN\n   Carlson,  CARLSA[N]\n   Wheeler,  WALAR\n Louis XVI,  L\n\n```"}]}
{"messages": [{"role": "user", "content": "For this task, for our purposes, a cuboid is a 3 dimensional object, with six rectangular faces, where all angles are right angles, opposite faces of the cuboid are equal, and where each dimension is a positive integer unit length. It will subsequently be referred to simply as a cuboid; but be aware that it references the above definition.\n\nThe surface area of a cuboid is two times the length times the width, plus two times the length times the height, plus two times the width times the height. A cuboid will always have an even integer surface area. The minimum surface area a cuboid may have is 6; one where the **l**, **w**, and **h** measurements are all **1**.\n\n```\n  2 × ( l × w + w × h + h × l )\n  2 × ( 1 × 1 + 1 × 1 + 1 × 1 ) = 6\n\n```\n\nDifferent cuboid configurations (may) yield different surface areas, but the surface area is always an integer and is always even.\n\nA cuboid with l = 2, w = 1 h = 1 has a surface area of 10\n\n```\n  2 × ( 2 × 1 + 1 × 1 + 1 × 2 ) = 10\n\n```\n\nThere is no configuration which will yield a surface area of 8.\n\nThere are 16 known even integer values below 1000 which can not be a surface area for any integer cuboid. It is conjectured, though not rigorously proved, that no others exist.\n\nTask\n\n* Find and display the sixteen even integer values larger than 6 (the minimum cuboid area) and less than 1000\n\nthat can not be the surface area of a cuboid.\n\nSee also\n\n* Numbers Aplenty - O'Halloran numbers * OEIS:A072843 - O'Halloran numbers: even integers which cannot be the surface area of a cuboid with integer-length sides * Idoneal numbers"}, {"role": "assistant", "content": "```\nmy @Area;\n\nmy $threshold = 1000; # a little overboard to make sure we get them all\n\nfor 1..$threshold -> $x {\n    for 1..$x -> $y {\n        last if $x × $y > $threshold;\n        for 1..$y -> $z {\n           push @Area[my $area = ($x × $y + $y × $z + $z × $x) × 2], \"$x,$y,$z\";\n           last if $area > $threshold;\n        }\n    }\n}\n\nsay \"Even integer surface areas NOT achievable by any regular, integer dimensioned cuboid:\\n\" ~\n   @Area[^$threshold].kv.grep( { $^key > 6 and $key %% 2 and !$^value } )»[0];\n\n```\n\nOutput:\n\n```\nEven integer surface areas NOT achievable by any regular, integer dimensioned cuboid:\n8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924\n```"}]}
{"messages": [{"role": "user", "content": "Create a set of data types based upon inheritance. Each data type or class should have a print command that displays the contents of an instance of that class to standard output. Create instances of each class in your inheritance hierarchy and display them to standard output. Write each of the objects to a file named *objects.dat* in binary form using serialization or marshalling. Read the file *objects.dat* and print the contents of each serialized object."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# Reference:\n# https://docs.raku.org/language/classtut\n# https://github.com/teodozjan/perl-store\n\nuse v6;\nuse PerlStore::FileStore;\n\nclass Point {\n    has Int $.x;\n    has Int $.y;\n}\n\nclass Rectangle does  FileStore {\n    has Point $.lower;\n    has Point $.upper;\n\n    method area() returns Int {\n        ($!upper.x - $!lower.x) * ( $!upper.y - $!lower.y);\n    }\n}\n\nmy $r1 = Rectangle.new(lower => Point.new(x => 0, y => 0),\n                      upper => Point.new(x => 10, y => 10));\nsay \"Create Rectangle1 with area \",$r1.area();\nsay \"Serialize Rectangle1 to object.dat\";\n$r1.to_file('./objects.dat');\nsay \"\";\nsay \"take a peek on object.dat ..\";\nsay slurp \"./objects.dat\";\nsay \"\";\nsay \"Deserialize to Rectangle2\";\nmy $r2 = from_file('objects.dat');\nsay \"Rectangle2 is of type \", $r2.WHAT;\nsay \"Rectangle2 area is \", $r2.area();\n\n```\n\nOutput:\n\n```\nCreate Rectangle1 with area 100\nSerialize Rectangle1 to object.dat\n\ntake a peek on object.dat ..\nRectangle.new(lower => Point.new(x => 0, y => 0), upper => Point.new(x => 10, y => 10))\n\n\nDeserialize to Rectangle2\nRectangle2 is of type (Rectangle)\nRectangle2 area is 100\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind odd and square numbers (>99) under **1.000**"}, {"role": "assistant", "content": "Vote for deletion: trivial. But if we gotta keep it, at least make it *slightly* interesting.\n\n```\nfor 1..5 {\n    my $max = exp $_, 10;\n    put \"\\n{+$_} odd squares from {$max / 10} to $max:\\n{ .batch(10).join: \"\\n\" }\"\n    given ({(2 × $++ + 1)²} … * > $max).grep: $max / 10 ≤ * ≤ $max\n}\n\n```\n\nOutput:\n\n```\n2 odd squares from 1 to 10:\n1 9\n\n3 odd squares from 10 to 100:\n25 49 81\n\n11 odd squares from 100 to 1000:\n121 169 225 289 361 441 529 625 729 841\n961\n\n34 odd squares from 1000 to 10000:\n1089 1225 1369 1521 1681 1849 2025 2209 2401 2601\n2809 3025 3249 3481 3721 3969 4225 4489 4761 5041\n5329 5625 5929 6241 6561 6889 7225 7569 7921 8281\n8649 9025 9409 9801\n\n108 odd squares from 10000 to 100000:\n10201 10609 11025 11449 11881 12321 12769 13225 13689 14161\n14641 15129 15625 16129 16641 17161 17689 18225 18769 19321\n19881 20449 21025 21609 22201 22801 23409 24025 24649 25281\n25921 26569 27225 27889 28561 29241 29929 30625 31329 32041\n32761 33489 34225 34969 35721 36481 37249 38025 38809 39601\n40401 41209 42025 42849 43681 44521 45369 46225 47089 47961\n48841 49729 50625 51529 52441 53361 54289 55225 56169 57121\n58081 59049 60025 61009 62001 63001 64009 65025 66049 67081\n68121 69169 70225 71289 72361 73441 74529 75625 76729 77841\n78961 80089 81225 82369 83521 84681 85849 87025 88209 89401\n90601 91809 93025 94249 95481 96721 97969 99225\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nOdd numbers of the form p\\*q where p and q are distinct primes, where **p\\*q < 1000**\n\nSee also\n:   * OEIS:A046388"}, {"role": "assistant", "content": "```\nsay (3..333).grep(*.is-prime).combinations(2).map( { next if (my $p = [*] $_) > 999; $p } ).flat\\\n    .sort.batch(20)».fmt('%3d').join: \"\\n\";\n\n```\n\nOutput:\n\n```\n 15  21  33  35  39  51  55  57  65  69  77  85  87  91  93  95 111 115 119 123\n129 133 141 143 145 155 159 161 177 183 185 187 201 203 205 209 213 215 217 219\n221 235 237 247 249 253 259 265 267 287 291 295 299 301 303 305 309 319 321 323\n327 329 335 339 341 355 365 371 377 381 391 393 395 403 407 411 413 415 417 427\n437 445 447 451 453 469 471 473 481 485 489 493 497 501 505 511 515 517 519 527\n533 535 537 543 545 551 553 559 565 573 579 581 583 589 591 597 611 623 629 633\n635 649 655 667 669 671 679 681 685 687 689 695 697 699 703 707 713 717 721 723\n731 737 745 749 753 755 763 767 771 779 781 785 789 791 793 799 803 807 813 815\n817 831 835 843 849 851 865 869 871 879 889 893 895 899 901 905 913 917 921 923\n933 939 943 949 951 955 959 965 973 979 985 989 993 995\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program that solves the odd word problem with the restrictions given below.\n\nDescription\n\nYou are promised an input stream consisting of English letters and punctuations.\n\nIt is guaranteed that:\n\n* the words (sequence of consecutive letters) are delimited by one and only one punctuation,\n* the stream will begin with a word,\n* the words will be at least one letter long,   and\n* a full stop (a period, [**.**]) appears after, and only after, the last word.\n\nExample\n\nA stream with six words:\n\n:   :   `what,is,the;meaning,of:life.`\n\nThe task is to reverse the letters in every other word while leaving punctuations intact, producing:\n\n:   :   `what,si,the;gninaem,of:efil.`\n\nwhile observing the following restrictions:\n\n1. Only I/O allowed is reading or writing one character at a time, which means: no reading in a string, no peeking ahead, no pushing characters back into the stream, and no storing characters in a global variable for later use;\n2. You **are not** to explicitly save characters in a collection data structure, such as arrays, strings, hash tables, etc, for later reversal;\n3. You **are** allowed to use recursions, closures, continuations, threads, co-routines, etc., even if their use implies the storage of multiple characters.\n\nTest cases\n\nWork on both the   \"life\"   example given above, and also the text:\n\n:   :   `we,are;not,in,kansas;any,more.`"}, {"role": "assistant", "content": "(formerly Perl 6)\nA recursive solution, with the added feature that it treats each line separately.\n\n```\nmy &in = { $*IN.getc // last }\n\nloop {\n    ew(in);\n    ow(in).print;\n}\n\nmulti ew ($_ where /\\w/) { .print; ew(in); }\nmulti ew ($_)            { .print; next when \"\\n\"; }\n\nmulti ow ($_ where /\\w/) { ow(in) x .print; }\nmulti ow ($_)            { $_; }\n\n```\n\nOutput:\n\n```\n$ ./oddword\nwe,are;not,in,kansas;any,more.\nwe,era;not,ni,kansas;yna,more.\nwhat,is,the;meaning,of:life.\nwhat,si,the;gninaem,of:efil.\n```\n\nNote how the even/oddness is reset on the line boundary; if not, the second line might have started out in an odd state and reversed \"what\" instead of \"is\". The call to next prevents that by sending the loop back to its initial state.\n\nThere is one clever trick here with the x operator; it evaluates both its arguments in order, but in this case only returns the left argument because the right one is always 1 (True). You can think of it as a reversed C-style comma operator."}]}
{"messages": [{"role": "user", "content": "Given a list of words, (use the words from the dictionary unixdict.txt).\n\nTake the letters at odd indices letters from each word. If the result is present in the list, then display the result.\nThe length of the *odd word* should be **>   4**.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nmy %words = 'unixdict.txt'.IO.slurp.words.map: * => 1;\n\nmy (@odds, @evens);\n\nfor %words {\n    next if .key.chars < 9;\n    my $odd  = .key.comb[0,2 … *].join;\n    @odds.push(.key => $odd) if %words{$odd} and $odd.chars > 4;\n    my $even = .key.comb[1,3 … *].join;\n    @evens.push(.key => $even) if %words{$even} and $even.chars > 4;\n}\n\n.put for flat 'Odd words > 4:', @odds.sort;\n\n.put for flat \"\\nEven words > 4:\", @evens.sort;\n\n```\n\nOutput:\n\n```\nOdd words > 4:\nbarbarian\tbrain\nchildbear\tcider\ncorrigenda\tcried\ngargantuan\tgrata\nheaddress\thades\npalladian\tplain\npropionate\tpoint\nsalvation\tslain\nsiltation\tslain\nslingshot\tsight\nstatuette\tsaute\nsupersede\tspree\nsupervene\tspree\nterminable\ttrial\n\nEven words > 4:\ncannonball\tannal\nimportation\tmotto\npsychopomp\tscoop\nstarvation\ttrain\nupholstery\tposey\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nPresent a program which emits the lyrics to the song   *I Knew an Old Lady Who Swallowed a Fly*,   taking advantage of the repetitive structure of the song's lyrics.\n\nThis song has multiple versions with slightly different lyrics, so all these programs might not emit identical output.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @victims =\n    fly    => \"  I don't know why S—\",\n    spider => \"  That wriggled and jiggled and tickled inside her.\",\n    bird   => \"  How absurd, T!\",\n    cat    => \"  Fancy that, S!\",\n    dog    => \"  What a hog, T!\",\n    goat   => \"  She just opened her throat, and in walked the goat!\",\n    cow    => \"  I don't know how S!\",\n    horse  => \"  She's dead, of course...\";\n\nmy @history = \"I guess she'll die...\\n\";\n\nfor (flat @victims».kv) -> $victim, $_ is copy {\n    say \"There was an old lady who swallowed a $victim...\";\n\n    s/ «S» /she swallowed the $victim/;\n    s/ «T» /to swallow a $victim!/;\n    .say;\n    last when /dead/;\n\n    @history[0] ~~ s/^X/She swallowed the $victim/;\n    .say for @history;\n    @history.unshift($_) if @history < 5;\n    @history.unshift(\"X to catch the $victim,\");\n}\n\n```\n\nAnd that's how I larned it!"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program to perform a conversion of the old Russian measures of length to the metric system   (and vice versa).\n\nIt is an example of a linear transformation of several variables.\n\nThe program should accept a single value in a selected unit of measurement, and convert and return it to the other units:\n  \n*vershoks*, *arshins*, *sazhens*, *versts*, *meters*, *centimeters* and *kilometers*.\n\nAlso see\n:   * Old Russian measure of length"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015.12\n\nFairly straightfoward. Define a hash of conversion factors then apply them. Makes no attempt to do correct pluralization because I have no idea what the correct plurals are and little interest in researching them. Conversion factors from Wikipedia: Obsolete Russian units of measurement.\n\n```\nconvert(1, 'meter');\n\nsay '*' x 40, \"\\n\";\n\nconvert(1, 'milia');\n\nsub convert (Real $magnitude, $unit) {\n     my %factor = \n        tochka     => 0.000254,\n        liniya     => 0.00254,\n        diuym      => 0.0254,\n        vershok    => 0.04445,\n        piad       => 0.1778,\n        fut        => 0.3048,\n        arshin     => 0.7112,\n        sazhen     => 2.1336,\n        versta     => 1066.8,\n        milia      => 7467.6,\n        centimeter => 0.01,\n        meter      => 1.0,\n        kilometer  => 1000.0,\n    ;\n\n    my $meters = $magnitude * %factor{$unit.lc};\n\n    say \"$magnitude $unit to:\\n\", '_' x 40;\n\n    printf \"%10s: %s\\n\", $_,  $meters / %factor{$_} unless $_ eq $unit.lc\n      for %factor.keys.sort:{ +%factor{$_} }\n}\n\n```\n\n```\n1 meter to:\n________________________________________\n    tochka: 3937.007874\n    liniya: 393.700787\ncentimeter: 100\n     diuym: 39.370079\n   vershok: 22.497188\n      piad: 5.624297\n       fut: 3.280840\n    arshin: 1.406074\n    sazhen: 0.468691\n kilometer: 0.001\n    versta: 0.000937\n     milia: 0.000134\n****************************************\n\n1 milia to:\n________________________________________\n    tochka: 29400000\n    liniya: 2940000\ncentimeter: 746760\n     diuym: 294000\n   vershok: 168000\n      piad: 42000\n       fut: 24500\n    arshin: 10500\n     meter: 7467.6\n    sazhen: 3500\n kilometer: 7.4676\n    versta: 7\n\n```"}]}
{"messages": [{"role": "user", "content": "A method of choosing a line randomly from a file:\n\n:   :   * Without reading the file more than once\n        * When substantial parts of the file cannot be held in memory\n        * Without knowing how many lines are in the file\n\nIs to:\n\n:   :   * keep the first line of the file as a possible choice, then\n        * Read the second line of the file if possible and make it the possible choice if a uniform random value between zero and one is less than 1/2.\n        * Read the third line of the file if possible and make it the possible choice if a uniform random value between zero and one is less than 1/3.\n        * ...\n        * Read the Nth line of the file if possible and make it the possible choice if a uniform random value between zero and one is less than 1/N\n\n:   :   * Return the computed possible choice when no further lines exist in the file.\n\nTask\n\n1. Create a function/method/routine called `one_of_n` that given `n`, the number of actual lines in a file, follows the algorithm above to return an integer - the line number of the line chosen from the file.   \n   The number returned can vary, randomly, in each run.\n2. Use `one_of_n` in a *simulation* to find what would be the chosen line of a 10-line file simulated 1,000,000 times.\n3. Print and show how many times each of the 10 lines is chosen as a rough measure of how well the algorithm works.\n\nNote: You may choose a smaller number of repetitions if necessary, but mention this up-front.\n\nNote: This is a specific version of a Reservoir Sampling algorithm: https://en.wikipedia.org/wiki/Reservoir\\_sampling"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n```\nsub one_of_n($n) {\n    my $choice;\n    $choice = $_ if .rand < 1 for 1 .. $n;\n    $choice - 1;\n}\n\nsub one_of_n_test($n = 10, $trials = 1_000_000) {\n    my @bins;\n    @bins[one_of_n($n)]++ for ^$trials;\n    @bins;\n}\n\nsay one_of_n_test();\n\n```\n\nOutput:\n\n```\n100288 100047 99660 99773 100256 99633 100161 100483 99789 99910\n```"}]}
{"messages": [{"role": "user", "content": "Assume an array of cells with an initial distribution of live and dead cells,\nand imaginary cells off the end of the array having fixed values.\n\nCells in the next generation of the array are calculated based on the value of the cell and its left and right nearest neighbours in the current generation.\n\nIf, in the following table, a live cell is represented by 1 and a dead cell by 0 then to generate the value of the cell at a particular index in the array of cellular values you use the following table:\n\n```\n000 -> 0  # \n001 -> 0  #\n010 -> 0  # Dies without enough neighbours\n011 -> 1  # Needs one neighbour to survive\n100 -> 0  #\n101 -> 1  # Two neighbours giving birth\n110 -> 1  # Needs one neighbour to survive\n111 -> 0  # Starved to death.\n\n```\n\nRelated tasks\n\n* Elementary cellular automaton"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2014-02-27\n\nWe'll make a general algorithm capable of computing any cellular automata\nas defined by Stephen Wolfram's\nfamous book *A new kind of Science*.\nWe will take the liberty of wrapping the array of cells\nas it does not affect the result much\nand it makes the implementation a lot easier.\n\n```\nclass Automaton {\n    has $.rule;\n    has @.cells;\n    has @.code = $!rule.fmt('%08b').flip.comb».Int;\n \n    method gist { \"|{ @!cells.map({+$_ ?? '#' !! ' '}).join }|\" }\n \n    method succ {\n        self.new: :$!rule, :@!code, :cells( \n            @!code[\n                    4 «*« @!cells.rotate(-1)\n                »+« 2 «*« @!cells\n                »+«       @!cells.rotate(1)\n            ]\n        )\n    }\n}\n\n#  The rule proposed for this task is rule 0b01101000 = 104\n\nmy @padding = 0 xx 5;\nmy Automaton $a .= new:\n    rule  => 104,\n    cells => flat @padding, '111011010101'.comb, @padding\n;\nsay $a++ for ^10;\n\n\n# Rule 104 is not particularly interesting so here is [[wp:Rule 90|Rule 90]], \n# which shows a [[wp:Sierpinski Triangle|Sierpinski Triangle]].\n\nsay '';\n@padding = 0 xx 25;\n$a = Automaton.new: :rule(90), :cells(flat @padding, 1, @padding);\n \nsay $a++ for ^20;\n\n```\n\nOutput:\n\n```\n|     ### ## # # #     |\n|     # ##### # #      |\n|      ##   ## #       |\n|      ##   ###        |\n|      ##   # #        |\n|      ##    #         |\n|      ##              |\n|      ##              |\n|      ##              |\n|      ##              |\n\n|                         #                         |\n|                        # #                        |\n|                       #   #                       |\n|                      # # # #                      |\n|                     #       #                     |\n|                    # #     # #                    |\n|                   #   #   #   #                   |\n|                  # # # # # # # #                  |\n|                 #               #                 |\n|                # #             # #                |\n|               #   #           #   #               |\n|              # # # #         # # # #              |\n|             #       #       #       #             |\n|            # #     # #     # #     # #            |\n|           #   #   #   #   #   #   #   #           |\n|          # # # # # # # # # # # # # # # #          |\n|         #                               #         |\n|        # #                             # #        |\n|       #   #                           #   #       |\n|      # # # #                         # # # #      |\n\n```"}]}
{"messages": [{"role": "user", "content": "Implement a One-time pad, for encrypting and decrypting messages.  \nTo keep it simple, we will be using letters only.\n\nSub-Tasks\n\n* **Generate** the data for a One-time pad (user needs to specify a filename and length)\n\n:   The important part is to get \"true random\" numbers, e.g. from /dev/random\n\n* **encryption / decryption** ( basically the same operation, much like Rot-13 )\n\n:   For this step, much of Vigenère cipher could be reused,  \n    with the key to be read from the file containing the One-time pad.\n\n* optional: **management** of One-time pads: list, mark as used, delete, etc.\n\n:   Somehow, the users needs to keep track which pad to use for which partner.\n\nTo support the management of pad-files:\n\n* Such files have a file-extension \".1tp\"\n* Lines starting with \"#\" may contain arbitary meta-data (i.e. comments)\n* Lines starting with \"-\" count as \"used\"\n* Whitespace within the otp-data is ignored\n\nFor example, here is the data from Wikipedia:\n\n```\n# Example data - Wikipedia - 2014-11-13\n-ZDXWWW EJKAWO FECIFE WSNZIP PXPKIY URMZHI JZTLBC YLGDYJ \n-HTSVTV RRYYEG EXNCGA GGQVRF FHZCIB EWLGGR BZXQDQ DGGIAK \n YHJYEQ TDLCQT HZBSIZ IRZDYS RBYJFZ AIRCWI UCVXTW YKPQMK \n CKHVEX VXYVCS WOGAAZ OUVVON GCNEVR LMBLYB SBDCDC PCGVJX \n QXAUIP PXZQIJ JIUWYH COVWMJ UZOJHL DWHPER UBSRUJ HGAAPR \n CRWVHI FRNTQW AJVWRT ACAKRD OZKIIB VIQGBK IJCWHF GTTSSE \n EXFIPJ KICASQ IOUQTP ZSGXGH YTYCTI BAZSTN JKMFXI RERYWE \n\n```\n\nSee also\n\n* one time pad encryption in Python\n* snapfractalpop - One-Time-Pad Command-Line-Utility (C).\n* Crypt-OTP-2.00 on CPAN (Perl)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.10\n\nThe task is somewhat under-specified, especially the third (optional) section so I'm skipping that for now. Each sub-task has it's own code.\n\n**Sub-task one:** generate one-time-pad files.\n\nThis is a fairly basic otp file generator. Uses Crypt::Random for decently high quality random numbers. (Random bytes are drawn from /dev/urandom on Unix-like systems, and CryptGenRandom() on Windows.) It will ask for a file name to save to, and the number of lines you want. Each line can be used to encode up to 48 characters of data. Default is 1000 lines, Only generating 4 lines here for demonstration purposes. Saving the file to 'rosettacode.1tp'.\n\n```\nsub MAIN {\n    put \"Generate data for one time pad encryption.\\n\" ~\n        \"File will have .1tp extension.\";\n    my $fn;\n    loop {\n        $fn = prompt 'Filename for one time pad data: ';\n        if $fn !~~ /'.1tp' $/ { $fn ~= '.1tp' }\n        if $fn.IO.e {\n            my $ow = prompt \"$fn aready exists, over-write? y/[n] \";\n            last if $ow ~~ m:i/'y'/;\n            redo;\n        }\n        last;\n    }\n\n    put 'Each line will contain 48 characters of encyption data.';\n    my $lines = prompt 'How many lines of data to generate? [1000] ';\n    $lines ||= 1000;\n    generate($fn, $lines);\n    say \"One-time-pad data saved to: \", $fn.IO.absolute;\n\n    sub generate ( $fn, $lines) {\n        use Crypt::Random;\n        $fn.IO.spurt: \"# one-time-pad encryption data\\n\" ~\n          ((sprintf(\" %s %s %s %s %s %s %s %s\\n\",\n          ((('A'..'Z')[crypt_random_uniform(26)] xx 6).join) xx 8))\n          xx $lines).join;\n    }\n}\n\n```\n\nOutput:\n\n```\nGenerate data for one time pad encryption.\nFile wile have .1tp extension.\nFilename for one time pad data: rosettacode\nEach line will contain 48 characters of encyption data.\nHow many lines of data to generate? [1000] 4\nOne-time-pad data saved to: /home/myhome/mydirectory/rosettacode.1tp\n\n```\n\nSample file generated by above code:\n\n```\n# one-time-pad encryption data\n DSUJOU UUWDZD VHFWRR AJDMDC ERZDGD WWKLHJ YITCML FORXCV\n BXGFCL ANGCGY VTAEUG UYAIPK FXWMNI INDLOR JIDZQL BOFFQD\n JISNOS CMLRPW TFGELQ HPTMRN SHBBDP AIVDAC CEWIFH TRLQVK\n FRBUUC GDCQHQ CEEURS RGVWVT JZIQLP NQCABF BWUPUI UDTZAF\n```\n\n**Sub-task two:** encrypt/decrypt text using the otp files generated by part one.\n\nOne-time-pad encryption gets it's security from the fact that the pads are used **one time**. As a line is used in the otp file, it needs to be marked as used, or removed so it doesn't get reused. Theoretically, you would make a copy of rosettacode.1tp and send it by secure means to the receiver of your encrypted text so that they can use it to decrypt. Since we are encrypting and decrypting on the same computer, we'll make a copy of the otp file named rosettacopy.1tp and use that for decryption so the encrypt and decrypt functions don't conflict.\n\n```\nsub s2v ($s) { $s.uc.comb(/ <[ A..Z ]> /)».ord »-» 65 }\nsub v2s (@v) { (@v »%» 26 »+» 65)».chr.join }\n\nsub hide   ($secret, $otp) { v2s(s2v($secret) »+» s2v($otp)) }\nsub reveal ($hidden, $otp) { v2s(s2v($hidden) »-» s2v($otp)) }\n\nsub otp-data ($fn, $lines) {\n    my $fh = $fn.IO.open :rw;\n    my $data;\n    my $count = 0;\n    repeat {\n        my $pos = $fh.tell;\n        my $line = $fh.get;\n        if $line.substr(0,1) ne '-'|'#' {\n            $data ~= $line;\n            $fh.seek($pos);\n            $fh.put: '-' ~ $line.substr(1);\n            $count++;\n        }\n    } until $count == $lines or $fh.eof;\n    note \"Insufficient lines of data remaining in $fn\" if $count != $lines;\n    $data;\n}\n\nsub otp-size (Str $string) { ceiling $string.uc.comb(/ <[ A..Z ]> /) / 48 }\n\nsub otp-encrypt ( $secret, $fn ) {\n    my $otp-size = otp-size $secret;\n    my $otp-data = otp-data($fn, $otp-size);\n    my $encrypted = hide $secret, $otp-data;\n    # pad encryted text out to a full line with random text\n    $encrypted ~= ('A'..'Z').roll while $encrypted.chars % 48;\n    join \"\\n\", $encrypted.comb(6).rotor(8, :partial).map:\n      { sprintf \"{ join ' ', \"%s\" xx $_ }\", $_ };\n}\n\nsub otp-decrypt ( $secret, $fn ) {\n    my $otp-size = otp-size $secret;\n    my $otp-data = otp-data($fn, $otp-size);\n    my $plain-text = reveal $secret, $otp-data;\n    join \"\\n\", $plain-text.comb(6).rotor(8, :partial).map:\n      { sprintf \"{ join ' ', \"%s\" xx $_ }\", $_ };\n}\n\nmy $otp-encrypt-fn = 'rosettacode.1tp';\nmy $otp-decrypt-fn = 'rosettacopy.1tp';\n\nmy $secret = \"Beware the Jabberwock, my son! The jaws that bite, the claws that catch!\";\n\nsay \"Secret:\\n$secret\\n\\nEncrypted:\";\nsay my $encrypted =   otp-encrypt $secret,    $otp-encrypt-fn;\nsay \"\\nDecrypted:\\n\", otp-decrypt $encrypted, $otp-decrypt-fn;\n\n```\n\nOutput:\n\n```\nSecret:\nBeware the Jabberwock, my son! The jaws that bite, the claws that catch!\n\nEncrypted:\nEWQJFY NBAMZE WLWSFT KVBERP XYDMGZ OPRLAK GBXVTP HZRTUO\nIXZHCE CUUORL THOFDI DCXRLG JQICPI ZEREHP RLOEAE PRMVJH\n\nDecrypted:\nBEWARE THEJAB BERWOC KMYSON THEJAW STHATB ITETHE CLAWST\nHATCAT CHOMLN YOOBJC JEXJWW ETMQCA RROTTY IDLFKT ODHQTE\n```\n\nContents of rosettacode.1tp after encryption / rosettacopy.1tp after decryption:\n\n```\n# one-time-pad encryption data\n-DSUJOU UUWDZD VHFWRR AJDMDC ERZDGD WWKLHJ YITCML FORXCV\n-BXGFCL ANGCGY VTAEUG UYAIPK FXWMNI INDLOR JIDZQL BOFFQD\n JISNOS CMLRPW TFGELQ HPTMRN SHBBDP AIVDAC CEWIFH TRLQVK\n FRBUUC GDCQHQ CEEURS RGVWVT JZIQLP NQCABF BWUPUI UDTZAF\n```"}]}
{"messages": [{"role": "user", "content": "Generate the sequence **an** where each term in **a** is the smallest **n** digit prime number *(in base 10)* composed entirely of the digits **1** and **2**.\n\nIt is conjectured, though not proven, that a conforming prime exists for all **n**. No counter examples have been found up to several thousand digits.\n\nTask\n\n* Find and show here, the first **20** elements in the sequence (from **1** digit through **20** digits), or as many as reasonably supported by your language if it is fewer.\n\nStretch\n\n* Find and and show the abbreviated values for the elements with **n** equal to **100** through **2000** in increments of **100**.\n\n:   Shorten the displayed number by replacing any leading **1**s in the number with the count of **1**s, and show the remainder of the number. *(See Raku example for reference)*\n\nSee also\n\n* OEIS:A036229 - Smallest n-digit prime containing only digits 1 or 2 or -1 if no such prime exists"}, {"role": "assistant", "content": "### Task specific\n\n```\nsub condense ($n) { my $i = $n.index(2); $i ?? \"(1 x $i) {$n.substr($i)}\" !! $n }\n\nsub onetwo ($d, $s='') { take $s and return unless $d; onetwo($d-1,$s~$_) for 1,2 }\n\nsub get-onetwo ($d) { (gather onetwo $d).hyper.grep(&is-prime)[0] }\n\nprintf \"%4d: %s\\n\", $_, get-onetwo($_) for 1..20;\nprintf \"%4d: %s\\n\", $_, condense get-onetwo($_) for (1..20) »×» 100;\n\n```\n\nOutput:\n\n```\n   1: 2\n   2: 11\n   3: 211\n   4: 2111\n   5: 12211\n   6: 111121\n   7: 1111211\n   8: 11221211\n   9: 111112121\n  10: 1111111121\n  11: 11111121121\n  12: 111111211111\n  13: 1111111121221\n  14: 11111111112221\n  15: 111111112111121\n  16: 1111111112122111\n  17: 11111111111112121\n  18: 111111111111112111\n  19: 1111111111111111111\n  20: 11111111111111212121\n 100: (1 x 92) 21112211\n 200: (1 x 192) 21112211\n 300: (1 x 288) 211121112221\n 400: (1 x 390) 2111122121\n 500: (1 x 488) 221222111111\n 600: (1 x 590) 2112222221\n 700: (1 x 689) 21111111111\n 800: (1 x 787) 2122222221111\n 900: (1 x 891) 222221221\n1000: (1 x 988) 222122111121\n1100: (1 x 1087) 2112111121111\n1200: (1 x 1191) 211222211\n1300: (1 x 1289) 22121221121\n1400: (1 x 1388) 222211222121\n1500: (1 x 1489) 21112121121\n1600: (1 x 1587) 2121222122111\n1700: (1 x 1688) 212121211121\n1800: (1 x 1791) 221211121\n1900: (1 x 1889) 22212212211\n2000: (1 x 1989) 22121121211\n```\n\n### Generalized\n\nThis version will do the task requirements, but will also find (without modification):\n\n* OEIS:A036929 - Smallest n digit prime using only 0 and 1 (or '0' if none exists)\n* OEIS:A036229 - Smallest n digit prime using only 1 and 2 (or '0' if none exists) <-- The task\n* OEIS:A036930 - Smallest n digit prime using only 1 and 3 (or '0' if none exists)\n* OEIS:A036931 - Smallest n digit prime using only 1 and 4 (or '0' if none exists)\n* OEIS:A036932 - Smallest n digit prime using only 1 and 5 (or '0' if none exists)\n* OEIS:A036933 - Smallest n digit prime using only 1 and 6 (or '0' if none exists)\n* OEIS:A036934 - Smallest n digit prime using only 1 and 7 (or '0' if none exists)\n* OEIS:A036935 - Smallest n digit prime using only 1 and 8 (or '0' if none exists)\n* OEIS:A036936 - Smallest n digit prime using only 1 and 9 (or '0' if none exists)\n* OEIS:A036937 - Smallest n digit prime using only 2 and 3 (or '0' if none exists)\n* OEIS:A036938 - Smallest n digit prime using only 2 and 7 (or '0' if none exists)\n* OEIS:A036939 - Smallest n digit prime using only 2 and 9 (or '0' if none exists)\n* OEIS:A036940 - Smallest n digit prime using only 3 and 4 (or '0' if none exists)\n* OEIS:A036941 - Smallest n digit prime using only 3 and 5 (or '0' if none exists)\n* OEIS:A036942 - Smallest n digit prime using only 3 and 7 (or '0' if none exists)\n* OEIS:A036943 - Smallest n digit prime using only 3 and 8 (or '0' if none exists)\n* OEIS:A036944 - Smallest n digit prime using only 4 and 7 (or '0' if none exists)\n* OEIS:A036945 - Smallest n digit prime using only 4 and 9 (or '0' if none exists)\n* OEIS:A036946 - Smallest n digit prime using only 5 and 7 (or '0' if none exists)\n* OEIS:A036947 - Smallest n digit prime using only 5 and 9 (or '0' if none exists)\n* OEIS:A036948 - Smallest n digit prime using only 6 and 7 (or '0' if none exists)\n* OEIS:A036949 - Smallest n digit prime using only 7 and 8 (or '0' if none exists)\n* OEIS:A036950 - Smallest n digit prime using only 7 and 9 (or '0' if none exists)\n* OEIS:A036951 - Smallest n digit prime using only 8 and 9 (or '0' if none exists)\n\nReally, the only one that is a little tricky is the first one (0,1). That one required some specialized logic. All of the rest would work with the task specific version with different hard coded digits.\n\nLimited the stretch to keep the run time reasonable. Finishes all in around 12 seconds on my system.\n\n```\nfor 929,(0,1),229,(1,2),930,(1,3),931,(1,4),932,(1,5),933,(1,6),934,(1,7),935,(1,8),\n    936,(1,9),937,(2,3),938,(2,7),939,(2,9),940,(3,4),941,(3,5),942,(3,7),943,(3,8),\n    944,(4,7),945,(4,9),946,(5,7),947,(5,9),948,(6,7),949,(7,8),950,(7,9),951,(8,9)\n  -> $oeis, $pair {\n\n    say \"\\nOEIS:A036{$oeis} - Smallest n digit prime using only {$pair[0]} and {$pair[1]} (or '0' if none exists):\";\n\n    sub condense ($n) { $n.subst(/(.) {} :my $repeat=$0; ($repeat**{9..*})/, -> $/ {\"($0 x {1+$1.chars}) \"}) }\n\n    sub build ($digit, $sofar='') { take $sofar and return unless $digit; build($digit-1,$sofar~$_) for |$pair }\n\n    sub get-prime ($digits) {\n        ($pair[0] ?? (gather build $digits).first: &is-prime\n        !! (gather build $digits-1, $pair[1]).first: &is-prime\n        ) // 0\n    }\n\n    printf \"%4d: %s\\n\", $_, condense .&get-prime for flat 1..20, 100, 200;\n}\n\n```\n\nOutput:\n\n```\nOEIS:A036929 - Smallest n digit prime using only 0 and 1 (or '0' if none exists):\n   1: 0\n   2: 11\n   3: 101\n   4: 0\n   5: 10111\n   6: 101111\n   7: 1011001\n   8: 10010101\n   9: 100100111\n  10: 1000001011\n  11: 10000001101\n  12: 100000001111\n  13: 1000000111001\n  14: 10000000001011\n  15: 100000000100101\n  16: 1(0 x 10) 11101\n  17: 1(0 x 12) 1101\n  18: 1(0 x 11) 100111\n  19: 1(0 x 13) 10011\n  20: 1(0 x 12) 1100101\n 100: 1(0 x 93) 101101\n 200: 1(0 x 189) 1110101011\n\nOEIS:A036229 - Smallest n digit prime using only 1 and 2 (or '0' if none exists):\n   1: 2\n   2: 11\n   3: 211\n   4: 2111\n   5: 12211\n   6: 111121\n   7: 1111211\n   8: 11221211\n   9: 111112121\n  10: 1111111121\n  11: 11111121121\n  12: 111111211111\n  13: 1111111121221\n  14: (1 x 10) 2221\n  15: 111111112111121\n  16: 1111111112122111\n  17: (1 x 13) 2121\n  18: (1 x 14) 2111\n  19: (1 x 19) \n  20: (1 x 14) 212121\n 100: (1 x 92) 21112211\n 200: (1 x 192) 21112211\n\n\n... many lines manually omitted ...\n\n\nOEIS:A036950 - Smallest n digit prime using only 7 and 9 (or '0' if none exists):\n   1: 7\n   2: 79\n   3: 797\n   4: 0\n   5: 77797\n   6: 777977\n   7: 7777997\n   8: 77779799\n   9: 777777799\n  10: 7777779799\n  11: 77777779979\n  12: 777777779777\n  13: 7777777779977\n  14: (7 x 11) 977\n  15: (7 x 11) 9797\n  16: (7 x 11) 97799\n  17: (7 x 15) 97\n  18: (7 x 13) 97977\n  19: (7 x 16) 997\n  20: (7 x 16) 9997\n 100: (7 x 93) 9979979\n 200: (7 x 192) 99777779\n\nOEIS:A036951 - Smallest n digit prime using only 8 and 9 (or '0' if none exists):\n   1: 0\n   2: 89\n   3: 0\n   4: 8999\n   5: 89899\n   6: 888989\n   7: 8888989\n   8: 88888999\n   9: 888898889\n  10: 8888888989\n  11: 88888888999\n  12: 888888898999\n  13: 8888888999899\n  14: (8 x 13) 9\n  15: (8 x 10) 98999\n  16: (8 x 10) 989999\n  17: (8 x 16) 9\n  18: (8 x 13) 98889\n  19: (8 x 16) 989\n  20: (8 x 13) 9888989\n 100: (8 x 91) 998998889\n 200: (8 x 190) 9888898989\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay a smooth shaded triangle with OpenGL.\n\nTriangle created using C example compiled with GCC 4.1.2 and freeglut3."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\nAt this time there is not a publicly available OpenGL <-> Raku library, but it isn't too difficult to just call into the underlying C libraries. Here's a minimal example.\n\nIt's a little verbose since it is doing all of the setup and loading manually.\n\n```\nuse NativeCall;\n\nclass Window is repr('CPointer') {}\nclass Monitor is repr('CPointer') {}\n\n# GLFW\n\nconstant $lib = ('glfw', v3);\n\nsub glfwInit(--> int32) is native($lib) {*}\nsub glfwCreateWindow(int32, int32, Str, Monitor, Window --> Window) is native($lib) {*}\nsub glfwTerminate() is native($lib) {*}\nsub glfwMakeContextCurrent(Window) is native($lib) {*}\nsub glfwSetWindowShouldClose(Window, int32) is native($lib) {*}\nsub glfwWindowShouldClose(Window --> int32) is native($lib) {*}\nsub glfwSwapBuffers(Window) is native($lib) {*}\nsub glfwSwapInterval(int32) is native($lib) {*}\nsub glfwPollEvents() is native($lib) {*}\nsub glfwGetFramebufferSize(Window, int32 is rw, int32 is rw) is native($lib) {*}\n\n# OpenGL\n\nenum PrimitiveMode(\n  GL_TRIANGLES =>\t0x0004,\n);\n\nenum MatrixMode(\n  GL_MATRIX_MODE => 0x0BA0,\n  GL_MODELVIEW => 0x1700,\n  GL_PROJECTION => 0x1701,\n);\n\nconstant $gllib = 'GL';\n\nsub glViewport(int32, int32, int32, int32) is native($gllib) {*}\nsub glClear(int32) is native($gllib) {*}\nsub glMatrixMode(int32) is native($gllib) {*}\nsub glLoadIdentity() is native($gllib) {*}\nsub glOrtho(num64, num64, num64, num64, num64, num64) is native($gllib) {*}\nsub glRotatef(num32, num32, num32, num32) is native($gllib) {*}\nsub glBegin(int32) is native($gllib) {*}\nsub glColor3f(num32, num32, num32) is native($gllib) {*}\nsub glVertex3f(num32, num32, num32) is native($gllib) {*}\nsub glEnd() is native($gllib) {*}\n\nconstant GL_COLOR_BUFFER_BIT = 0x00004000;\n\ndie 'Failed to initialize GLFW' unless glfwInit().so;\n\nmy $w = glfwCreateWindow(640, 480, \"OpenGL Triangle\", Nil, Nil);\nwithout $w { glfwTerminate(); die 'Failed to create window' }\n\nglfwMakeContextCurrent($w);\nglfwSwapInterval(1);\n\nwhile not glfwWindowShouldClose($w) {\n    my num32 $ratio;\n    my int32 $width;\n    my int32 $height;\n\n    glfwGetFramebufferSize($w, $width, $height);\n    $ratio = ($width / $height).Num;\n\n    glViewport(0, 0, $width, $height);\n    glClear(GL_COLOR_BUFFER_BIT);\n\n    glMatrixMode(GL_PROJECTION);\n    glLoadIdentity();\n    glOrtho(-$ratio, $ratio, -1e0, 1e0, 1e0, -1e0);\n    glMatrixMode(GL_MODELVIEW);\n\n    glLoadIdentity();\n    glRotatef((now % 360 * 100e0) , 0e0, 0e0,  1e0);\n\n    glBegin(GL_TRIANGLES);\n    glColor3f(1e0, 0e0, 0e0);\n    glVertex3f(5e-1, -2.88e-1, 0e0);\n    glColor3f(0e0, 1e0, 0e0);\n    glVertex3f(-5e-1, -2.88e-1, 0e0);\n    glColor3f(0e0, 0e0, 1e0);\n    glVertex3f( 0e0, 5.73e-1, 0e0);\n    glEnd();\n\n    glfwSwapBuffers($w);\n    glfwPollEvents();\n}\n\nglfwTerminate();\n\n```\n\nSee screen cap: OpenGL-Triangle-perl6.png (Offsite PNG image.)\n\nAdditional Output: (Offsite Media file)"}]}
{"messages": [{"role": "user", "content": "Using the triangle geometry from OpenGL. But instead of using a mechanism such as glColor3d, use a pixel shader for each pixel in the triangle. The pixel shader should pick a random RGB color for each pixel. Most pixels should have colors which are different from that of most other pixels.\n\nOptional: provide an update mechanism, to repeatedly re-render the triangle. (Possibilities include a mouse event handler, a timer event handler or an infinite loop, or even window expose events.) Shader generated color for each pixel should be different in each render.\n\nOptional: after updating the opengl rendering target but before rendering the triangle, query the opengl implementation to determine which versions of shaders are supported by the rendering target, list the tested shaders and the available shaders and then use a supported shader.\n\nSee also: opengl.org's gl shader language documentation, and lighthouse3d.com's glsl tutorial."}, {"role": "assistant", "content": "**Translation of**: C\n\n```\n# 20250207 Raku programming solution\n\nuse NativeCall;\n\nmy ($angle, $r_mod) = 0e0;\n\n# OpenGL and GLUT constants\nenum GLenum ( GL_TRIANGLES => 0x0004);\n\nenum GLbitfield ( GL_COLOR_BUFFER_BIT => 0x00004000, GL_DEPTH_BUFFER_BIT => 0x00000100 );\nenum GLUTdisplay_mode ( GLUT_RGB => 0x0000, GLUT_DOUBLE => 0x0002, GLUT_DEPTH => 0x0010 );\nenum Shader_type ( GL_FRAGMENT_SHADER => 0x8B30, GL_VERTEX_SHADER => 0x8B31 );\nenum STDLIB ( RAND_MAX => 2147483647 );\n\n# GLUT functions\nconstant $lib = 'glut';\nsub glutInit(CArray[uint32], CArray[Str]) is native($lib) {*}\nsub glutInitDisplayMode(uint32 $mode) is native($lib) {*}\nsub glutInitWindowSize(int32 $width, int32 $height) is native($lib) {*}\nsub glutCreateWindow(Str $str) is native($lib) {*}\nsub glutDisplayFunc(&func ()) is native($lib) {*}\nsub glutIdleFunc(&func ()) is native($lib) {*}\nsub glutSwapBuffers() is native($lib) {*}\nsub glutMainLoop() is native($lib) {*}\n\n# OpenGL functions\nconstant $gllib = 'GL';\nsub glClear(int32) is native($gllib) {*}\nsub glLoadIdentity() is native($gllib) {*}\nsub glRotatef(num32 $angle, num32 $x, num32 $y, num32 $z) is native($gllib) {*}\nsub glBegin(uint32) is native($gllib) {*}\nsub glEnd() is native($gllib) {*}\nsub glVertex3f(num32 $x, num32 $y, num32 $z) is native($gllib) {*}\nsub glUniform1f(uint32, num32) is native($gllib) {*}\n\n# Shader functions\nsub glCreateShader(uint32) returns uint32 is native($gllib) {*}\nsub glShaderSource(uint32, int32, CArray[Str], CArray[int32]) is native($gllib) {*}\nsub glCompileShader(uint32) is native($gllib) {*}\nsub glCreateProgram() returns uint32 is native($gllib) {*}\nsub glAttachShader(uint32, uint32) is native($gllib) {*}\nsub glLinkProgram(uint32) is native($gllib) {*}\nsub glUseProgram(uint32) is native($gllib) {*}\nsub glGetUniformLocation(uint32, Str) returns uint32 is native($gllib) {*}\n\n# GLEW functions\nconstant $glewlib = 'GLEW';\nsub glewInit() returns int32 is native($glewlib) {*}\nsub glewIsSupported(Str) returns int32 is native($glewlib) {*}\n\nsub render() {\n   glClear(GL_COLOR_BUFFER_BIT +| GL_DEPTH_BUFFER_BIT);\n   glUniform1f($r_mod, rand / RAND_MAX);\n   glLoadIdentity();\n   glRotatef($angle, $angle * 0.1, 1e0, 0e0);\n   glBegin(GL_TRIANGLES);\n      glVertex3f(-1e0, -0.5e0, 0e0);\n      glVertex3f(0e0, 1e0, 0e0);\n      glVertex3f(1e0, 0e0, 0e0);\n   glEnd();\n   $angle += 0.02;\n   glutSwapBuffers();\n}\n\nsub compile_shader($shader_type, $source) {\n   my $shader = glCreateShader($shader_type);\n   my $length = $source.chars;\n   my $source_array = CArray[Str].new($source);\n   my $length_array = CArray[int32].new($length);\n   glShaderSource($shader, 1, $source_array, $length_array);\n   glCompileShader($shader);\n   return $shader;\n}\n\nsub set_shader() {\n   my $f = q:to/END/;\nvarying float x, y, z;\nuniform float r_mod;\nfloat rand(float s, float r) { return mod(mod(s, r + r_mod) * 112341.0, 1.0); }\nvoid main() {\n   gl_FragColor = vec4(rand(gl_FragCoord.x, x), rand(gl_FragCoord.y, y), rand(gl_FragCoord.z, z), 1.0);\n}\nEND\n   my $v = q:to/END/;\nvarying float x, y, z;\nvoid main() {\n   gl_Position = ftransform();\n   x = gl_Position.x; y = gl_Position.y; z = gl_Position.z;\n   x += y; y -= x; z += x - y;\n}\nEND\n\n   my $vs = compile_shader(GL_VERTEX_SHADER, $v);\n   my $ps = compile_shader(GL_FRAGMENT_SHADER, $f);\n\n   given my $prog = glCreateProgram() {\n      ($vs, $ps).map: -> $shader { glAttachShader($prog, $shader) };\n      glLinkProgram($prog);\n      glUseProgram($prog);\n      $r_mod = glGetUniformLocation($prog, \"r_mod\");\n   }   \n}\n\nglutInit(CArray[uint32].new, CArray[Str].new);\nglutInitDisplayMode(GLUT_DOUBLE +| GLUT_RGB +| GLUT_DEPTH);\nglutInitWindowSize(600, 600);\nglutCreateWindow(\"pixel shader\");\nglutDisplayFunc(&render);\nglutIdleFunc(&render);\nglewInit();\ndie \"GL 2.0 unsupported\\n\" unless glewIsSupported(\"GL_VERSION_2_0\"); \nset_shader();\nglutMainLoop();\n\n```"}]}
{"messages": [{"role": "user", "content": "This is a way to render the classic Utah Teapot using OpenGL library.\n\nSee also: Utah Teapot wikipage."}, {"role": "assistant", "content": "**Translation of**: C\n\n```\n# 20210524 Raku programming solution\n\nuse NativeCall;\n\nmy $rot = 0e0;\n                            # https://www.khronos.org/opengl/wiki/OpenGL_Type\nenum GLenum ( \n   GL_SMOOTH   => 0x1D01,   GL_LIGHT0     => 0x4000,   GL_AMBIENT   => 0x1200,\n   GL_DIFFUSE  => 0x1201,   GL_FRONT      => 0x0404,   GL_SHININESS => 0x1601,\n   GL_LIGHTING => 0x0B50,   GL_DEPTH_TEST => 0x0B71,\n);\nenum GLbitfield ( GL_COLOR_BUFFER_BIT => 0x00004000,   GL_DEPTH_BUFFER_BIT => 0x00000100, );\nenum GLUTdisplay_mode ( GLUT_RGB => 0x0000, GLUT_SINGLE => 0x0000, GLUT_DEPTH  => 0x0010, );\n\n\nconstant $lib = 'glut';\nsub glutInit(CArray[uint32], CArray[Str]) is native($lib) {*};\nsub glutInitDisplayMode(uint32 $mode) is native($lib) {*};\nsub glutInitWindowSize(int32 $width, int32 $height) is native($lib) {*};\nsub glutCreateWindow(Str $str) is native($lib) {*};\nsub glutDisplayFunc(&func ()) is native($lib) {*};\nsub glutWireTeapot(num64 $size) is native($lib) {*};\nsub glutIdleFunc(&func ()) is native($lib) {*};\nsub glutPostRedisplay() is native($lib) {*};\nsub glutMainLoop() is native($lib) {*};\n\n\nconstant $gllib = 'GL';\nsub glClearColor(num32 $red, num32 $green, num32 $blue, num32 $alpha) is native($gllib) {*};\nsub glShadeModel(int32) is native($gllib) {*};\nsub glEnable(int32) is native($gllib) {*};\nsub glClear(int32) is native($gllib) {*};\nsub glRotatef(num32 $angle, num32 $x, num32 $y, num32 $z) is native($gllib) {*};\nsub glPushMatrix() is native($gllib) {*};\nsub glPopMatrix() is native($gllib) {*};\nsub glFlush() is native($gllib) {*};\nsub glLightfv   (int32, int32, CArray[num32]) is native($gllib) {*};\nsub glMaterialfv(int32, int32, CArray[num32]) is native($gllib) {*};\n\n\nsub init {\n   glClearColor(.5e0,.5e0,.5e0,0e0);\n   glShadeModel(GL_SMOOTH);\n   glLightfv(GL_LIGHT0,GL_AMBIENT,CArray[num32].new: 1e0,1e0,1e0,0e0); # white\n   glLightfv(GL_LIGHT0,GL_DIFFUSE,CArray[num32].new: 1e0,1e0,1e0,0e0); # white\n   glMaterialfv(GL_FRONT,GL_SHININESS,CArray[num32].new: 70e0); # skinless so no effect ?\n   glEnable(GL_LIGHTING);\n   glEnable(GL_LIGHT0);\n   glEnable(GL_DEPTH_TEST);\n}\n\nsub display {\n   glClear(GL_COLOR_BUFFER_BIT+|GL_DEPTH_BUFFER_BIT);\n   glPushMatrix();\n   glRotatef(30e0,1e0,1e0,0e0);\n   glRotatef($rot,0e0,1e0,1e0);\n   glMaterialfv(GL_FRONT,GL_DIFFUSE, CArray[num32].new: 0e0,1e0,0e0,0e0); # green\n   glutWireTeapot(.5e0);\n   glPopMatrix();\n   glFlush();\n}\n\nsub onIdle {\n   $rot += 0.1e0;       # changed from 0.01 for faster rotation rate\n   glutPostRedisplay();\n}\n\n\nglutInit(CArray[uint32].new,CArray[Str].new);\nglutInitDisplayMode(GLUT_SINGLE+|GLUT_RGB+|GLUT_DEPTH);\nglutInitWindowSize(900,700);\nglutCreateWindow(\"The Amazing, Rotating Utah Teapot brought to you in OpenGL via freeglut.\");\ninit();\nglutDisplayFunc(&display);\nglutIdleFunc(&onIdle);\nglutMainLoop();\n\n```\n\nOutput: (Offsite Media file)"}]}
{"messages": [{"role": "user", "content": "Calculate the password requested by ethernet gateways from the Legrand / Bticino MyHome OpenWebNet home automation system when the user's ip address is not in the gateway's whitelist\n\n**Note:** Factory default password is '12345'. Changing it is highly recommended !\n\nconversation goes as follows\n\n```\n← *#*1##\n→ *99*0##\n← *#603356072##\n```\n\nat which point a password should be sent back, calculated from the \"password open\" that is set in the gateway, and the nonce that was just sent\n\n```\n→ *#25280520##\n← *#*1##\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku doesn't really have good support for unsigned fixed bit integers yet so emulating them with regular Ints and bitmasks.\n\n```\nsub own-password (Int $password, Int $nonce) {\n    my int $n1 = 0;\n    my int $n2 = $password;\n    for $nonce.comb {\n        given $_ {\n            when 1 {\n                $n1 = $n2 +& 0xFFFFFF80 +> 7;\n                $n2 +<= 25;\n            }\n            when 2 {\n                $n1 = $n2 +& 0xFFFFFFF0 +> 4;\n                $n2 +<= 28;\n            }\n            when 3 {\n                $n1 = $n2 +& 0xFFFFFFF8 +> 3;\n                $n2 +<= 29;\n            }\n            when 4 {\n                $n1 = $n2 +< 1;\n                $n2 +>= 31;\n            }\n            when 5 {\n                $n1 = $n2 +< 5;\n                $n2 +>= 27;\n            }\n            when 6 {\n                $n1 = $n2 +< 12;\n                $n2 +>= 20;\n            }\n            when 7 {\n                $n1 = $n2 +& 0x0000FF00 +| ($n2 +& 0x000000FF +< 24) +| ($n2 +& 0x00FF0000 +> 16);\n                $n2 = $n2 +& 0xFF000000 +> 8;\n            }\n            when 8 {\n                $n1 = $n2 +& 0x0000FFFF +< 16 +| $n2 +> 24;\n                $n2 = $n2 +& 0x00FF0000 +> 8;\n            }\n            when 9  { $n1 = +^$n2 }\n            default { $n1 = $n2 }\n        }\n        given $_ {\n            when 0 {}\n            when 9 {}\n            default { $n1 = ($n1 +| $n2) +& 0xFFFFFFFF }\n        }\n        $n2 = $n1;\n    }\n    $n1\n}\n\nsay own-password( 12345, 603356072 );\nsay own-password( 12345, 410501656 );\nsay own-password( 12345, 630292165 );\n\n```\n\nOutput:\n\n```\n25280520\n119537670\n4269684735\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Operators in C and C++. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nProvide a list of   precedence   and   associativity   of all the operators and constructs that the language utilizes in descending order of precedence such that an operator which is listed on some row will be evaluated prior to any operator that is listed on a row further below it.\n\nOperators that are in the same cell (there may be several rows of operators listed in a cell) are evaluated with the same level of precedence, in the given direction.\n\nState whether arguments are passed by value or by reference."}, {"role": "assistant", "content": "(formerly Perl 6)\nSee this table for a list of the precedence levels. Raku is an operator-rich language (and users may define more operators at will), so instead of listing all the operators in the table, representative operators are listed for some of the precedence levels; see later in the same file for a more complete list of predefined operators at each precedence level."}]}
{"messages": [{"role": "user", "content": "Task\n\nDefine a function/method/subroutine which sorts a sequence (\"table\") of sequences (\"rows\") of strings (\"cells\"), by one of the strings. Besides the input to be sorted, it shall have the following optional parameters:\n\n:   |  |\n    | --- |\n    | ---   ordering  A function specifying the ordering of strings; lexicographic by default.  column  An integer specifying which string of each row to compare; the first by default.  reverse  Reverses the ordering.   --- |\n\nThis task should be considered to include both positional and named optional parameters, as well as overloading on argument count as in Java or selector name as in Smalltalk, or, in the extreme, using different function names. Provide these variations of sorting **in whatever way is most natural to your language**. If the language supports both methods naturally, you are encouraged to describe both.\n\nDo not implement a sorting algorithm; this task is about the interface. If you can't use a built-in sort routine, just omit the implementation (with a comment).\n\nSee also:\n\n* Named Arguments"}, {"role": "assistant", "content": "(formerly Perl 6)\nUsing named parameters:\n\n```\nmethod sorttable(:$column = 0, :$reverse, :&ordering = &infix:<cmp>) {\n    my @result = self»[$column].sort: &ordering;\n    return $reverse ?? @result.reverse !! @result;\n}\n\n```\n\nUsing optional positional parameters:\n\n```\nmethod sorttable-pos($column = 0, $reverse?, &ordering = &infix:<cmp>) {\n    my @result = self»[$column].sort: &ordering;\n    return $reverse ?? @result.reverse !! @result;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "When neglecting the influence of other objects, two celestial bodies orbit one another along a conic trajectory. In the orbital plane, the polar equation is thus:\n\nr = L/(1 + e cos(angle))\n\n**L** ,  **e**  and  **angle**  are respectively called *semi-latus rectum*, *eccentricity* and *true anomaly*. The eccentricity and the true anomaly are two of the six so-called orbital elements often used to specify an orbit and the position of a point on this orbit.\n\nThe four other parameters are the *semi-major axis*, the *longitude of the ascending node*, the *inclination* and the *argument of periapsis*. An other parameter, called the *gravitational parameter*, along with dynamical considerations described further, also allows for the determination of the speed of the orbiting object.\n\nThe semi-major axis is half the distance between perihelion and aphelion. It is often noted  **a**, and it's not too hard to see how it's related to the semi-latus-rectum:\n\na = L/(1 - e2)\n\nThe longitude of the ascending node, the inclination and the argument of the periapsis specify the orientation of the orbiting plane with respect to a reference plane defined with three arbitrarily chosen reference distant stars.\n\nThe gravitational parameter is the coefficent GM in Newton's gravitational force. It is sometimes noted µ and will be chosen as one here for the sake of simplicity:\n\nµ = GM = 1\n\nAs mentioned, dynamical considerations allow for the determination of the speed. They result in the so-called vis-viva equation:\n\nv2 = GM(2/r - 1/a)\n\nThis only gives the magnitude of the speed. The direction is easily determined since it's tangent to the conic.\n\nThose parameters allow for the determination of both the position and the speed of the orbiting object in cartesian coordinates, those two vectors constituting the so-called orbital state vectors.\n\nTask\n\nShow how to perform this conversion from orbital elements to orbital state vectors in your programming language.\n\nTODO: pick an example from a reputable source, and bring the algorithm description onto this site. (Restating those pages in concise a fashion comprehensible to the coders and readers of this site will be a good exercise.)"}, {"role": "assistant", "content": "(formerly Perl 6)\nWe'll use the Clifford geometric algebra library but only for the vector operations.\n\n```\nsub orbital-state-vectors(\n    Real :$semimajor-axis where * >= 0,\n    Real :$eccentricity   where * >= 0,\n    Real :$inclination,\n    Real :$longitude-of-ascending-node,\n    Real :$argument-of-periapsis,\n    Real :$true-anomaly\n) {\n    use Clifford;\n    my ($i, $j, $k) = @e[^3];\n\n    sub rotate($a is rw, $b is rw, Real \\α) {\n        ($a, $b) = cos(α)*$a + sin(α)*$b, -sin(α)*$a + cos(α)*$b;\n    }\n    rotate($i, $j, $longitude-of-ascending-node);\n    rotate($j, $k, $inclination);\n    rotate($i, $j, $argument-of-periapsis);\n\n    my \\l = $eccentricity == 1 ?? # PARABOLIC CASE\n        2*$semimajor-axis !!\n        $semimajor-axis*(1 - $eccentricity**2);\n\n    my ($c, $s) = .cos, .sin given $true-anomaly;\n\n    my \\r = l/(1 + $eccentricity*$c);\n    my \\rprime = $s*r**2/l;\n\n    my $position = r*($c*$i + $s*$j);\n\n    my $speed = \n    (rprime*$c - r*$s)*$i + (rprime*$s + r*$c)*$j;\n    $speed /= sqrt($speed**2);\n    $speed *= sqrt(2/r - 1/$semimajor-axis);\n\n    { :$position, :$speed }\n}\n\nsay orbital-state-vectors\n    semimajor-axis => 1,\n    eccentricity => 0.1,\n    inclination => pi/18,\n    longitude-of-ascending-node => pi/6,\n    argument-of-periapsis => pi/4,\n    true-anomaly => 0;\n\n```\n\nOutput:\n\n```\n{position => 0.237771283982207*e0+0.860960261697716*e1+0.110509023572076*e2, speed => -1.06193301748006*e0+0.27585002056925*e1+0.135747024865598*e2}\n```"}]}
{"messages": [{"role": "user", "content": "Assume we have a set of items that can be sorted into an order by the user.\n\nThe user is presented with pairs of items from the set in *no* order,\nthe user states which item\nis less than, equal to, or greater than the other (with respect to their\nrelative positions if fully ordered).\n\nWrite a function that given items that the user can order, **asks the user** to\ngive the result of *comparing two items at a time* and uses the comparison results\nto eventually return the items in order.\n\nTry and minimise the comparisons the user is asked for.\n\nShow on this page, the function ordering the colours of the rainbow:\n\n```\n   violet red green indigo blue yellow orange\n\n```\n\nThe correct ordering being:\n\n```\n   red orange yellow green blue indigo violet\n\n```\n\nNote:\n\n* Asking for/receiving user comparisons is a part of the task.\n* Code *inputs* should not assume an ordering.\n* The seven colours can form twenty-one different pairs.\n* A routine that does not ask the user \"too many\" comparison questions should be used."}, {"role": "assistant", "content": "Raku's sort (like most languages) can take a custom \"comparator\" routine.\nSince the calls to the comparator are minimized, and the info that the user provides is analogous to the required return values of the comparator, we just need to embed the prompt directly in the comparator.\n\n```\nmy $ask_count = 0;\nsub by_asking ( $a, $b ) {\n    $ask_count++;\n    constant $fmt = '%2d. Is %-6s [ less than | greater than | equal to ] %-6s? ( < = > ) ';\n    constant %o = '<' => Order::Less,\n                  '=' => Order::Same,\n                  '>' => Order::More;\n\n    loop {\n        my $input = prompt sprintf $fmt, $ask_count, $a, $b;\n        return $_ with %o{ $input.trim };\n        say \"Invalid input '$input'\";\n    }\n}\n\nmy @colors = <violet red green indigo blue yellow orange>;\nmy @sorted = @colors.sort: &by_asking;\nsay (:@sorted);\n\ndie if @sorted».substr(0,1).join ne 'roygbiv';\nmy $expected_ask_count = @colors.elems * log(@colors.elems);\nwarn \"Too many questions? ({:$ask_count} > {:$expected_ask_count})\" if $ask_count > $expected_ask_count;\n\n```\n\nOutput:\n\n```\n 1. Is violet [ less than | greater than | equal to ] red   ? ( < = > ) >\n 2. Is green  [ less than | greater than | equal to ] indigo? ( < = > ) <\n 3. Is blue   [ less than | greater than | equal to ] yellow? ( < = > ) >\n 4. Is red    [ less than | greater than | equal to ] green ? ( < = > ) <\n 5. Is violet [ less than | greater than | equal to ] green ? ( < = > ) >\n 6. Is violet [ less than | greater than | equal to ] indigo? ( < = > ) >\n 7. Is yellow [ less than | greater than | equal to ] orange? ( < = > ) >\n 8. Is red    [ less than | greater than | equal to ] orange? ( < = > ) <\n 9. Is green  [ less than | greater than | equal to ] orange? ( < = > ) >\n10. Is green  [ less than | greater than | equal to ] yellow? ( < = > ) >\n11. Is green  [ less than | greater than | equal to ] blue  ? ( < = > ) <\n12. Is indigo [ less than | greater than | equal to ] blue  ? ( < = > ) >\nsorted => [red orange yellow green blue indigo violet]\n\n```"}]}
{"messages": [{"role": "user", "content": "Given   `M`   as a list of items and another list   `N`   of items chosen from   `M`,   create   `M'`   as a list with the *first* occurrences of items from   N   sorted to be in one of the set of indices of their original occurrence in   `M`   but in the order given by their order in   `N`.\n\nThat is, items in   `N`   are taken from   `M`   without replacement, then the corresponding positions in   `M'`   are filled by successive items from   `N`.\n\nFor example\n:   if   `M`   is   `'the cat sat on the mat'`\n:   And   `N`   is   `'mat cat'`\n:   Then the result   `M'`   is   `'the mat sat on the cat'`.\n\nThe words not in   `N`   are left in their original positions.\n\nIf there are duplications then only the first instances in   `M`   up to as many as are mentioned in   `N`   are potentially re-ordered.\n\nFor example\n:   `M = 'A B C A B C A B C'`\n:   `N = 'C A C A'`\n\nIs ordered as:\n\n:   `M' = 'C B A C B A A B C'`\n\nShow the output, here, for at least the following inputs:\n\n```\nData M: 'the cat sat on the mat' Order N: 'mat cat'\nData M: 'the cat sat on the mat' Order N: 'cat mat'\nData M: 'A B C A B C A B C'      Order N: 'C A C A'\nData M: 'A B C A B D A B E'      Order N: 'E A D A'\nData M: 'A B'                    Order N: 'B'      \nData M: 'A B'                    Order N: 'B A'    \nData M: 'A B B A'                Order N: 'B A'\n\n```\n\nCf\n\n* Sort disjoint sublist"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nsub order-disjoint-list-items(\\M, \\N) {\n    my \\bag = N.BagHash;\n    M.map: { bag{$_}-- ?? N.shift !! $_ }\n}\n\n# Testing:\n\nfor q:to/---/.comb(/ [\\S+]+ % ' ' /).map({[.words]})\n    the cat sat on the mat      mat cat\n    the cat sat on the mat      cat mat\n    A B C A B C A B C           C A C A\n    A B C A B D A B E           E A D A\n    A B                         B\n    A B                         B A\n    A B B A                     B A\n    X X Y                       X\n    A X                         Y A\n    ---\n->  $m, $n { say \"\\n$m ==> $n\\n\", order-disjoint-list-items($m, $n) }\n\n```\n\nOutput:\n\n```\nthe cat sat on the mat ==> mat cat\nthe mat sat on the cat\n\nthe cat sat on the mat ==> cat mat\nthe cat sat on the mat\n\nA B C A B C A B C ==> C A C A\nC B A C B A A B C\n\nA B C A B D A B E ==> E A D A\nE B C A B D A B A\n\nA B ==> B\nA B\n\nA B ==> B A\nB A\n\nA B B A ==> B A\nB A B A\n\nX X Y ==> X\nX X Y\n\nA X ==> Y A\nY X\n```"}]}
{"messages": [{"role": "user", "content": "Tasks in this category have to do with sorting collections of objects.\n\nWrite a function that orders two lists or arrays filled with numbers.\nThe function should accept two lists as arguments and return `true` if the first list should be ordered before the second, and `false` otherwise.\n\nThe order is determined by lexicographic order: Comparing the first element of each list.\nIf the first elements are equal, then the second elements should be compared, and so on, until one of the list has no more elements.\nIf the first list runs out of elements the result is `true`.\nIf the second list or both run out of elements the result is `false`.\n\nNote: further clarification of lexicographical ordering is expounded on the talk page here and here."}, {"role": "assistant", "content": "(formerly Perl 6)\nThere is already a built-in comparison operator.\n\n```\nmy @a = <1 2 4>;\nmy @b = <1 2 4>;\nsay @a,\" before \",@b,\" = \", @a before @b;\n\n@a = <1 2 4>;\n@b = <1 2>;\nsay @a,\" before \",@b,\" = \", @a before @b;\n\n@a = <1 2>;\n@b = <1 2 4>;\nsay @a,\" before \",@b,\" = \", @a before @b;\n\nfor 1..10 {\n    my @a = flat (^100).roll((2..3).pick);\n    my @b = flat @a.map: { Bool.pick ?? $_ !! (^100).roll((0..2).pick) }\n    say @a,\" before \",@b,\" = \", @a before @b;\n}\n\n```\n\nOutput:\n\n```\n1 2 4 before 1 2 4 = False\n1 2 4 before 1 2 = False\n1 2 before 1 2 4 = True\n63 52 before 0 52 = False\n17 75 24 before 31 75 24 = True\n43 32 before 43 32 = False\n73 84 before 2 84 = False\n73 92 before 40 24 46 = False\n16 24 before 41 24 = True\n9 12 22 before 9 12 32 67 = True\n81 23 before 81 23 = False\n55 53 1 before 55 62 83 = True\n20 40 51 before 20 17 78 34 = False\n```"}]}
{"messages": [{"role": "user", "content": "In this task we want to find the ordered partitions into fixed-size blocks.\n\nThis task is related to Combinations in that it has to do with discrete mathematics and moreover a helper function to compute combinations is (probably) needed to solve this task.\n\np\na\nr\nt\ni\nt\ni\no\nn\ns\n(\n\na\nr\ng\n\n1\n,\n\na\nr\ng\n\n2\n,\n.\n.\n.\n,\n\na\nr\ng\n\nn\n)\n{\\displaystyle {\\displaystyle partitions({\\mathit {arg}}\\_{1},{\\mathit {arg}}\\_{2},...,{\\mathit {arg}}\\_{n})}}\n should generate all distributions of the elements in \n\n{\n1\n,\n.\n.\n.\n,\n\nΣ\n\ni\n=\n1\n\nn\n\na\nr\ng\n\ni\n}\n{\\displaystyle {\\displaystyle \\{1,...,\\Sigma \\_{i=1}^{n}{\\mathit {arg}}\\_{i}\\}}}\n into \n\nn\n{\\displaystyle {\\displaystyle n}}\n blocks of respective size \n\na\nr\ng\n\n1\n,\n\na\nr\ng\n\n2\n,\n.\n.\n.\n,\n\na\nr\ng\n\nn\n{\\displaystyle {\\displaystyle {\\mathit {arg}}\\_{1},{\\mathit {arg}}\\_{2},...,{\\mathit {arg}}\\_{n}}}\n.\n\nExample 1: \n\np\na\nr\nt\ni\nt\ni\no\nn\ns\n(\n2\n,\n0\n,\n2\n)\n{\\displaystyle {\\displaystyle partitions(2,0,2)}}\n would create:\n\n```\n{({1, 2}, {}, {3, 4}), \n ({1, 3}, {}, {2, 4}), \n ({1, 4}, {}, {2, 3}), \n ({2, 3}, {}, {1, 4}), \n ({2, 4}, {}, {1, 3}), \n ({3, 4}, {}, {1, 2})}\n\n```\n\nExample 2: \n\np\na\nr\nt\ni\nt\ni\no\nn\ns\n(\n1\n,\n1\n,\n1\n)\n{\\displaystyle {\\displaystyle partitions(1,1,1)}}\n would create:\n\n```\n{({1}, {2}, {3}), \n ({1}, {3}, {2}), \n ({2}, {1}, {3}), \n ({2}, {3}, {1}), \n ({3}, {1}, {2}), \n ({3}, {2}, {1})}\n\n```\n\nNote that the number of elements in the list is\n\n:   (\n\n    a\n    r\n    g\n\n    1\n    +\n\n    a\n    r\n    g\n\n    2\n    +\n    .\n    .\n    .\n    +\n\n    a\n    r\n    g\n\n    n\n\n    a\n    r\n    g\n\n    1\n\n    )\n    ⋅\n\n    (\n\n    a\n    r\n    g\n\n    2\n    +\n\n    a\n    r\n    g\n\n    3\n    +\n    .\n    .\n    .\n    +\n\n    a\n    r\n    g\n\n    n\n\n    a\n    r\n    g\n\n    2\n\n    )\n    ⋅\n    …\n    ⋅\n\n    (\n\n    a\n    r\n    g\n\n    n\n\n    a\n    r\n    g\n\n    n\n\n    )\n    {\\displaystyle {\\displaystyle {{\\mathit {arg}}\\_{1}+{\\mathit {arg}}\\_{2}+...+{\\mathit {arg}}\\_{n} \\choose {\\mathit {arg}}\\_{1}}\\cdot {{\\mathit {arg}}\\_{2}+{\\mathit {arg}}\\_{3}+...+{\\mathit {arg}}\\_{n} \\choose {\\mathit {arg}}\\_{2}}\\cdot \\ldots \\cdot {{\\mathit {arg}}\\_{n} \\choose {\\mathit {arg}}\\_{n}}}}\n\n(see the definition of the binomial coefficient if you are not familiar with this notation) and the number of elements remains the same regardless of how the argument is permuted\n(i.e. the multinomial coefficient).\n\nAlso, \n\np\na\nr\nt\ni\nt\ni\no\nn\ns\n(\n1\n,\n1\n,\n1\n)\n{\\displaystyle {\\displaystyle partitions(1,1,1)}}\n creates the permutations of \n\n{\n1\n,\n2\n,\n3\n}\n{\\displaystyle {\\displaystyle \\{1,2,3\\}}}\n and thus there would be \n\n3\n!\n=\n6\n{\\displaystyle {\\displaystyle 3!=6}}\n elements in the list.\n\nNote: Do not use functions that are not in the standard library of the programming language you use. Your file should be written so that it can be executed on the command line and by default outputs the result of \n\np\na\nr\nt\ni\nt\ni\no\nn\ns\n(\n2\n,\n0\n,\n2\n)\n{\\displaystyle {\\displaystyle partitions(2,0,2)}}\n. If the programming language does not support polyvariadic functions pass a list as an argument.\n\n**Notation**\n\nHere are some explanatory remarks on the notation used in the task description:\n\n{\n1\n,\n…\n,\nn\n}\n{\\displaystyle {\\displaystyle \\{1,\\ldots ,n\\}}}\n denotes the set of consecutive numbers from \n\n1\n{\\displaystyle {\\displaystyle 1}}\n to \n\nn\n{\\displaystyle {\\displaystyle n}}\n, e.g. \n\n{\n1\n,\n2\n,\n3\n}\n{\\displaystyle {\\displaystyle \\{1,2,3\\}}}\n if \n\nn\n=\n3\n{\\displaystyle {\\displaystyle n=3}}\n.\n\nΣ\n{\\displaystyle {\\displaystyle \\Sigma }}\n is the mathematical notation for summation, e.g. \n\nΣ\n\ni\n=\n1\n\n3\ni\n=\n6\n{\\displaystyle {\\displaystyle \\Sigma \\_{i=1}^{3}i=6}}\n (see also [1]).\n\na\nr\ng\n\n1\n,\n\na\nr\ng\n\n2\n,\n.\n.\n.\n,\n\na\nr\ng\n\nn\n{\\displaystyle {\\displaystyle {\\mathit {arg}}\\_{1},{\\mathit {arg}}\\_{2},...,{\\mathit {arg}}\\_{n}}}\n are the arguments — natural numbers — that the sought function receives."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.04.1\n\n```\nsub partition(@mask is copy) {\n    my @op;\n    my $last = [+] @mask or return [] xx 1;\n    for @mask.kv -> $k, $v {\n        next unless $v;\n        temp @mask[$k] -= 1;\n        for partition @mask -> @p {\n            @p[$k].push: $last;\n            @op.push: @p;\n        }\n    }\n    return @op;\n}\n\n.say for reverse partition [2,0,2];\n\n```\n\nOutput:\n\n```\n[[1, 2], (Any), [3, 4]]\n[[1, 3], (Any), [2, 4]]\n[[2, 3], (Any), [1, 4]]\n[[1, 4], (Any), [2, 3]]\n[[2, 4], (Any), [1, 3]]\n[[3, 4], (Any), [1, 2]]\n```"}]}
{"messages": [{"role": "user", "content": "An   *ordered word*   is a word in which the letters appear in alphabetic order.\n\nExamples include   **abbey**   and   **dirt**.\n\nTask[edit]\n\nFind *and display* all the ordered words in the dictionary   unixdict.txt   that have the longest word length.\n\n(Examples that access the dictionary file locally assume that you have downloaded this file yourself.)\n\nThe display needs to be shown on this page.\n\nRelated tasks\n\n* |  |  |  |  |  |  |\n  | --- | --- | --- | --- | --- | --- |\n  | | Word plays | | | --- | --- | |  | | Ordered words  Palindrome detection  Semordnilap  Anagrams  Anagrams/Deranged anagrams | | |\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nHere we assume the dictionary is provided on standard input.\n\n**Works with**: Rakudo version 2016.07\n\n```\nsay lines.grep({ [le] .comb }).classify(*.chars).max(*.key).value\n\n```\n\nOutput:\n\n```\n[abbott accent accept access accost almost bellow billow biopsy chilly choosy choppy effort floppy glossy knotty]\n\n```"}]}
{"messages": [{"role": "user", "content": "An Ormiston pair is two consecutive prime numbers which are anagrams, i.e. contain the same decimal digits but in a different order.\n\n**(1913, 1931)** is the first such pair.\n\nTask\n\n* Find and show the first **30** Ormiston pairs.\n\n* Find and show the **count** of Ormiston pairs up to one million.\n\nStretch\n\n* Find and show the **count** of Ormiston pairs up to ten million.\n\nSee also\n\n* Numbers Aplenty - Ormiston pairs * OEIS:A072274 - Ormiston prime pairs"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\nuse List::Divvy;\n\nmy @primes = lazy (^∞).hyper.grep( &is-prime ).map: { $_ => .comb.sort.join };\nmy @Ormistons = @primes.kv.map: { ($^value.key, @primes[$^key+1].key) if $^value.value eq @primes[$^key+1].value };\n\nsay \"First thirty Ormiston pairs:\"; \nsay @Ormistons[^30].batch(3)».map( { \"({.[0].fmt: \"%5d\"}, {.[1].fmt: \"%5d\"})\" } ).join: \"\\n\";\nsay '';\nsay +@Ormistons.&before( *[1] > $_ ) ~ \" Ormiston pairs before \" ~ .Int.&cardinal for 1e5, 1e6, 1e7;\n\n```\n\nOutput:\n\n```\nFirst thirty Ormiston pairs:\n( 1913,  1931) (18379, 18397) (19013, 19031)\n(25013, 25031) (34613, 34631) (35617, 35671)\n(35879, 35897) (36979, 36997) (37379, 37397)\n(37813, 37831) (40013, 40031) (40213, 40231)\n(40639, 40693) (45613, 45631) (48091, 48109)\n(49279, 49297) (51613, 51631) (55313, 55331)\n(56179, 56197) (56713, 56731) (58613, 58631)\n(63079, 63097) (63179, 63197) (64091, 64109)\n(65479, 65497) (66413, 66431) (74779, 74797)\n(75913, 75931) (76213, 76231) (76579, 76597)\n\n40 Ormiston pairs before one hundred thousand\n382 Ormiston pairs before one million\n3722 Ormiston pairs before ten million\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nAn **Ormiston triple** is three consecutive prime numbers which are anagrams, i.e. contain the same decimal digits but in a different order.\n\nExample\n\nThe three consecutive primes **(11117123, 11117213, 11117321)** are an Ormiston triple.\n\nTask\n\n* Find and show the smallest member of the first **25** Ormiston triples.\n\n* Find and show the **count** of Ormiston triples up to one billion.\n\nStretch\n\n* Find and show the **count** of Ormiston triples up to ten billion.\n\nReference\n\n* OEIS:A075093 - Smallest member of Ormiston prime triple\n\nRelated task\n\n* Ormiston pairs"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\nuse List::Divvy;\n\nmy @primes = lazy (^∞).hyper.grep( &is-prime ).map: { $_ => .comb.sort.join };\nmy @Ormistons = @primes.kv.map: { $^value.key if $^value.value eq @primes[$^key+1].value eq @primes[$^key+2].value};\n\nsay \"First twenty-five Ormiston triples:\"; \nsay @Ormistons[^25].batch(5)».join(', ').join: \"\\n\";\nsay '';\nsay +@Ormistons.&before( *[0] > $_ ) ~ \" Ormiston triples before \" ~ .Int.&cardinal for 1e8, 1e9;\n\n```\n\nOutput:\n\n```\nFirst twenty-five Ormiston triples:\n11117123, 12980783, 14964017, 32638213, 32964341\n33539783, 35868013, 44058013, 46103237, 48015013\n50324237, 52402783, 58005239, 60601237, 61395239\n74699789, 76012879, 78163123, 80905879, 81966341\n82324237, 82523017, 83279783, 86050781, 92514341\n\n25 Ormiston triples before one hundred million\n368 Ormiston triples before one billion\n```"}]}
{"messages": [{"role": "user", "content": "An overloaded operator can be used on more than one data type, or represents a different action depending on the context. For example, if your language lets you use \"+\" for adding numbers and concatenating strings, then one would say that the \"+\" operator is overloaded.\n\nTask\n\nDemonstrate overloaded operators in your language, by showing the different types of data they can or cannot operate on, and the results of each operation."}, {"role": "assistant", "content": "While it is very easy to overload operators in Raku, it isn't really common...\nat least, not in the traditional sense. Or it's extremely common... It depends on how you view it.\n\nFirst off, do not confuse \"symbol reuse\" with operator overloading. Multiplication \\* and exponentiation \\*\\* operators both use an asterisk, but one is not an overload of the other. A single asterisk is not the same as two. In fact the term \\* (whatever) also exists, but differs from both. The parser is smart enough to know when a term or an operator is expected and will select the correct one (or warn if they are not in the correct position).\n\nFor example:\n\n```\n1, 2, 1, * ** * * * … *\n\n```\n\nis a perfectly cromulent sequence definition in Raku. A little odd perhaps, but completely sensible. (It's the sequence starting with givens 1,2,1, with each term after the value of the term 3 terms back, raised to the power of the term two terms back, multiplied by the value one term back, continuing for some undefined number of terms. - Whatever to the whatever times whatever until whatever.)\n\nOne of the founding principles of Raku is that: \"Different things should look different\". It follows that \"Similar things should look similar\".\n\nTo pick out one tiny example: Adding numbery things together shouldn't be easily confusable with concatenating\nstrings. Instead, Raku has the \"concatenation\" operator: ~ for joining stringy\nthings together.\n\nUsing a numeric-ish operator implies that you want a numeric-ish answer... so Raku\nwill try very hard to give you what you ask for, no matter what operands you\npass it.\n\nRaku operators have multiple candidates to try to fulfil your request and will\ntry to coerce the operands to a sensible value.\n\nAddition:\n\n```\nsay  3    +  5;      # Int plus Int\nsay  3.0  +  0.5e1;  # Rat plus Num\nsay '3'   +  5;      # Str plus Int\nsay  3    + '5';     # Int plus Str\nsay '3'   + '5';     # Str plus Str\nsay '3.0' + '0.5e1'; # Str plus Str\nsay (2, 3, 4) + [5, 6]; # List plus Array\n\n```\n\n+ is a numeric operator so every thing is evaluated numerically if possible\n\nOutput:\n\n```\n8\n8\n8\n8\n8\n8\n5 # a list or array evaluated numerically returns the number of elements\n```\n\nConcatenation:\n\n```\nsay  3    ~  5;      # Int concatenate Int\nsay  3.0  ~  0.5e1;  # Rat concatenate Num\nsay '3'   ~  5;      # Str concatenate Int\nsay  3    ~ '5';     # Int concatenate Str\nsay '3'   ~ '5';     # Str concatenate Str\nsay '3.0' ~ '0.5e1'; # Str concatenate Str\nsay (2, 3, 4) ~ [5, 6]; # List concatenate Array\n\n```\n\n~ is a Stringy operator so everything is evaluated as a string (numerics are evaluated numerically then coerced to a string).\n\nOutput:\n\n```\n35\n35\n35\n35\n35\n3.00.5e1\n2 3 45 6 # default stringification, then concatenate\n```\n\nThere is nothing preventing you from overloading or overriding existing\noperators. Raku firmly believes in not putting pointless restrictions on\nwhat you can and can not do. Why make it hard to do the \"wrong\" thing when\nwe make it so easy to do it right?\n\nThere is no real impetus to \"overload\" existing operators to do *different*\nthings, it is **very** easy to add new operators in Raku, and nearly **any**\nUnicode character or combination may used to define it. They may be infix,\nprefix, postfix, (or post-circumfix!) The precedence, associativity and arity\nare all easily defined. An operator at heart is just a subroutine with funny calling conventions.\n\nBorrowed from the Nimber arithmetic task:\n\nNew operators, defined in place. Arity is two (almost all infix operators\ntake two arguments), precedence is set equivalent to similar existing operators,\ndefault (right) associativity. The second, ⊗, actually uses itself to define\nitself.\n\n```\nsub infix:<⊕> (Int $x, Int $y) is equiv(&infix:<+>) { $x +^ $y }\n\nsub infix:<⊗> (Int $x, Int $y) is equiv(&infix:<×>) {\n    return $x × $y if so $x|$y < 2;\n    my $h = exp $x.lsb, 2;\n    return $h ⊗ $y ⊕ (($x ⊕ $h) ⊗ $y) if $x > $h;\n    return $y ⊗ $x if $y.lsb < $y.msb;\n    return $x × $y unless my $comp = $x.lsb +& $y.lsb;\n    $h = exp $comp.lsb, 2;\n    (($x +> $h) ⊗ ($y +> $h)) ⊗ (3 +< ($h - 1))\n}\n\nsay 123 ⊗ 456;\n\n```\n\nOutput:\n\n```\n31562\n```\n\nBase Raku has 27 different operator precedence levels for built-ins. You could theoretically give a new operator an absolute numeric precedence but it would be difficult to predict exactly what the relative precedence would be. Instead, precedence is set by setting a relative precedence; either equivalent to an existing operator, or, by setting it tighter(higher) or looser(lower) precedence than an existing operator. When tighter or looser precedence is specified, a whole new precedence level is created squeezed in between the named level and its immediate successor (predecessor). The task Exponentiation with infix operators in (or operating on) the base demonstrates three different operators that nominally do the same thing, but may yield different results due to differing precedence levels.\n\nThat's all well and good, but suppose you have a new class, say, a Line class, and\nyou want to be able to do arithmetic on Lines. No need to override the built\nin arithmetic operators, just add a multi candidate to do the right thing. A multi\nallows *adding* a new definition of the operator without disturbing the existing ones.\n\nVery, **very** basic Line class:\n\n```\nclass Line {\n    has @.start;\n    has @.end;\n}\n\n# New infix + multi to add two Lines together, for some bogus definition of add\nmulti infix:<+> (Line $x, Line $y) {\n    Line.new(\n       :start(\n          sqrt($x.start[0]² + $y.start[0]²),\n          sqrt($x.start[1]² + $y.start[1]²)\n       ),\n       :end(\n          sqrt($x.end[0]² + $y.end[0]²),\n          sqrt($x.end[1]² + $y.end[1]²)\n       )\n    )\n}\n\n# In operation:\nsay Line.new(:start(-4,7), :end(5,0)) + Line.new(:start(1,1), :end(2,3));\n\n```\n\nOutput:\n\n```\nLine.new(start => [4.123105625617661e0, 7.0710678118654755e0], end => [5.385164807134504e0, 3e0])\n```\n\nTo be fair, all of this easy power in a bad programmers hands can lead to incomprehensible code... but bad programmers can be bad in any language."}]}
{"messages": [{"role": "user", "content": "Description\n\nFor the purposes of this task, an ***own digits power sum*** is a decimal integer which is **N** digits long and is equal to the sum of its individual digits raised to the power **N**.\n\nExample\n\nThe three digit integer **153** is an *own digits power sum* because 1³ + 5³ + 3³ = 1 + 125 + 27 = **153**.\n\nTask\n\nFind and show here all *own digits power sums* for **N** = **3** to **N** = **8** inclusive.\n\nOptionally, do the same for **N** = **9** which may take a while for interpreted languages.\n\nRelated\n\n* Narcissistic\\_decimal\\_number"}, {"role": "assistant", "content": "```\n(3..8).map: -> $p {\n    my %pow = (^10).map: { $_ => $_ ** $p };\n    my $start = 10 ** ($p - 1);\n    my $end   = 10 ** $p;\n    my @temp;\n    for ^9 -> $i {\n        ([X] ($i..9) xx $p).race.map: {\n            next unless [<=] $_;\n            my $sum = %pow{$_}.sum;\n            next if $sum < $start;\n            next if $sum > $end;\n            @temp.push: $sum if $sum.comb.Bag eqv $_».Str.Bag\n        }\n    }\n    .say for unique sort @temp;\n}\n\n```\n\nOutput:\n\n```\n153\n370\n371\n407\n1634\n8208\n9474\n54748\n92727\n93084\n548834\n1741725\n4210818\n9800817\n9926315\n24678050\n24678051\n88593477\n```\n\n### Combinations with repetitions\n\nUsing code from Combinations with repetitions task, a version that runs relatively quickly, and scales well.\n\n```\nproto combs_with_rep (UInt, @ ) { * }\nmulti combs_with_rep (0,    @ ) { () }\nmulti combs_with_rep ($,    []) { () }\nmulti combs_with_rep (1,    @a) { map { $_, }, @a }\nmulti combs_with_rep ($n, [$head, *@tail]) {\n    |combs_with_rep($n - 1, ($head, |@tail)).map({ $head, |@_ }),\n    |combs_with_rep($n, @tail);\n}\n\nsay sort gather {\n    for 3..9 -> $d {\n        for combs_with_rep($d, [^10]) -> @digits {\n            .take if $d == .comb.elems and @digits.join == .comb.sort.join given sum @digits X** $d;\n        }\n    }\n}\n\n```\n\nOutput:\n\n```\n153 370 371 407 1634 8208 9474 54748 92727 93084 548834 1741725 4210818 9800817 9926315 24678050 24678051 88593477 146511208 472335975 534494836 912985153\n```"}]}
{"messages": [{"role": "user", "content": "Conversion and addition of p-adic Numbers.\n\nTask.\n\nConvert two rationals to p-adic numbers and add them up.\nRational reconstruction is needed to interpret the result.\n\np-Adic numbers were introduced around 1900 by Hensel. p-Adic expansions\n(a series of digits 0 ≤ d < p times p-power weights)\nare finite-tailed and tend to zero in the direction of higher positive\npowers of p (to the left in the notation used here).\nFor example, the number 4 (100.0) has *smaller* 2-adic norm than 1/4 (0.01).\n\nIf we convert a natural number, the familiar p-ary expansion is obtained:\n10 decimal is 1010 both binary and 2-adic. To convert a rational number a/b\nwe perform p-adic long division. If p is actually prime, this is always possible\nif first the 'p-part' is removed from b (and the p-adic point shifted accordingly).\nThe inverse of b modulo p is then used in the conversion.\n\n**Recipe:** at each step the most significant digit of the partial remainder\n(initially a) is zeroed by subtracting a proper multiple of the divisor b.\nShift out the zero digit (divide by p) and repeat until the remainder is zero\nor the precision limit is reached. Because p-adic division starts from the right,\nthe 'proper multiplier' is simply\nd = partial remainder \\* 1/b (mod p).\nThe d's are the successive p-adic digits to find.\n\nAddition proceeds as usual, with carry from the right to the leftmost term,\nwhere it has least magnitude and just drops off. We can work with approximate rationals\nand obtain exact results. The routine for rational reconstruction demonstrates this:\nrepeatedly add a p-adic to itself (keeping count to determine the denominator),\nuntil an integer is reached (the numerator then equals the weighted digit sum).\nBut even p-adic arithmetic fails if the precision is too low. The examples mostly\nset the shortest prime-exponent combinations that allow valid reconstruction.\n\nRelated task.\n\np-Adic square roots\n\nReference.\n\n[1] p-Adic expansions"}, {"role": "assistant", "content": "```\n# 20210225 Raku programming solution\n\n#!/usr/bin/env raku\n\nclass Padic { has ($.p is default(2), %.v is default({})) is rw ;\n\n   method r2pa (Rat $x is copy, \\p, \\d) { # Reference: math.stackexchange.com/a/1187037\n      self.p = p ; \n      $x += p**d if $x < 0 ;  # complement\n\n      my $lowerest = 0;\n      my ($num,$den) = $x.nude;\n      while ($den % p) == 0 { $den /= p and $lowerest-- }\n      $x = $num / $den;\n\n      while +self.v < d {\n         my %d = ^p Z=> (( $x «-« ^p ) »/» p )».&{ .denominator % p }; # .kv\n         for %d.keys { self.v.{$lowerest++} = $_ and last if %d{$_} != 0 }\n         $x = ($x - self.v.{$lowerest-1}) / p ;\n      }\n      self\n   }\n\n   method add (Padic \\x, \\d) {\n      my $div = 0;\n      my $lowerest = (self.v.keys.sort({.Int}).first,\n                         x.v.keys.sort({.Int}).first  ).min ;\n      return Padic.new:  \n         p => self.p,\n         v => gather for ^d {\n            my $power = $lowerest + $_;\n            given ((self.v.{$power}//0)+(x.v.{$power}//0)+$div).polymod(x.p) \n               { take ($power, .[0]).Slip and $div = .[1] }\n         }\n   }\n\n   method gist { \n      # en.wikipedia.org/wiki/P-adic_number#Notation\n      # my %H = (0..9) Z=> ('₀'..'₉'); # (0x2080 .. 0x2089);\n      # '⋯ ' ~ self.v ~ ' ' ~ [~] self.p.comb».&{ %H{$_} } \n     \n      # express as a series \n      my %H = ( 0…9 ,'-') Z=> ( '⁰','¹','²','³','⁴'…'⁹','⁻');  \n      [~] self.v.keys.sort({.Int}).map: {\n         ' + ' ~ self.v.{$_} ~ '*' ~ self.p ~ [~] $_.comb».&{ %H{$_}} }\n      }\n}\n\nmy @T;\nfor my \\D = ( \n#`[[ these are not working\n   < 26/25 -109/125 5 4 >,\n   < 6/7 -5/7 10 7 >,\n   < 2/7 -3/7 10 7 >,\n   < 2/7 -1/7 10 7 >,\n   < 34/21 -39034/791 10 9 >,\n#]]\n#`[[[[[ Works\n   < 11/4 679001/207 2 43>,\n   < 11/4 679001/207 3 27 >,\n   < 5/19 -101/384 2 12>,\n   < -22/7 46071/379 7 13 >,\n   < -7/5 99/70 7 4> ,\n   < -101/109 583376/6649 61 7>,\n   < 122/407 -517/1477 7 11>,\n\n   < 2/1 1/1 2 4>,\n   < 4/1 3/1 2 4>,\n   < 4/1 3/1 2 5>,\n   < 4/9 8/9 5 4>,\n   < 11/4 679001/207 11 13 >,\n   < 1/4 9263/2837 7 11 >,\n   < 49/2 -4851/2 7 6 >,\n   < -9/5 27/7 3 8>,\n   < -22/7 46071/379 2 37 >,\n   < -22/7 46071/379 3 23 >,\n\n   < -101/109 583376/6649 2 40>,\n   < -101/109 583376/6649 32749 3>,\n   < -25/26 5571/137 7 13>,\n#]]]]]\n\n   < 5/8 353/30809 7 11 >,\n) -> \\D { \n   given @T[0] = Padic.new { say D[0]~' = ', .r2pa: D[0],D[2],D[3] }\n   given @T[1] = Padic.new { say D[1]~' = ', .r2pa: D[1],D[2],D[3] }\n   given @T[0].add: @T[1], D[3] { \n      given @T[2] = Padic.new { .r2pa: D[0]+D[1], D[2], D[3] } \n      say \"Addition result = \", $_.gist; #\n      unless ( $_.v.Str eq @T[2].v.Str ) { \n         say 'but ' ~ (D[0]+D[1]).nude.join('/') ~ ' = ' ~ @T[2].gist\n      }\n   }\n}\n\n```\n\nOutput:\n\n```\n5/8 =  + 5*7⁰ + 2*7¹ + 4*7² + 2*7³ + 4*7⁴ + 2*7⁵ + 4*7⁶ + 2*7⁷ + 4*7⁸ + 2*7⁹ + 4*7¹⁰\n353/30809 =  + 5*7⁰ + 5*7¹ + 4*7² + 3*7³ + 4*7⁴ + 6*7⁵ + 3*7⁶ + 6*7⁷ + 6*7⁸ + 3*7⁹ + 2*7¹⁰\nAddition result =  + 3*7⁰ + 1*7¹ + 2*7² + 6*7³ + 1*7⁴ + 2*7⁵ + 1*7⁶ + 2*7⁷ + 4*7⁸ + 6*7⁹ + 6*7¹⁰\n\n```"}]}
{"messages": [{"role": "user", "content": "Given a list of p-values, adjust the p-values for multiple comparisons. This is done in order to control the false positive, or Type 1 error rate.\n\nThis is also known as the \"false discovery rate\" (FDR). After adjustment, the p-values will be higher but still inside [0,1].\n\nThe adjusted p-values are sometimes called \"q-values\".\n\nTask\n\nGiven one list of p-values, return the p-values correcting for multiple comparisons\n\n```\n   p = {4.533744e-01, 7.296024e-01, 9.936026e-02, 9.079658e-02, 1.801962e-01,\n        8.752257e-01, 2.922222e-01, 9.115421e-01, 4.355806e-01, 5.324867e-01,\n        4.926798e-01, 5.802978e-01, 3.485442e-01, 7.883130e-01, 2.729308e-01,\n        8.502518e-01, 4.268138e-01, 6.442008e-01, 3.030266e-01, 5.001555e-02,\n        3.194810e-01, 7.892933e-01, 9.991834e-01, 1.745691e-01, 9.037516e-01,\n        1.198578e-01, 3.966083e-01, 1.403837e-02, 7.328671e-01, 6.793476e-02,\n        4.040730e-03, 3.033349e-04, 1.125147e-02, 2.375072e-02, 5.818542e-04,\n        3.075482e-04, 8.251272e-03, 1.356534e-03, 1.360696e-02, 3.764588e-04,\n        1.801145e-05, 2.504456e-07, 3.310253e-02, 9.427839e-03, 8.791153e-04,\n        2.177831e-04, 9.693054e-04, 6.610250e-05, 2.900813e-02, 5.735490e-03}\n\n```\n\nThere are several methods to do this, see:\n\n* Yoav Benjamini, Yosef Hochberg \"Controlling the False Discovery Rate: A Practical and Powerful Approach to Multiple Testing\", *Journal of the Royal Statistical Society. Series B*, Vol. 57, No. 1 (1995), pp. 289-300, JSTOR:2346101\n* Yoav Benjamini, Daniel Yekutieli, \"The control of the false discovery rate in multiple testing under dependency\", *Ann. Statist.*, Vol. 29, No. 4 (2001), pp. 1165-1188, DOI:10.1214/aos/1013699998 JSTOR:2674075\n* Sture Holm, \"A Simple Sequentially Rejective Multiple Test Procedure\", *Scandinavian Journal of Statistics*, Vol. 6, No. 2 (1979), pp. 65-70, JSTOR:4615733\n* Yosef Hochberg, \"A sharper Bonferroni procedure for multiple tests of significance\", *Biometrika*, Vol. 75, No. 4 (1988), pp 800–802, DOI:10.1093/biomet/75.4.800 JSTOR:2336325\n* Gerhard Hommel, \"A stagewise rejective multiple test procedure based on a modified Bonferroni test\", *Biometrika*, Vol. 75, No. 2 (1988), pp 383–386, DOI:10.1093/biomet/75.2.383 JSTOR:2336190\n\nEach method has its own advantages and disadvantages."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03.1\n\n```\n########################### Helper subs ###########################\n\nsub adjusted (@p, $type) { \"\\n$type\\n\" ~ format adjust( check(@p), $type ) }\n\nsub format ( @p, $cols = 5 ) {\n    my $i = -$cols;\n    my $fmt = \"%1.10f\";\n    join \"\\n\", @p.rotor($cols, :partial).map:\n      { sprintf \"[%2d]  { join ' ', $fmt xx $_ }\", $i+=$cols, $_ };\n}\n\nsub check ( @p ) { die 'p-values must be in range 0.0 to 1.0' if @p.min < 0 or 1 < @p.max; @p }\n\nmulti ratchet ( 'up', @p ) { my $m; @p[$_] min= $m, $m = @p[$_] for ^@p; @p }\n\nmulti ratchet ( 'dn', @p ) { my $m; @p[$_] max= $m, $m = @p[$_] for ^@p .reverse; @p }\n\nsub schwartzian ( @p, &transform, :$ratchet ) {\n    my @pa = @p.map( {[$_, $++]} ).sort( -*.[0] ).map: { [transform(.[0]), .[1]] };\n    @pa[*;0] = ratchet($ratchet, @pa»[0]);\n    @pa.sort( *.[1] )»[0]\n}\n\n############# The various p-value correction routines #############\n\nmulti adjust( @p, 'Benjamini-Hochberg' ) {\n    @p.&schwartzian: * * @p / (@p - $++) min 1, :ratchet('up')\n}\n\nmulti adjust( @p, 'Benjamini-Yekutieli' ) {\n    my \\r = ^@p .map( { 1 / ++$ } ).sum;\n    @p.&schwartzian: * * r * @p / (@p - $++) min 1, :ratchet('up')\n}\n\nmulti adjust( @p, 'Hochberg' ) {\n    my \\m = @p.max;\n    @p.&schwartzian: * * ++$ min m, :ratchet('up')\n}\n\nmulti adjust( @p, 'Holm' ) {\n    @p.&schwartzian: * * ++$ min 1, :ratchet('dn')\n}\n\nmulti adjust( @p, 'Šidák' ) {\n    @p.&schwartzian: 1 - (1 - *) ** ++$, :ratchet('dn')\n}\n\nmulti adjust( @p, 'Bonferroni' ) {\n    @p.map: * * @p min 1\n}\n\n# Hommel correction can't be easily reduced to a one pass transform\nmulti adjust( @p, 'Hommel' ) {\n    my @s  = @p.map( {[$_, $++]} ).sort: *.[0] ; # sorted\n    my \\z  = +@p; # array si(z)e\n    my @pa = @s»[0].map( * * z / ++$ ).min xx z; # p adjusted\n    my @q;        # scratch array\n    for (1 ..^ z).reverse -> $i {\n        my @L  = 0 .. z - $i; # lower indices\n        my @U  = z - $i ^..^ z; # upper indices\n        my $q  = @s[@U]»[0].map( { $_ * $i / (2 + $++) } ).min;\n        @q[@L] = @s[@L]»[0].map: { min $_ * $i, $q, @s[*-1][0] };\n        @pa    = ^z .map: { max @pa[$_], @q[$_] }\n    }\n    @pa[@s[*;1].map( {[$_, $++]} ).sort( *.[0] )»[1]]\n}\n\nmulti adjust ( @p, $unknown ) {\n    note \"\\nSorry, do not know how to do $unknown correction.\\n\" ~\n    \"Perhaps you want one of these?:\\n\" ~\n    <Benjamini-Hochberg Benjamini-Yekutieli Bonferroni Hochberg\n    Holm Hommel Šidák>.join(\"\\n\");\n    exit\n}\n\n########################### The task ###########################\n\nmy @p-values =\n    4.533744e-01, 7.296024e-01, 9.936026e-02, 9.079658e-02, 1.801962e-01,\n    8.752257e-01, 2.922222e-01, 9.115421e-01, 4.355806e-01, 5.324867e-01,\n    4.926798e-01, 5.802978e-01, 3.485442e-01, 7.883130e-01, 2.729308e-01,\n    8.502518e-01, 4.268138e-01, 6.442008e-01, 3.030266e-01, 5.001555e-02,\n    3.194810e-01, 7.892933e-01, 9.991834e-01, 1.745691e-01, 9.037516e-01,\n    1.198578e-01, 3.966083e-01, 1.403837e-02, 7.328671e-01, 6.793476e-02,\n    4.040730e-03, 3.033349e-04, 1.125147e-02, 2.375072e-02, 5.818542e-04,\n    3.075482e-04, 8.251272e-03, 1.356534e-03, 1.360696e-02, 3.764588e-04,\n    1.801145e-05, 2.504456e-07, 3.310253e-02, 9.427839e-03, 8.791153e-04,\n    2.177831e-04, 9.693054e-04, 6.610250e-05, 2.900813e-02, 5.735490e-03\n;\n\nfor < Benjamini-Hochberg Benjamini-Yekutieli Bonferroni Hochberg Holm Hommel Šidák >\n{\n    say adjusted @p-values, $_\n}\n\n```\n\nOutput:\n\n```\nBenjamini-Hochberg\n[ 0]  0.6126681081 0.8521710465 0.1987205200 0.1891595417 0.3217789286\n[ 5]  0.9301450000 0.4870370000 0.9301450000 0.6049730556 0.6826752564\n[10]  0.6482628947 0.7253722500 0.5280972727 0.8769925556 0.4705703448\n[15]  0.9241867391 0.6049730556 0.7856107317 0.4887525806 0.1136717045\n[20]  0.4991890625 0.8769925556 0.9991834000 0.3217789286 0.9301450000\n[25]  0.2304957692 0.5832475000 0.0389954722 0.8521710465 0.1476842609\n[30]  0.0168363750 0.0025629017 0.0351608438 0.0625018947 0.0036365888\n[35]  0.0025629017 0.0294688286 0.0061660636 0.0389954722 0.0026889914\n[40]  0.0004502863 0.0000125223 0.0788155476 0.0314261300 0.0048465270\n[45]  0.0025629017 0.0048465270 0.0011017083 0.0725203250 0.0220595769\n\nBenjamini-Yekutieli\n[ 0]  1.0000000000 1.0000000000 0.8940844244 0.8510676197 1.0000000000\n[ 5]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[10]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[15]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 0.5114323399\n[20]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[25]  1.0000000000 1.0000000000 0.1754486368 1.0000000000 0.6644618149\n[30]  0.0757503083 0.0115310209 0.1581958559 0.2812088585 0.0163617595\n[35]  0.0115310209 0.1325863108 0.0277423864 0.1754486368 0.0120983246\n[40]  0.0020259303 0.0000563403 0.3546073326 0.1413926119 0.0218055202\n[45]  0.0115310209 0.0218055202 0.0049568120 0.3262838334 0.0992505663\n\nBonferroni\n[ 0]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[ 5]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[10]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[15]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[20]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[25]  1.0000000000 1.0000000000 0.7019185000 1.0000000000 1.0000000000\n[30]  0.2020365000 0.0151667450 0.5625735000 1.0000000000 0.0290927100\n[35]  0.0153774100 0.4125636000 0.0678267000 0.6803480000 0.0188229400\n[40]  0.0009005725 0.0000125223 1.0000000000 0.4713919500 0.0439557650\n[45]  0.0108891550 0.0484652700 0.0033051250 1.0000000000 0.2867745000\n\nHochberg\n[ 0]  0.9991834000 0.9991834000 0.9991834000 0.9991834000 0.9991834000\n[ 5]  0.9991834000 0.9991834000 0.9991834000 0.9991834000 0.9991834000\n[10]  0.9991834000 0.9991834000 0.9991834000 0.9991834000 0.9991834000\n[15]  0.9991834000 0.9991834000 0.9991834000 0.9991834000 0.9991834000\n[20]  0.9991834000 0.9991834000 0.9991834000 0.9991834000 0.9991834000\n[25]  0.9991834000 0.9991834000 0.4632662100 0.9991834000 0.9991834000\n[30]  0.1575884700 0.0138396690 0.3938014500 0.7600230400 0.0250197306\n[35]  0.0138396690 0.3052970640 0.0542613600 0.4626366400 0.0165641872\n[40]  0.0008825611 0.0000125223 0.9930759000 0.3394022040 0.0369228426\n[45]  0.0102358057 0.0397415214 0.0031729200 0.8992520300 0.2179486200\n\nHolm\n[ 0]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[ 5]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[10]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[15]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[20]  1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000\n[25]  1.0000000000 1.0000000000 0.4632662100 1.0000000000 1.0000000000\n[30]  0.1575884700 0.0139534054 0.3938014500 0.7600230400 0.0250197306\n[35]  0.0139534054 0.3052970640 0.0542613600 0.4626366400 0.0165641872\n[40]  0.0008825611 0.0000125223 0.9930759000 0.3394022040 0.0369228426\n[45]  0.0102358057 0.0397415214 0.0031729200 0.8992520300 0.2179486200\n\nHommel\n[ 0]  0.9991834000 0.9991834000 0.9991834000 0.9987623800 0.9991834000\n[ 5]  0.9991834000 0.9991834000 0.9991834000 0.9991834000 0.9991834000\n[10]  0.9991834000 0.9991834000 0.9991834000 0.9991834000 0.9991834000\n[15]  0.9991834000 0.9991834000 0.9991834000 0.9991834000 0.9595180000\n[20]  0.9991834000 0.9991834000 0.9991834000 0.9991834000 0.9991834000\n[25]  0.9991834000 0.9991834000 0.4351894700 0.9991834000 0.9766522500\n[30]  0.1414255500 0.0130434007 0.3530936533 0.6887708800 0.0238560222\n[35]  0.0132245726 0.2722919760 0.0542613600 0.4218157600 0.0158112696\n[40]  0.0008825611 0.0000125223 0.8743649143 0.3016908480 0.0351646120\n[45]  0.0095824564 0.0387722160 0.0031729200 0.8122276400 0.1950066600\n\nŠidák\n[ 0]  0.9998642526 0.9999922727 0.9341844137 0.9234670175 0.9899922294\n[ 5]  0.9999922727 0.9992955735 0.9999922727 0.9998642526 0.9998909746\n[10]  0.9998642526 0.9999288207 0.9995533892 0.9999922727 0.9990991210\n[15]  0.9999922727 0.9998642526 0.9999674876 0.9992955735 0.7741716825\n[20]  0.9993332472 0.9999922727 0.9999922727 0.9899922294 0.9999922727\n[25]  0.9589019598 0.9998137104 0.3728369461 0.9999922727 0.8605248833\n[30]  0.1460714182 0.0138585952 0.3270159382 0.5366136349 0.0247164330\n[35]  0.0138585952 0.2640282766 0.0528503728 0.3723753774 0.0164308228\n[40]  0.0008821796 0.0000125222 0.6357389664 0.2889497995 0.0362651575\n[45]  0.0101847015 0.0389807074 0.0031679962 0.5985019850 0.1963376344\n```"}]}
{"messages": [{"role": "user", "content": "As the Fibonacci sequence expands to the Fibonacci n-step number sequences; We similarly expand the Padovan sequence to form these Padovan n-step number sequences.\n\nThe Fibonacci-like sequences can be defined like this:\n\n```\n   For n == 2:\n       start:      1, 1\n       Recurrence: R(n, x) = R(n, x-1) + R(n, x-2); for n == 2\n   For n == N:\n       start:      First N terms of R(N-1, x)\n       Recurrence: R(N, x) = sum(R(N, x-1) + R(N, x-2) + ... R(N, x-N))\n\n```\n\nFor this task we similarly define terms of the first 2..n-step Padovan sequences as:\n\n```\n   For n == 2:\n       start:      1, 1, 1\n       Recurrence: R(n, x) = R(n, x-2) + R(n, x-3); for n == 2\n   For n == N:\n       start:      First N + 1 terms of R(N-1, x)\n       Recurrence: R(N, x) = sum(R(N, x-2) + R(N, x-3) + ... R(N, x-N-1))\n\n```\n\nThe initial values of the sequences are:\n\n:   :   Padovan \n\n        n\n        {\\displaystyle {\\displaystyle n}}\n        -step sequences\n\n        | n {\\displaystyle {\\displaystyle n}} | Values | OEIS Entry |\n        | --- | --- | --- |\n        | 2 | 1,1,1,2,2,3,4,5,7,9,12,16,21,28,37, ... | A134816: 'Padovan's spiral numbers' |\n        | 3 | 1,1,1,2,3,4,6,9,13,19,28,41,60,88,129, ... | A000930: 'Narayana's cows sequence' |\n        | 4 | 1,1,1,2,3,5,7,11,17,26,40,61,94,144,221, ... | A072465: 'A Fibonacci-like model in which each pair of rabbits dies after the birth of their 4th litter' |\n        | 5 | 1,1,1,2,3,5,8,12,19,30,47,74,116,182,286, ... | A060961: 'Number of compositions (ordered partitions) of n into 1's, 3's and 5's' |\n        | 6 | 1,1,1,2,3,5,8,13,20,32,51,81,129,205,326, ... | <not found> |\n        | 7 | 1,1,1,2,3,5,8,13,21,33,53,85,136,218,349, ... | A117760: 'Expansion of 1/(1 - x - x^3 - x^5 - x^7)' |\n        | 8 | 1,1,1,2,3,5,8,13,21,34,54,87,140,225,362, ... | <not found> |\n\nTask\n\n1. Write a function to generate the first \n\n   t\n   {\\displaystyle {\\displaystyle t}}\n    terms, of the first `2..max_n` Padovan \n\n   n\n   {\\displaystyle {\\displaystyle n}}\n   -step number sequences as defined above.\n2. Use this to print and show here at least the first `t=15` values of the first `2..8` \n\n   n\n   {\\displaystyle {\\displaystyle n}}\n   -step sequences.  \n    (The OEIS column in the table above should be omitted)."}, {"role": "assistant", "content": "```\nsay 'Padovan N-step sequences; first 25 terms:';\n\nfor 2..8 -> \\N {\n    my @n-step = 1, 1, 1, { state $n = 2; @n-step[ ($n - N .. $n++ - 1).grep: * >= 0 ].sum } … *;\n    put \"N = {N} |\" ~ @n-step[^25]».fmt: \"%5d\";\n}\n\n```\n\nOutput:\n\n```\nPadovan N-step sequences; first 25 terms:\nN = 2 |    1     1     1     2     2     3     4     5     7     9    12    16    21    28    37    49    65    86   114   151   200   265   351   465   616\nN = 3 |    1     1     1     2     3     4     6     9    13    19    28    41    60    88   129   189   277   406   595   872  1278  1873  2745  4023  5896\nN = 4 |    1     1     1     2     3     5     7    11    17    26    40    61    94   144   221   339   520   798  1224  1878  2881  4420  6781 10403 15960\nN = 5 |    1     1     1     2     3     5     8    12    19    30    47    74   116   182   286   449   705  1107  1738  2729  4285  6728 10564 16587 26044\nN = 6 |    1     1     1     2     3     5     8    13    20    32    51    81   129   205   326   518   824  1310  2083  3312  5266  8373 13313 21168 33657\nN = 7 |    1     1     1     2     3     5     8    13    21    33    53    85   136   218   349   559   895  1433  2295  3675  5885  9424 15091 24166 38698\nN = 8 |    1     1     1     2     3     5     8    13    21    34    54    87   140   225   362   582   936  1505  2420  3891  6257 10061 16178 26014 41830\n```"}]}
{"messages": [{"role": "user", "content": "The Padovan sequence is similar to the Fibonacci sequence in several ways.\nSome are given in the table below, and the referenced video shows some of the geometric\nsimilarities.\n\n:   :   | Comment | Padovan | Fibonacci |\n        | --- | --- | --- |\n        |  |  |  |\n        | Named after. | Richard Padovan | Leonardo of Pisa: Fibonacci |\n        |  |  |  |\n        | Recurrence initial values. | P(0)=P(1)=P(2)=1 | F(0)=0, F(1)=1 |\n        | Recurrence relation. | P(n)=P(n-2)+P(n-3) | F(n)=F(n-1)+F(n-2) |\n        |  |  |  |\n        | First 10 terms. | 1,1,1,2,2,3,4,5,7,9 | 0,1,1,2,3,5,8,13,21,34 |\n        |  |  |  |\n        | Ratio of successive terms... | Plastic ratio, p | Golden ratio, g |\n        |  | 1.324717957244746025960908854… | 1.6180339887498948482... |\n        | Exact formula of ratios p and q. | ((9+69\\*\\*.5)/18)\\*\\*(1/3) + ((9-69\\*\\*.5)/18)\\*\\*(1/3) | (1+5\\*\\*0.5)/2 |\n        | Ratio is real root of polynomial. | p: x\\*\\*3-x-1 | g: x\\*\\*2-x-1 |\n        |  |  |  |\n        | Spirally tiling the plane using. | Equilateral triangles | Squares |\n        |  |  |  |\n        | Constants for ... | s= 1.0453567932525329623 | a=5\\*\\*0.5 |\n        | ... Computing by truncation. | P(n)=floor(p\\*\\*(n-1) / s + .5) | F(n)=floor(g\\*\\*n / a + .5) |\n        |  |  |  |\n        | L-System Variables. | A,B,C | A,B |\n        | L-System Start/Axiom. | A | A |\n        | L-System Rules. | A->B,B->C,C->AB | A->B,B->AB |\n\nTask\n\n* Write a function/method/subroutine to compute successive members of the Padovan series using the recurrence relation.\n* Write a function/method/subroutine to compute successive members of the Padovan series using the floor function.\n* Show the first twenty terms of the sequence.\n* Confirm that the recurrence and floor based functions give the same results for 64 terms,\n* Write a function/method/... using the L-system to generate successive strings.\n* Show the first 10 strings produced from the L-system\n* Confirm that the length of the first 32 strings produced is the Padovan sequence.\n\nShow output here, on this page.\n\nRef\n\n* The Plastic Ratio - Numberphile video."}, {"role": "assistant", "content": "```\nconstant p = 1.32471795724474602596;\nconstant s = 1.0453567932525329623;\nconstant %rules = A => 'B', B => 'C', C => 'AB';\n\nmy @pad-recur = 1, 1, 1, -> $c, $b, $ { $b + $c }  … *;\n\nmy @pad-floor = { floor 1/2 + p ** ($++ - 1) / s } … *;\n\nmy @pad-L-sys = 'A', { %rules{$^axiom.comb}.join } … *;\nmy @pad-L-len = @pad-L-sys.map: *.chars;\n\nsay @pad-recur.head(20);\nsay @pad-L-sys.head(10);\n\nsay \"Recurrence == Floor to N=64\" if (@pad-recur Z== @pad-floor).head(64).all;\nsay \"Recurrence == L-len to N=32\" if (@pad-recur Z== @pad-L-len).head(32).all;\n\n```\n\nOutput:\n\n```\n(1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 49 65 86 114 151)\n(A B C AB BC CAB ABBC BCCAB CABABBC ABBCBCCAB)\nRecurrence == Floor to N=64\nRecurrence == L-len to N=32\n\n```"}]}
{"messages": [{"role": "user", "content": "Generate the sequence where each term **n** is the count of the pairs **(x,y)** with **1 < x < y <= n**, that have at least one common prime factor.\n\nFor instance, when **n** = 9, examine the pairs:\n\n```\n   (2,3) (2,4) (2,5) (2,6) (2,7) (2,8) (2,9)\n   (3,4) (3,5) (3,6) (3,7) (3,8) (3,9)\n   (4,5) (4,6) (4,7) (4,8) (4,9)\n   (5,6) (5,7) (5,8) (5,9)\n   (6,7) (6,8) (6,9)\n   (7,8) (7,9)\n   (8,9)\n\n```\n\nFind all of the pairs that have at least one common prime factor:\n\n```\n   (2,4) (2,6) (2,8) (3,6) (3,9) (4,6) (4,8) (6,8) (6,9)\n\n```\n\nand count them:\n\n```\n   a(9) = 9\n\n```\n\nTerms may be found directly using the formula:\n\n```\n   a(n) = n × (n-1) / 2 + 1 - 𝚺{i=1..n} 𝚽(i)\n\n```\n\nwhere 𝚽() is Phi; the Euler totient function.\n\nFor the term **a(p)**, if **p** is prime, then **a(p)** is equal to the previous term.\n\nTask\n\n* Find and display the first one hundred terms of the sequence.\n* Find and display the one thousandth.\n\nStretch\n\n* Find and display the ten thousandth, one hundred thousandth, one millionth.\n\nSee also\n\n* OEIS:A185670 - Number of pairs (x,y) with 1 <= x < y <= n with at least one common factor * Task: Totient function"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\nuse Lingua::EN::Numbers;\n\nmy \\𝜑 = 0, |(1..*).hyper.map: -> \\t { t × [×] t.&prime-factors.unique.map: { 1 - 1/$_ } }\n\nsub pair-count (\\n) {  n × (n - 1) / 2 + 1 - sum 𝜑[1..n] }\n\nsay \"Number of pairs with common factors - first one hundred terms:\\n\"\n    ~ (1..100).map(&pair-count).batch(10)».&comma».fmt(\"%6s\").join(\"\\n\") ~ \"\\n\";\n\nfor ^7 { say (my $i = 10 ** $_).&ordinal.tc.fmt(\"%22s term: \") ~ $i.&pair-count.&comma }\n\n```\n\nOutput:\n\n```\nNumber of pairs with common factors - first one hundred terms:\n     0      0      0      1      1      4      4      7      9     14\n    14     21     21     28     34     41     41     52     52     63\n    71     82     82     97    101    114    122    137    137    158\n   158    173    185    202    212    235    235    254    268    291\n   291    320    320    343    363    386    386    417    423    452\n   470    497    497    532    546    577    597    626    626    669\n   669    700    726    757    773    818    818    853    877    922\n   922    969    969  1,006  1,040  1,079  1,095  1,148  1,148  1,195\n 1,221  1,262  1,262  1,321  1,341  1,384  1,414  1,461  1,461  1,526\n 1,544  1,591  1,623  1,670  1,692  1,755  1,755  1,810  1,848  1,907\n\n                 First term: 0\n                 Tenth term: 14\n         One hundredth term: 1,907\n        One thousandth term: 195,309\n        Ten thousandth term: 19,597,515\nOne hundred thousandth term: 1,960,299,247\n         One millionth term: 196,035,947,609\n```"}]}
{"messages": [{"role": "user", "content": "Today   (**2020-02-02**,   at the time of this writing)   happens to be a palindrome,   without the hyphens,   not only for those countries which express their dates in the   **yyyy-mm-dd**   format but,   unusually,   also for countries which use the   **dd-mm-yyyy**   format.\n\nTask\n\nWrite a program which calculates and shows the next 15 palindromic dates for those countries which express their dates in the   **yyyy-mm-dd**   format."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.01\n\nPretty basic, but good enough. Could start earlier but 3/2/1 digit years require different handling that isn't necessary for this task. (And would be pretty pointless anyway assuming we need 2 digits for the month and two digits for the day. ISO:8601 anybody?)\n\n```\nmy $start = '1000-01-01';\n \nmy @palindate = {\n     state $year = $start.substr(0,4);\n     ++$year;\n     my $m = $year.substr(2, 2).flip;\n     my $d = $year.substr(0, 2).flip;\n     next if not try Date.new(\"$year-$m-$d\");\n     \"$year-$m-$d\"\n} … *;\n \nmy $date-today = Date.today; # 2020-02-02\n \nmy $k = @palindate.first: { Date.new($_) > $date-today }, :k;\n \nsay join \"\\n\", @palindate[$k - 1 .. $k + 14];\n\nsay \"\\nTotal number of four digit year palindrome dates:\\n\" ~\nmy $four = @palindate.first( { .substr(5,1) eq '-' }, :k );\nsay \"between {@palindate[0]} and {@palindate[$four - 1]}.\";\n\nmy $five = @palindate.first: { .substr(6,1) eq '-' }, :k;\n\nsay \"\\nTotal number of five digit year palindrome dates:\\n\" ~\n+@palindate[$four .. $five]\n\n```\n\nOutput:\n\n```\n2020-02-02\n2021-12-02\n2030-03-02\n2040-04-02\n2050-05-02\n2060-06-02\n2070-07-02\n2080-08-02\n2090-09-02\n2101-10-12\n2110-01-12\n2111-11-12\n2120-02-12\n2121-12-12\n2130-03-12\n2140-04-12\n\nTotal number of four digit year palindrome dates:\n331\nbetween 1001-10-01 and 9290-09-29.\n\nTotal number of five digit year palindrome dates:\n3303\n```"}]}
{"messages": [{"role": "user", "content": "A palindrome is a phrase which reads the same backward and forward.\n\nTask[edit]\n\nWrite a function or program that checks whether a given sequence of characters (or, if you prefer, bytes)\nis a palindrome.\n\n***For extra credit:***\n\n* Support Unicode characters.\n* Write a second function (possibly as a wrapper to the first) which detects *inexact* palindromes, i.e. phrases that are palindromes if white-space and punctuation is ignored and case-insensitive comparison is used.\n\nHints\n\n* It might be useful for this task to know how to reverse a string.\n* This task's entries might also form the subjects of the task Test a function.\n\nRelated tasks\n\n* |  |  |  |  |  |  |\n  | --- | --- | --- | --- | --- | --- |\n  | | Word plays | | | --- | --- | |  | | Ordered words  Palindrome detection  Semordnilap  Anagrams  Anagrams/Deranged anagrams | | |\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsubset Palindrom of Str where {\n    .flip eq $_ given .comb(/\\w+/).join.lc\n}\n \nmy @tests = q:to/END/.lines;\n    A man, a plan, a canal: Panama.\n    My dog has fleas\n    Madam, I'm Adam.\n    1 on 1\n    In girum imus nocte et consumimur igni\n    END\n \nfor @tests { say $_ ~~ Palindrom, \"\\t\", $_ }\n```\n\nOutput:\n\n```\nTrue\tA man, a plan, a canal: Panama.\nFalse\tMy dog has fleas\nTrue\tMadam, I'm Adam.\nFalse\t1 on 1\nTrue\tIn girum imus nocte et consumimur igni\n\n```"}]}
{"messages": [{"role": "user", "content": "For this task, a *number* is to be understood as a positive integer expressed in base ten,\nand a *palindromic* number is one that is equal to the integer formed by reversing its decimal digits.\n\nA number that is evenly divisible by the number formed by concatenating its\nfirst and last digits in that order is known as a **gapful number**.\nAll one─ and two─digit numbers have this property and accordingly only\nnumbers greater than or equal to **100** should be considered for this Rosetta Code task.\n\n(*Evenly divisible* here means divisible with no remainder.)\n\nExample\n\n**1037**   is a   **gapful**   number because it is evenly divisible by the\nnumber   **17**   which is formed by the first and last decimal digits\nof    **1037**.\n\nTask\n:   * Show   (nine sets)   the first   **20**   palindromic gapful numbers that   *end*   with:\n\n    :   :   * the digit   **1**\n            * the digit   **2**\n            * the digit   **3**\n            * the digit   **4**\n            * the digit   **5**\n            * the digit   **6**\n            * the digit   **7**\n            * the digit   **8**\n            * the digit   **9**\n\n    * Show   (nine sets, like above)   of palindromic gapful numbers:\n\n    :   :   * the last   **15**   palindromic gapful numbers   (out of      **100**)\n            * the last   **10**   palindromic gapful numbers   (out of   **1,000**)       {optional}\n\nFor other ways of expressing the (above) requirements, see the   *discussion*   page.\n\nNote\n\nAll palindromic gapful numbers are divisible by eleven.\n\nRelated tasks\n:   * palindrome detection.\n    * gapful numbers.\n\nAlso see\n:   * The OEIS entry:   A108343 gapful numbers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\n```\nconstant @digits = '0','1','2','3','4','5','6','7','8','9';\n\n# Infinite lazy iterator to generate palindromic \"gap\" numbers\nmy @npal = flat [ @digits ], [ '00','11','22','33','44','55','66','77','88','99' ],\n  {\n    sink @^previous, @^penultimate;\n    [ flat @digits.map: -> \\digit { @penultimate.map: digit ~ * ~ digit  } ]\n  } … *;\n\n# Individual lazy palindromic gapful number iterators for each start/end digit\nmy @gappal = (1..9).map: -> \\digit {\n    my \\divisor = digit + 10 * digit;\n    @npal.map: -> \\this { next unless (my \\test = digit ~ this ~ digit) %% divisor; test }\n}\n\n# Display\n( \"(Required) First 20 gapful palindromes:\",              ^20, 7\n  ,\"\\n(Required) 86th through 100th:\",                 85..99, 8\n  ,\"\\n(Optional) 991st through 1,000th:\",            990..999, 10\n  ,\"\\n(Extra stretchy) 9,995th through 10,000th:\", 9994..9999, 12\n  ,\"\\n(Meh) 100,000th:\",                                99999, 14\n).hyper(:1batch).map: -> $caption, $range, $fmt {\n    my $now = now;\n    say $caption;\n    put \"$_: \" ~ @gappal[$_-1][|$range].fmt(\"%{$fmt}s\") for 1..9;\n    say round( now - $now, .001 ), \" seconds\";\n}\n\n```\n\nOutput:\n\n```\n(Required) First 20 gapful palindromes:\n1:     121    1001    1111    1221    1331    1441    1551    1661    1771    1881    1991   10901   11011   12221   13431   14641   15851   17171   18381   19591\n2:     242    2002    2112    2222    2332    2442    2552    2662    2772    2882    2992   20702   21912   22022   23232   24442   25652   26862   28182   29392\n3:     363    3003    3333    3663    3993   31713   33033   36663  300003  303303  306603  309903  312213  315513  318813  321123  324423  327723  330033  333333\n4:     484    4004    4224    4444    4664    4884   40304   42724   44044   46464   48884  400004  401104  402204  403304  404404  405504  406604  407704  408804\n5:    5005    5115    5225    5335    5445    5555    5665    5775    5885    5995   50105   51315   52525   53735   54945   55055   56265   57475   58685   59895\n6:    6006    6336    6666    6996   61116   64746   66066   69696  600006  603306  606606  609906  612216  615516  618816  621126  624426  627726  630036  633336\n7:    7007    7777   77077  700007  707707  710017  717717  720027  727727  730037  737737  740047  747747  750057  757757  760067  767767  770077  777777  780087\n8:    8008    8448    8888   80608   86768   88088  800008  802208  804408  806608  808808  821128  823328  825528  827728  829928  840048  842248  844448  846648\n9:    9009    9999   94149   99099  900009  909909  918819  927729  936639  945549  954459  963369  972279  981189  990099  999999 9459549 9508059 9557559 9606069\n0.111 seconds\n\n(Required) 86th through 100th:\n1:   165561   166661   167761   168861   169961   170071   171171   172271   173371   174471   175571   176671   177771   178871   179971\n2:   265562   266662   267762   268862   269962   270072   271172   272272   273372   274472   275572   276672   277772   278872   279972\n3: 30366303 30399303 30422403 30455403 30488403 30511503 30544503 30577503 30600603 30633603 30666603 30699603 30722703 30755703 30788703\n4:  4473744  4485844  4497944  4607064  4619164  4620264  4632364  4644464  4656564  4668664  4681864  4693964  4803084  4815184  4827284\n5:   565565   566665   567765   568865   569965   570075   571175   572275   573375   574475   575575   576675   577775   578875   579975\n6: 60399306 60422406 60455406 60488406 60511506 60544506 60577506 60600606 60633606 60666606 60699606 60722706 60755706 60788706 60811806\n7: 72299227 72322327 72399327 72422427 72499427 72522527 72599527 72622627 72699627 72722727 72799727 72822827 72899827 72922927 72999927\n8: 80611608 80622608 80633608 80644608 80655608 80666608 80677608 80688608 80699608 80800808 80811808 80822808 80833808 80844808 80855808\n9: 95311359 95400459 95499459 95588559 95677659 95766759 95855859 95944959 96033069 96122169 96211269 96300369 96399369 96488469 96577569\n0.046 seconds\n\n(Optional) 991st through 1,000th:\n1:   17799771   17800871   17811871   17822871   17833871   17844871   17855871   17866871   17877871   17888871\n2:   27799772   27800872   27811872   27822872   27833872   27844872   27855872   27866872   27877872   27888872\n3: 3084004803 3084334803 3084664803 3084994803 3085225803 3085555803 3085885803 3086116803 3086446803 3086776803\n4:  482282284  482414284  482535284  482656284  482777284  482898284  482909284  483020384  483141384  483262384\n5:   57800875   57811875   57822875   57833875   57844875   57855875   57866875   57877875   57888875   57899875\n6: 6084004806 6084334806 6084664806 6084994806 6085225806 6085555806 6085885806 6086116806 6086446806 6086776806\n7: 7452992547 7453223547 7453993547 7454224547 7454994547 7455225547 7455995547 7456226547 7456996547 7457227547\n8: 8085995808 8086006808 8086116808 8086226808 8086336808 8086446808 8086556808 8086666808 8086776808 8086886808\n9: 9675005769 9675995769 9676886769 9677777769 9678668769 9679559769 9680440869 9681331869 9682222869 9683113869\n0.282 seconds\n\n(Extra stretchy) 9,995th through 10,000th:\n1:   1787447871   1787557871   1787667871   1787777871   1787887871   1787997871\n2:   2787447872   2787557872   2787667872   2787777872   2787887872   2787997872\n3: 308757757803 308760067803 308763367803 308766667803 308769967803 308772277803\n4:  48326662384  48327872384  48329192384  48330303384  48331513384  48332723384\n5:   5787447875   5787557875   5787667875   5787777875   5787887875   5787997875\n6: 608760067806 608763367806 608766667806 608769967806 608772277806 608775577806\n7: 746951159647 746958859647 746961169647 746968869647 746971179647 746978879647\n8: 808690096808 808691196808 808692296808 808693396808 808694496808 808695596808\n9: 968688886869 968697796869 968706607869 968715517869 968724427869 968733337869\n3.114 seconds\n\n(Meh) 100,000th:\n1:   178788887871\n2:   278788887872\n3: 30878611687803\n4:  4833326233384\n5:   578789987875\n6: 60878611687806\n7: 74826144162847\n8: 80869688696808\n9: 96878077087869\n32.603 seconds\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show all palindromic primes   **n**,     where    **n   <   1000**"}, {"role": "assistant", "content": "```\nsay \"{+$_} matching numbers:\\n{.batch(10)».fmt('%3d').join: \"\\n\"}\"\n    given (^1000).grep: { .is-prime and $_ eq .flip };\n\n```\n\nOutput:\n\n```\n20 matching numbers:\n  2   3   5   7  11 101 131 151 181 191\n313 353 373 383 727 757 787 797 919 929\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind palindromic primes   **n**   in base 16,   where   **n   <   50010**"}, {"role": "assistant", "content": "Trivial modification of Palindromic primes task.\n\n```\nsay \"{+$_} matching numbers:\\n{.batch(10)».fmt('%3X').join: \"\\n\"}\"\n    given (^500).grep: { .is-prime and .base(16) eq .base(16).flip };\n\n```\n\nOutput:\n\n```\n13 matching numbers:\n  2   3   5   7   B   D  11 101 151 161\n191 1B1 1C1\n```"}]}
{"messages": [{"role": "user", "content": "Primes are prime no matter which base they are expressed in. Some numeric strings are prime in a large number of bases. (Not the *same* prime, but **a** prime.)\n\nFor example\n\nThe numeric string \"255\", while obviously not a prime in base 10, **is** a prime in bases:\n\n```\n     6   8  12  14  18  24  26  32  36  38  72  84  86  92  96 102 104 108 128 134\n   138 144 158 164 188 216 224 236 242 246 252 254 264 272 294 318 332 344 348 368\n   374 392 396 408 428 432 446 456 468 476 482 512 522 528 542 546 552 566 572 576\n   578 594 596 602 606 614 618 626 654 702 714 722 728 756 762 774 776 788 806 816\n   818 822 828 836 848 864 866 872 882 888 902 908 912 918 924 932 936 942 944 956\n   966 986 998\n\n```\n\namong others.\n\nThere *are* numeric strings however, that are not a prime in **any** base. Confining ourselves to 'decimal' numeric strings; the single digit numeric primes are prime in every base where they are a valid number.\n\nE.G.\n\nThe numeric string **\"2\"** is a prime in *every* base except base 2, where it is invalid.\n\nThe numeric string **\"3\"** is a prime in *every* base except base 2 and 3, where it is invalid.\n\n**\"4\"** is *not* a prime in every base except bases 2, 3, and 4 where it is an invalid number (and hence not a prime there either.)\n\nIn general, even pan-base non-primes are much more prevalent than odd, though both are fairly common.\n\nWith the exception of **\"10\"**, numeric strings that end in 0 are composite in every base where they are valid.\n\nNumeric strings where the greatest common divisor of all of the digits is more than 1 are composite in every base.\n\nIf a \"decimal\" numeric string N is composite in every base up to base N, it is composite in every base.\n\nThe digit **1** is an odd-ball case as it is neither prime nor composite. It typically is *not* included, but due to the ambiguous wording, would not be wrong if it is.\n\nTask\n\n* Find and display, here on this page, the first 40 pan-base non-prime \"base 10\" numeric strings.\n* Find and display, here on this page, the first 20 **odd** pan-base non-prime \"base 10\" numeric strings.\n* Find and display the count of pan-base non-prime \"base 10\" numeric strings up to at least the numeric string \"1000\".\n* What percentage of them are odd / even?\n\nSee also\n\n* OEIS A121719 - Strings of digits which are composite regardless of the base in which they are interpreted. Exclude bases in which numbers are not interpretable."}, {"role": "assistant", "content": "```\nuse Base::Any;\nuse List::Divvy;\n\nmy @np = 4,6,8,9, |lazy (11..*).hyper.grep( -> $n { ($n.substr(*-1) eq '0') || (1 < [gcd] $n.comb».Int) || none (2..$n).map: { try \"$n\".&from-base($_).is-prime } } );\n\nput \"First 50 pan-base composites:\\n\" ~ @np[^50].batch(10)».fmt(\"%3s\").join: \"\\n\";\nput \"\\nFirst 20 odd pan-base composites:\\n\" ~ @np.grep(* % 2)[^20].batch(10)».fmt(\"%3s\").join: \"\\n\";\n\nmy $threshold = 2500;\nput \"\\nCount of pan-base composites up to and including $threshold: \" ~ +@np.&upto($threshold);\n\nput \"Percent odd  up to and including $threshold: \" ~ +@np.&upto($threshold).grep(* % 2) / +@np.&upto($threshold) × 100;\nput \"Percent even up to and including $threshold: \" ~ +@np.&upto($threshold).grep(* %% 2) / +@np.&upto($threshold) × 100;\n\n```\n\nOutput:\n\n```\nFirst 50 pan-base composites:\n  4   6   8   9  20  22  24  26  28  30\n 33  36  39  40  42  44  46  48  50  55\n 60  62  63  64  66  68  69  70  77  80\n 82  84  86  88  90  93  96  99 100 110\n112 114 116 118 120 121 130 132 134 136\n\nFirst 20 odd pan-base composites:\n  9  33  39  55  63  69  77  93  99 121\n143 165 169 187 231 253 273 275 297 299\n\nCount of pan-base composites up to and including 2500: 953\nPercent odd  up to and including 2500: 16.894019\nPercent even up to and including 2500: 83.105981\n```"}]}
{"messages": [{"role": "user", "content": "Adrian Monk has problems and an assistant, Sharona Fleming. Sharona can deal with most of Adrian's problems except his lack of punctuality paying her remuneration. Two pay checks down and she prepares him pancakes for breakfast. Knowing that he will be unable to eat them unless they are stacked in ascending order of size she leaves him only a skillet which he can insert at any point in the pile and flip all the above pancakes, repeating until the pile is sorted. Sharona has left the pile of n pancakes such that the maximum number of flips is required. Adrian is determined to do this in as few flips as possible. This sequence n->p(n) is known as the Pancake numbers.\n\nThe task is to determine p(n) for n = 1 to 9, and for each show an example requiring p(n) flips.\n\nSorting\\_algorithms/Pancake\\_sort actually performs the sort some giving the number of flips used. How do these compare with p(n)?\n\nFew people know p(20), generously I shall award an extra credit for anyone doing more than p(16).\n\nWarning\n:   It is known that p(19) is 22 (see in particular the discussion at A058986); thus any algorithm that claims otherwise must be treated with caution.\n:   Note that the original \"cheeky partial answer\" of Phix has since been updated (5/12/2020), and/but just that, with no examples as asked for, *will* get your entry marked as incomplete.\n\nReferences\n\n1. Bill Gates and the pancake problem\n2. A058986"}, {"role": "assistant", "content": "### Maximum number of flips only\n\n**Translation of**: Phix\n\nThis is the translation of the second version (5th dec 2020). It differs from the first version for p(19).\n\n```\n# Updated: 20240901 Raku programming solution\n\nsub pancake(Int $n) {\n   loop ( my ($gap, $pg, $sum_gaps, $adj) = <2 1 2 -1> ; ; $sum_gaps += $gap ) {\n      $sum_gaps < $n ?? ( $adj += 1 ) !! return $n + $adj;\n      ($pg, $gap) = ($gap, $gap + $pg)\n   }\n}\n\nfor (1..20).rotor(5) { @_».&{printf \"p(%2d) = %2d   \",$_,pancake $_} and say() }\n\n```\n\nOutput:\n\n```\np( 1) =  0   p( 2) =  1   p( 3) =  3   p( 4) =  4   p( 5) =  5\np( 6) =  7   p( 7) =  8   p( 8) =  9   p( 9) = 10   p(10) = 11\np(11) = 13   p(12) = 14   p(13) = 15   p(14) = 16   p(15) = 17\np(16) = 18   p(17) = 19   p(18) = 20   p(19) = 22   p(20) = 23\n```\n\nYou may Attempt This Online!\n\n### Maximum number of flips plus examples using exhaustive search\n\n**Translation of**: Go\n\n```\nsub pancake(\\n) {\n   my @goalStack = (my \\numStacks = $ = 1)..n ; \n   my %newStacks = my %stacks = @goalStack.Str, 0 ;\n   for 1..1000 -> \\k { \n      my %nextStacks = (); \n      for %newStacks.keys».split(' ') X 2..n -> (@arr, \\pos) {\n         given flat @arr[0..^pos].reverse, @arr[pos..*-1] {\n            %nextStacks{$_.Str} = k unless %stacks{$_.Str}:exists\n         }\n      }\n      %stacks ,= (%newStacks = %nextStacks);\n      my $perms    = %stacks.elems;\n      my %inverted = %stacks.antipairs;      # this causes loss on examples \n      my \\max_key  = %inverted.keys.max;     # but not critical for our purpose\n      $perms == numStacks ?? return %inverted{max_key}, k-1 !! numStacks=$perms\n   }\n   return '', 0\n}\n\nsay \"The maximum number of flips to sort a given number of elements is:\";\nfor 1..9 -> $j { given pancake($j) { say \"pancake($j) = $_[1] example: $_[0]\" }}\n\n```\n\nOutput:\n\n```\nThe maximum number of flips to sort a given number of elements is:\npancake(1) = 0 example: 1\npancake(2) = 1 example: 2 1\npancake(3) = 3 example: 1 3 2\npancake(4) = 4 example: 2 4 1 3\npancake(5) = 5 example: 5 1 3 2 4\npancake(6) = 7 example: 5 3 6 1 4 2\npancake(7) = 8 example: 1 5 3 7 4 2 6\npancake(8) = 9 example: 6 1 8 3 5 7 2 4\npancake(9) = 10 example: 3 6 9 2 5 8 4 7 1\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nThe following problem is taken from Project Euler problem 41.\n  \n  \nWe shall say that an n-digit number is pandigital if it makes use of all the digits 1 to n exactly once. For example, 2143 is a 4-digit pandigital and is also prime.\n  \n  \nWhat is the largest **pandigital prime** that exists?\n\nOptional\n\nFurther say that an n+1-digit number is pandigital0 if it makes use of all the digits 0 to n exactly once. For example 10243 is a 5-digit pandigital0 and is also prime.\n  \n  \nWhat is the largest **pandigital0 prime** that exists?\n  \n  \nAssume that the problem is talking about **decimal** numbers."}, {"role": "assistant", "content": "```\nsay ($_..7).reverse.permutations».join.first: &is-prime for 1,0;\n\n```\n\nOutput:\n\n```\n7652413\n76540231\n```"}]}
{"messages": [{"role": "user", "content": "A pangram is a sentence that contains all the letters of the English alphabet at least once.\n\nFor example:   *The quick brown fox jumps over the lazy dog*.\n\nTask\n\nWrite a function or method to check a sentence to see if it is a   pangram   (or not)   and show its use.\n\nRelated tasks\n:   * determine if a string has all the same characters\n    * determine if a string has all unique characters"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nconstant Eng = set 'a' .. 'z';\nconstant Cyr = (set 'а' .. 'ё') (-) (set 'ъ', 'ѐ');\nconstant Hex = set 'a' .. 'f';\n\nsub pangram($str, Set $alpha = Eng) {\n  $alpha ⊆ $str.lc.comb\n}\n\nsay pangram(\"The quick brown fox jumps over the lazy dog.\");\nsay pangram(\"My dog has fleas.\");\nsay pangram(\"My dog has fleas.\", Hex);\nsay pangram(\"My dog backs fleas.\", Hex);\nsay pangram \"Съешь же ещё этих мягких французских булок, да выпей чаю\", Cyr;\n\n```\n\nOutput:\n\n```\nTrue\nFalse\nFalse\nTrue\nTrue\n```"}]}
{"messages": [{"role": "user", "content": "This organic chemistry task is essentially to implement a tree enumeration algorithm.\n\nTask\n\nEnumerate, without repetitions and in order of increasing size, all possible paraffin molecules (also known as alkanes).\n\nParaffins are built up using only carbon atoms, which has four bonds, and hydrogen, which has one bond.   All bonds for each atom must be used, so it is easiest to think of an alkane as linked carbon atoms forming the \"backbone\" structure, with adding hydrogen atoms linking the remaining unused bonds.\n\nIn a paraffin, one is allowed neither double bonds (two bonds between the same pair of atoms), nor cycles of linked carbons.   So all paraffins with   **n**   carbon atoms share the empirical formula     CnH2n+2\n\nBut for all   **n** ≥ 4   there are several distinct molecules (\"isomers\") with the same formula but different structures.\n\nThe number of isomers rises rather rapidly when   **n**   increases.\n\nIn counting isomers it should be borne in mind that the four bond positions on a given carbon atom can be freely interchanged and bonds rotated (including 3-D \"out of the paper\" rotations when it's being observed on a flat diagram),   so rotations or re-orientations of parts of the molecule (without breaking bonds) do not give different isomers.   So what seem at first to be different molecules may in fact turn out to be different orientations of the same molecule.\n\nExample\n\nWith   **n** = 3   there is only one way of linking the carbons despite the different orientations the molecule can be drawn;   and with   **n** = 4   there are two configurations:\n\n:   :   :   * a   straight   chain:     (CH3)(CH2)(CH2)(CH3)\n            * a branched chain:       (CH3)(CH(CH3))(CH3)\n\nDue to bond rotations, it doesn't matter which direction the branch points in.\n\nThe phenomenon of \"stereo-isomerism\" (a molecule being different from its mirror image due to the actual 3-D arrangement of bonds) is ignored for the purpose of this task.\n\nThe input is the number   **n**   of carbon atoms of a molecule (for instance **17**).\n\nThe output is how many different different paraffins there are with   **n**   carbon atoms (for instance   24,894   if   **n** = 17).\n\nThe sequence of those results is visible in the OEIS entry:\n\n:   :   :   A00602: number of n-node unrooted quartic trees; number of n-carbon alkanes C(n)H(2n+2) ignoring stereoisomers.\n\nThe sequence is (the index starts from zero, and represents the number of carbon atoms):\n\n```\n1, 1, 1, 1, 2, 3, 5, 9, 18, 35, 75, 159, 355, 802, 1858, 4347, 10359,\n24894, 60523, 148284, 366319, 910726, 2278658, 5731580, 14490245,\n36797588, 93839412, 240215803, 617105614, 1590507121, 4111846763,\n10660307791, 27711253769, ...\n\n```\n\nExtra credit\n\nShow the paraffins in some way.\n\nA flat 1D representation, with arrays or lists is enough, for instance:\n\n```\n*Main> all_paraffins 1\n                        [CCP H H H H]\n*Main> all_paraffins 2\n                        [BCP (C H H H) (C H H H)]\n*Main> all_paraffins 3\n                        [CCP H H (C H H H) (C H H H)]\n*Main> all_paraffins 4\n                        [BCP (C H H (C H H H)) (C H H (C H H H)),\n                         CCP H (C H H H) (C H H H) (C H H H)]\n*Main> all_paraffins 5\n                        [CCP H H (C H H (C H H H)) (C H H (C H H H)),\n                         CCP H (C H H H) (C H H H) (C H H (C H H H)),\n                         CCP (C H H H) (C H H H) (C H H H) (C H H H)]\n*Main> all_paraffins 6\n                        [BCP (C H H (C H H (C H H H))) (C H H (C H H (C H H H))),\n                         BCP (C H H (C H H (C H H H))) (C H (C H H H) (C H H H)),\n                         BCP (C H (C H H H) (C H H H)) (C H (C H H H) (C H H H)),\n                         CCP H (C H H H) (C H H (C H H H)) (C H H (C H H H)),\n                         CCP (C H H H) (C H H H) (C H H H) (C H H (C H H H))]\n\n```\n\nShowing a basic 2D ASCII-art representation of the paraffins is better; for instance (molecule names aren't necessary):\n\n```\n       methane          ethane               propane               isobutane\n                     \n          H              H   H              H   H   H              H   H   H\n          │              │   │              │   │   │              │   │   │\n      H ─ C ─ H      H ─ C ─ C ─ H      H ─ C ─ C ─ C ─ H      H ─ C ─ C ─ C ─ H\n          │              │   │              │   │   │              │   │   │\n          H              H   H              H   H   H              H   │   H\n                                                                       │\n                                                                   H ─ C ─ H\n                                                                       │\n                                                                       H\n\n```\n\nLinks\n\n* A paper that explains the problem and its solution in a functional language:\n\nhttp://www.cs.wright.edu/~tkprasad/courses/cs776/paraffins-turner.pdf\n\n* A Haskell implementation:\n\nhttps://github.com/ghc/nofib/blob/master/imaginary/paraffins/Main.hs\n\n* A Scheme implementation:\n\nhttp://www.ccs.neu.edu/home/will/Twobit/src/paraffins.scm\n\n* A Fortress implementation:         (this site has been closed)\n\nhttp://java.net/projects/projectfortress/sources/sources/content/ProjectFortress/demos/turnersParaffins0.fss?rev=3005"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.04\n\nCounting only, same algorithm as the C solution with some refactorings.\n\nNote how lexical scoping — rather than global variables or repeated arguments — is used to pass down information to subroutines.\n\n```\nsub count-unrooted-trees(Int $max-branches, Int $max-weight) {\n    my @rooted   = flat 1,1,0 xx $max-weight - 1;\n    my @unrooted = flat 1,1,0 xx $max-weight - 1;\n\n    sub count-trees-with-centroid(Int $radius) {\n        sub add-branches(\n            Int $branches,        # number of branches to add\n            Int $w,               # weight of heaviest branch to add\n            Int $weight  is copy, # accumulated weight of tree\n            Int $choices is copy, # number of choices so far\n        ) {\n            $choices *= @rooted[$w];\n            for 1 .. $branches -> $b {\n                ($weight += $w) <= $max-weight or last;\n                @unrooted[$weight] += $choices if $weight > 2*$radius;\n                if $b < $branches {\n                    @rooted[$weight] += $choices;\n                    add-branches($branches - $b, $_, $weight, $choices) for 1 ..^ $w;\n                    $choices = $choices * (@rooted[$w] + $b) div ($b + 1);\n                }\n            }\n        }\n        add-branches($max-branches, $radius, 1, 1);\n    }\n\n    sub count-trees-with-bicentroid(Int $weight) {\n        if $weight %% 2 {\n            my \\halfs = @rooted[$weight div 2];\n            @unrooted[$weight] += (halfs * (halfs + 1)) div 2;\n        }\n    }\n\n    gather {\n        take 1;\n        for 1 .. $max-weight {\n            count-trees-with-centroid($_);\n            count-trees-with-bicentroid($_);\n            take @unrooted[$_];\n        }\n    }\n}\n\nmy constant N = 100;\nmy @paraffins = count-unrooted-trees(4, N);\nsay .fmt('%3d'), ': ', @paraffins[$_] for flat 1 .. 30, N;\n\n```\n\nOutput:\n\n```\n  1: 1\n  2: 1\n  3: 1\n  4: 2\n  5: 3\n  6: 5\n  7: 9\n  8: 18\n  9: 35\n 10: 75\n 11: 159\n 12: 355\n 13: 802\n 14: 1858\n 15: 4347\n 16: 10359\n 17: 24894\n 18: 60523\n 19: 148284\n 20: 366319\n 21: 910726\n 22: 2278658\n 23: 5731580\n 24: 14490245\n 25: 36797588\n 26: 93839412\n 27: 240215803\n 28: 617105614\n 29: 1590507121\n 30: 4111846763\n100: 5921072038125809849884993369103538010139\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind, through brute force, the five-letter passwords corresponding with the following SHA-256 hashes:\n\n```\n1. 1115dd800feaacefdf481f1f9070374a2a81e27880f187396db67958b207cbad\n2. 3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b\n3. 74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f\n\n```\n\nYour program should naively iterate through all possible passwords consisting only of five lower-case ASCII English letters. It should use concurrent or parallel processing, if your language supports that feature. You may calculate SHA-256 hashes by calling a library or through a custom implementation. Print each matching password, along with its SHA-256 hash.\n\nRelated task: SHA-256"}, {"role": "assistant", "content": "(formerly Perl 6)\nThis solution can be changed from parallel to serial by removing the `.race` method.\n\n```\nuse Digest::SHA256::Native;\nconstant @alpha2 = [X~] <a   m p y z> xx 2;\nconstant @alpha3 = [X~] <e l m p x z> xx 3;\n\nmy %WANTED = set <\n    3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b\n    74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f\n    1115dd800feaacefdf481f1f9070374a2a81e27880f187396db67958b207cbad\n>;\n\nsub find_it ( $first_two ) {\n    for $first_two «~« @alpha3 -> \\password {\n        my \\digest_hex = sha256-hex(password);\n        return \"{password} => {digest_hex}\" if %WANTED{digest_hex}\n    }\n    ()\n}\n\n.say for flat @alpha2.race(:1batch).map: { find_it($_) };\n\n```\n\nOutput:\n\n```\napple => 3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b\nmmmmm => 74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f\nzyzzx => 1115dd800feaacefdf481f1f9070374a2a81e27880f187396db67958b207cbad\n```\n\nTesters can adjust the run speed by replacing the @alpha constants with one of the below:\n\n```\n# True to actual RC task, but slowest\nconstant @alpha2 = 'aa'  ..  'zz';\nconstant @alpha3 = 'aaa' .. 'zzz';\n\n# Reduced alphabets for speed during development & testing\nconstant @alpha2 = [X~] <a   m p y z> xx 2;\nconstant @alpha3 = [X~] <e l m p x z> xx 3;\n\n```"}]}
{"messages": [{"role": "user", "content": "Many programming languages allow you to specify computations to be run in parallel.\nWhile Concurrent computing is focused on concurrency,\nthe purpose of this task is to distribute time-consuming calculations\non as many CPUs as possible.\n\nAssume we have a collection of numbers, and want to find the one\nwith the largest minimal prime factor\n(that is, the one that contains relatively large factors).\nTo speed up the search, the factorization should be done\nin parallel using separate threads or processes,\nto take advantage of multi-core CPUs.\n\nShow how this can be formulated in your language.\nParallelize the factorization of those numbers,\nthen search the returned list of numbers and factors\nfor the largest minimal factor,\nand return that number and its prime factors.\n\nFor the prime number decomposition\nyou may use the solution of the Prime decomposition task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nTakes the list of numbers and converts them to a HyperSeq that is stored in a variable and evaluated concurrently. HyperSeqs overload map and grep to convert and pick values in worker threads. The runtime will pick the number of OS-level threads and assign worker threads to them while avoiding stalling in any part of the program. A HyperSeq is lazy, so the computation of values will happen in chunks as they are requested.\n\nThe hyper (and race) method can take two parameters that will tweak how the parallelization occurs: :degree and :batch. :degree is the number of worker threads to allocate to the job. By default it is set to the number of physical cores available. If you have a hyper threading processor, and the tasks are not cpu bound, it may be useful to raise that number but it is a reasonable default. :batch is how many sub-tasks are parceled out at a time to each worker thread. Default is 64. For small numbers of cpu intensive tasks a lower number will likely be better, but too low may make the dispatch overhead cancel out the benefit of threading. Conversely, too high will over-burden some threads and starve others. Over long-running processes with many hundreds / thousands of sub-tasks, the scheduler will automatically adjust the batch size up or down to try to keep the pipeline filled.\n\nOn my system, under the load I was running, I found a batch size of 3 to be optimal for this task. May be different for different systems and different loads.\n\nAs a relative comparison, perform the same factoring task on the same set of 100 numbers as found in the SequenceL example, using varying numbers of threads. The absolute speed numbers are not very significant, they will vary greatly between systems, this is more intended as a comparison of relative throughput. On a Core i7-4770 @ 3.40GHz with 4 cores and hyper-threading under Linux, there is a distinct pattern where more threads on physical cores give reliable increases in throughput. Adding hyperthreads may (and, in this case, does seem to) give some additional marginal benefit.\n\nUsing the prime-factors routine as defined in the prime decomposition task.\n\n```\nmy @nums = 64921987050997300559,  70251412046988563035,  71774104902986066597,\n           83448083465633593921,  84209429893632345702,  87001033462961102237,\n           87762379890959854011,  89538854889623608177,  98421229882942378967,\n           259826672618677756753, 262872058330672763871, 267440136898665274575,\n           278352769033314050117, 281398154745309057242, 292057004737291582187;\n\nmy @factories = @nums.hyper(:3batch).map: &prime-factors;\nprintf \"%21d factors: %s\\n\", |$_ for @nums Z @factories;\nmy $gmf = {}.append(@factories»[0] »=>« @nums).max: +*.key;\nsay \"\\nGreatest minimum factor: \", $gmf.key;\nsay \"from: { $gmf.value }\\n\";\nsay 'Run time: ', now - INIT now;\nsay '-' x 80;\n\n# For amusements sake and for relative comparison, using the same 100\n# numbers as in the SequenceL example, testing with different numbers of threads.\n\n@nums = <625070029 413238785 815577134 738415913 400125878 967798656 830022841\n   774153795 114250661 259366941 571026384 522503284 757673286 509866901 6303092\n   516535622 177377611 520078930 996973832 148686385 33604768 384564659 95268916\n   659700539 149740384 320999438 822361007 701572051 897604940 2091927 206462079\n   290027015 307100080 904465970 689995756 203175746 802376955 220768968 433644101\n   892007533 244830058 36338487 870509730 350043612 282189614 262732002 66723331\n   908238109 635738243 335338769 461336039 225527523 256718333 277834108 430753136\n   151142121 602303689 847642943 538451532 683561566 724473614 422235315 921779758\n   766603317 364366380 60185500 333804616 988528614 933855820 168694202 219881490\n   703969452 308390898 567869022 719881996 577182004 462330772 770409840 203075270\n   666478446 351859802 660783778 503851023 789751915 224633442 347265052 782142901\n   43731988 246754498 736887493 875621732 594506110 854991694 829661614 377470268\n   984990763 275192380 39848200 892766084 76503760>».Int;\n\nfor 1..8 -> $degree {\n    my $start = now;\n    my \\factories = @nums.hyper(:degree($degree), :3batch).map: &prime-factors;\n    my $gmf = {}.append(factories»[0] »=>« @nums).max: +*.key;\n    say \"\\nFactoring {+@nums} numbers, greatest minimum factor: {$gmf.key}\";\n    say \"Using: $degree thread{ $degree > 1 ?? 's' !! ''}\";\n    my $end = now;\n    say 'Run time: ', $end - $start, ' seconds.';\n}\n\n# Prime factoring routines from the Prime decomposition task\nsub prime-factors ( Int $n where * > 0 ) {\n    return $n if $n.is-prime;\n    return [] if $n == 1;\n    my $factor = find-factor( $n );\n    sort flat prime-factors( $factor ), prime-factors( $n div $factor );\n}\n\nsub find-factor ( Int $n, $constant = 1 ) {\n    return 2 unless $n +& 1;\n    if (my $gcd = $n gcd 6541380665835015) > 1 {\n        return $gcd if $gcd != $n\n    }\n    my $x      = 2;\n    my $rho    = 1;\n    my $factor = 1;\n    while $factor == 1 {\n        $rho *= 2;\n        my $fixed = $x;\n        for ^$rho {\n            $x = ( $x * $x + $constant ) % $n;\n            $factor = ( $x - $fixed ) gcd $n;\n            last if 1 < $factor;\n        }\n    }\n    $factor = find-factor( $n, $constant + 1 ) if $n == $factor;\n    $factor;\n}\n\n```\n\nTypical output:\n\n```\n 64921987050997300559 factors: 736717 88123373087627\n 70251412046988563035 factors: 5 43 349 936248577956801\n 71774104902986066597 factors: 736717 97424255043641\n 83448083465633593921 factors: 736717 113270202079813\n 84209429893632345702 factors: 2 3 3 3 41 107880821 352564733\n 87001033462961102237 factors: 736717 118092881612561\n 87762379890959854011 factors: 3 3 3 3 331 3273372119315201\n 89538854889623608177 factors: 736717 121537652707381\n 98421229882942378967 factors: 736717 133594351539251\n259826672618677756753 factors: 7 37118096088382536679\n262872058330672763871 factors: 3 47 1864340839224629531\n267440136898665274575 factors: 3 5 5 71 50223499887073291\n278352769033314050117 factors: 7 39764681290473435731\n281398154745309057242 factors: 2 809 28571 46061 132155099\n292057004737291582187 factors: 7 151 373 2339 111323 2844911\n\nGreatest minimum factor: 736717\nfrom: 64921987050997300559 71774104902986066597 83448083465633593921 87001033462961102237 89538854889623608177 98421229882942378967\n\nRun time: 0.2968644\n--------------------------------------------------------------------------------\n\nFactoring 100 numbers, greatest minimum factor: 782142901\nUsing: 1 thread\nRun time: 0.3438752 seconds.\n\nFactoring 100 numbers, greatest minimum factor: 782142901\nUsing: 2 threads\nRun time: 0.2035372 seconds.\n\nFactoring 100 numbers, greatest minimum factor: 782142901\nUsing: 3 threads\nRun time: 0.14177834 seconds.\n\nFactoring 100 numbers, greatest minimum factor: 782142901\nUsing: 4 threads\nRun time: 0.110738 seconds.\n\nFactoring 100 numbers, greatest minimum factor: 782142901\nUsing: 5 threads\nRun time: 0.10142434 seconds.\n\nFactoring 100 numbers, greatest minimum factor: 782142901\nUsing: 6 threads\nRun time: 0.10954304 seconds.\n\nFactoring 100 numbers, greatest minimum factor: 782142901\nUsing: 7 threads\nRun time: 0.097886 seconds.\n\nFactoring 100 numbers, greatest minimum factor: 782142901\nUsing: 8 threads\nRun time: 0.0927695 seconds.\n```\n\nBeside HyperSeq and its (allowed to be) out-of-order equivalent RaceSeq, Rakudo supports primitive threads, locks and highlevel promises. Using channels and supplies values can be move thread-safely from one thread to another. A react-block can be used as a central hub for message passing.\n\nIn Raku most errors are bottled up Exceptions inside Failure objects that remember where they are created and thrown when used. This is useful to pass errors from one thread to another without losing file and line number of the source file that caused the error.\n\nIn the future hyper operators, junctions and feeds will be candidates for autothreading."}]}
{"messages": [{"role": "user", "content": "Parameterized SQL statements are an easy way to avoid SQL injection attacks. SQL drivers and libraries will automatically \"sanitize\" input to parameterized SQL statements to avoid these catastrophic database attacks. Second, parameterized SQL performs better. A lot better.\n\nUsing a SQL update statement like this one (spacing is optional):\n\n```\nUPDATE players\n   SET name = 'Smith, Steve', score = 42, active = true\n   WHERE jerseyNum = 99\n\n```\n\nshow how to make a parameterized SQL statement, set the parameters to the values given above, and execute the statement.\n\n> Non-parameterized SQL is the GoTo statement of database programming. Don't do it, and make sure your coworkers don't either."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nuse DBIish;\n\nmy $db = DBIish.connect('DBI:mysql:mydatabase:host','login','password');\n\nmy $update = $db.prepare(\"UPDATE players SET name = ?, score = ?, active = ? WHERE jerseyNum = ?\");\n\nmy $rows-affected = $update.execute(\"Smith, Steve\",42,'true',99);\n\n```"}]}
{"messages": [{"role": "user", "content": "Parametric polymorphism is a way to define types or functions that are generic over other types. The genericity can be expressed by using *type variables* for the parameter type, and by a mechanism to explicitly or implicitly replace the type variables with concrete types when necessary.\n\nTask\n\nWrite a small example for a type declaration that is parametric over another type, together with a short bit of code (and its type signature) that uses it.\n\nA good example is a container type, let's say a binary tree, together with some function that traverses the tree, say, a *map*-function that operates on every element of the tree.\n\nThis language feature only applies to statically-typed languages."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\n```\nrole BinaryTree[::T] {\n    has T $.value;\n    has BinaryTree[T] $.left;\n    has BinaryTree[T] $.right;\n\n    method replace-all(T $value) {\n        $!value = $value;\n        $!left.replace-all($value) if $!left.defined;\n        $!right.replace-all($value) if $!right.defined;\n    }\n}\n\nclass IntTree does BinaryTree[Int] { }\n\nmy IntTree $it .= new(value => 1,\n                      left  => IntTree.new(value => 2),\n                      right => IntTree.new(value => 3));\n\n$it.replace-all(42);\nsay $it;\n\n```\n\nOutput:\n\n```\nIntTree.new(value => 42, left => IntTree.new(value => 42, left => BinaryTree[T], right => BinaryTree[T]), right => IntTree.new(value => 42, left => BinaryTree[T], right => BinaryTree[T]))\n```"}]}
{"messages": [{"role": "user", "content": "The purpose of this task is to demonstrate parsing of text-format IP addresses, using IPv4 and IPv6.\n\nTaking the following as inputs:\n\n:   :   :   |  |  |\n            | --- | --- |\n            | 127.0.0.1 | The \"localhost\" IPv4 address |\n            | 127.0.0.1:80 | The \"localhost\" IPv4 address, with a specified port (80) |\n            | ::1 | The \"localhost\" IPv6 address |\n            | [::1]:80 | The \"localhost\" IPv6 address, with a specified port (80) |\n            | 2605:2700:0:3::4713:93e3 | Rosetta Code's primary server's public IPv6 address |\n            | [2605:2700:0:3::4713:93e3]:80 | Rosetta Code's primary server's public IPv6 address, with a specified port (80) |\n\nTask\n\nEmit each described IP address as a hexadecimal integer representing the address, the address space, and the port number specified, if any.\n\nIn languages where variant result types are clumsy, the result should be ipv4 or ipv6 address number, something which says which address space was represented, port number and something that says if the port was specified.\n\nExample\n\n**127.0.0.1**   has the address number   **7F000001**   (2130706433 decimal)\nin the ipv4 address space.\n\n**::ffff:127.0.0.1**   represents the same address in the ipv6 address space where it has the\naddress number   **FFFF7F000001**   (281472812449793 decimal).\n\n**::1**   has address number   **1**   and serves the same purpose in the ipv6 address\nspace that   **127.0.0.1**   serves in the ipv4 address space."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\ngrammar IP_Addr {\n    token TOP { ^ [ <IPv4> | <IPv6> ] $ }\n \n    token IPv4 {\n        [ <d8> +% '.' ] <?{ $<d8> == 4 }> <port>?\n                { @*by8 = @$<d8> }\n    }\n\n    token IPv6 {\n        |     <ipv6>\n        | '[' <ipv6> ']' <port>\n    }\n\n    token ipv6 {\n        | <h16> +% ':' <?{ $<h16> == 8 }>\n                { @*by16 = @$<h16> }\n \n        | [ (<h16>) +% ':']? '::' [ (<h16>) +% ':' ]? <?{ @$0 + @$1 ≤ 8 }>\n                { @*by16 = |@$0, |('0' xx 8 - (@$0 + @$1)), |@$1 }\n \n        | '::ffff:' <IPv4>\n                { @*by16 = |('0' xx 5), 'ffff', |(by8to16 @*by8) }\n    }\n\n    token d8  { (\\d+) <?{ $0 < 256   }> }\n    token d16 { (\\d+) <?{ $0 < 65536 }> }\n    token h16 { (<xdigit>+) <?{ $0.chars ≤ 4 }> }\n\n    token port {\n        ':' <d16> { $*port = +$<d16> }\n    }\n}\n\nsub by8to16 (@m) { gather for @m -> $a,$b { take ($a * 256 + $b).fmt(\"%04x\") } }\n\nmy @cases = <\n    127.0.0.1\n    127.0.0.1:80\n    ::1\n    [::1]:80\n    2605:2700:0:3::4713:93e3\n    [2605:2700:0:3::4713:93e3]:80\n    2001:db8:85a3:0:0:8a2e:370:7334\n    2001:db8:85a3::8a2e:370:7334\n    [2001:db8:85a3:8d3:1319:8a2e:370:7348]:443\n    192.168.0.1\n    ::ffff:192.168.0.1\n    ::ffff:71.19.147.227\n    [::ffff:71.19.147.227]:80\n    ::\n    256.0.0.0\n    g::1\n    0000\n    0000:0000\n    0000:0000:0000:0000:0000:0000:0000:0000\n    0000:0000:0000::0000:0000\n    0000::0000::0000:0000\n    ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff\n    ffff:ffff:ffff:fffg:ffff:ffff:ffff:ffff\n    fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff\n    fff:ffff:0:ffff:ffff:ffff:ffff:ffff\n>;\n\nfor @cases -> $addr {\n    my @*by8;\n    my @*by16;\n    my $*port;\n\n    IP_Addr.parse($addr);\n\n    say $addr;\n    if @*by16 {\n        say \"  IPv6: \", @*by16.map({:16(~$_)})».fmt(\"%04x\").join;\n        say \"  Port: \", $*port if $*port;\n    }\n    elsif @*by8 {\n        say \"  IPv4: \", @*by8».fmt(\"%02x\").join;\n        say \"  Port: \", $*port if $*port;\n    }\n    else {\n        say \"  BOGUS!\";\n    }\n    say '';\n}\n\n```\n\nOutput:\n\n```\n127.0.0.1\n  IPv4: 7f000001\n\n127.0.0.1:80\n  IPv4: 7f000001\n  Port: 80\n\n::1\n  IPv6: 00000000000000000000000000000001\n\n[::1]:80\n  IPv6: 00000000000000000000000000000001\n  Port: 80\n\n2605:2700:0:3::4713:93e3\n  IPv6: 260527000000000300000000471393e3\n\n[2605:2700:0:3::4713:93e3]:80\n  IPv6: 260527000000000300000000471393e3\n  Port: 80\n\n2001:db8:85a3:0:0:8a2e:370:7334\n  IPv6: 20010db885a3000000008a2e03707334\n\n2001:db8:85a3::8a2e:370:7334\n  IPv6: 20010db885a3000000008a2e03707334\n\n[2001:db8:85a3:8d3:1319:8a2e:370:7348]:443\n  IPv6: 20010db885a308d313198a2e03707348\n  Port: 443\n\n192.168.0.1\n  IPv4: c0a80001\n\n::ffff:192.168.0.1\n  IPv6: 00000000000000000000ffffc0a80001\n\n::ffff:71.19.147.227\n  IPv6: 00000000000000000000ffff471393e3\n\n[::ffff:71.19.147.227]:80\n  IPv6: 00000000000000000000ffff471393e3\n  Port: 80\n\n::\n  IPv6: 00000000000000000000000000000000\n\n256.0.0.0\n  BOGUS!\n\ng::1\n  BOGUS!\n\n0000\n  BOGUS!\n\n0000:0000\n  BOGUS!\n\n0000:0000:0000:0000:0000:0000:0000:0000\n  IPv6: 00000000000000000000000000000000\n\n0000:0000:0000::0000:0000\n  IPv6: 00000000000000000000000000000000\n\n0000::0000::0000:0000\n  IPv6: 00000000000000000000000000000000\n\nffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff\n  IPv6: ffffffffffffffffffffffffffffffff\n\nffff:ffff:ffff:fffg:ffff:ffff:ffff:ffff\n  BOGUS!\n\nfff:ffff:ffff:ffff:ffff:ffff:ffff:ffff\n  IPv6: 0fffffffffffffffffffffffffffffff\n\nfff:ffff:0:ffff:ffff:ffff:ffff:ffff\n  IPv6: 0fffffff0000ffffffffffffffffffff\n```"}]}
{"messages": [{"role": "user", "content": "Command-line arguments can be quite complicated, as in:\n\n:   :   :   :   **nc   -v   -n   -z   -w   1   192.168.1.2   1-1000**\n\nMany languages provide a library (getopt or GetOpt) to parse the raw command line options in an intelligent way."}, {"role": "assistant", "content": "(formerly Perl 6)\nAt the end of running any top-level code (which can preprocess the arguments if it likes), Raku automatically examines any remaining arguments and transforms them into a call to a MAIN routine, if one is defined. The arguments are parsed based on the signature of the routine, so that options are mapped to named arguments.\n\n```\nsub MAIN (Bool :$b, Str :$s = '', Int :$n = 0, *@rest) {\n    say \"Bool: $b\";\n    say \"Str: $s\";\n    say \"Num: $n\";\n    say \"Rest: @rest[]\";\n}\n\n```\n\nOutput:\n\n```\n$ ./main -h\nUsage:\n  ./main [-b] [-s=<Str>] [-n=<Int>] [<rest> ...]\n\n$ ./main -b -n=42 -s=turtles all the way down\nBool: True\nStr: turtles\nNum: 42\nRest: all the way down\n```\n\nIf there are multiple MAIN subs, they are differentiated by multiple dispatch. A help message can automatically be generated for all the variants. The intent of this mechanism is not to cover every possible switch structure, but just to make it drop-dead easy to handle most of the common ones."}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nTask\n\nWrite a program that can parse a grammar in   Extended Backus–Naur Form   (**EBNF**),   and then parse something else according to the grammar.\n\nThe program is only required to decide whether or not the something else belongs to the language described by the grammar,  but for extra credit,   it can output a syntax tree.\n\nSee the tests."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03.1\n\nThis parses the EBNF rule set using a Raku grammar, then if it parses as valid EBNF, constructs a grammar and parses the test strings with that. EBNF rule sets that are naively syntactically correct but missing rules will parse as valid but will give a runtime failure warning about missing methods.\nIt is implemented and exercised using the flavor of EBNF and test cases specified on the test page.\n\n```\n# A Raku grammar to parse EBNF\ngrammar EBNF {\n    rule         TOP { ^ <title>? '{' [ <production> ]+ '}' <comment>? $ }\n    rule  production { <name> '=' <expression> <[.;]> }\n    rule  expression { <term> +% \"|\" }\n    rule        term { <factor>+ }\n    rule      factor { <group> | <repeat> | <optional> | <identifier> | <literal> }\n    rule       group { '(' <expression> ')' }\n    rule      repeat { '{' <expression> '}' }\n    rule    optional { '[' <expression> ']' }\n    token identifier { <-[\\|\\(\\)\\{\\}\\[\\]\\.\\;\\\"\\'\\s]>+ } #\"\n    token    literal { [\"'\" <-[']>+ \"'\" | '\"' <-[\"]>+ '\"'] } #\"\n    token      title { <literal> }\n    token    comment { <literal> }\n    token       name { <identifier>  <?before \\h* '='> }\n}\n\nclass EBNF::Actions {\n    method        TOP($/) { \n                            say \"Syntax Tree:\\n\", $/; # Dump the syntax tree to STDOUT\n                            make 'grammar ' ~\n                              ($<title> ?? $<title>.subst(/\\W/, '', :g) !! 'unnamed') ~\n                              \" \\{\\n rule TOP \\{^[<\" ~ $/<production>[0]<name> ~\n                              \">]+\\$\\}\\n \" ~ $<production>>>.ast ~ \"\\}\"\n                          }\n   method production($/) { \n                            make 'token ' ~ $<name> ~ ' {' ~\n                              $<expression>.ast ~ \"}\\n\"\n                          }\n   method expression($/) { make join '|', $<term>>>.ast }\n   method       term($/) { make join '\\h*', $<factor>>>.ast }\n   method     factor($/) { \n                            make $<literal>  ?? $<literal> !!\n                              $<group>    ?? '[' ~ $<group>.ast    ~ ']'  !!\n                              $<repeat>   ?? '[' ~ $<repeat>.ast   ~ '\\\\s*]*' !!\n                              $<optional> ?? '[' ~ $<optional>.ast ~ ']?' !!\n                              '<' ~ $<identifier> ~ '>'\n                          }\n   method     repeat($/) { make $<expression>.ast }\n   method   optional($/) { make $<expression>.ast }\n   method      group($/) { make $<expression>.ast }\n}\n\n# An array of test cases\nmy @tests = (\n    {\n        ebnf => \n            q<\"a\" {\n                a = \"a1\" ( \"a2\" | \"a3\" ) { \"a4\" } [ \"a5\" ] \"a6\" ;\n            } \"z\">\n        ,\n        teststrings => [\n            'a1a3a4a4a5a6',\n            'a1 a2a6',\n            'a1 a3 a4 a6',\n            'a1 a4 a5 a6',\n            'a1 a2 a4 a4 a5 a6',\n            'a1 a2 a4 a5 a5 a6',\n            'a1 a2 a4 a5 a6 a7',\n            'your ad here' \n        ]\n    },\n    {\n        ebnf =>\n            q<{\n                expr = term { plus term } .\n                term = factor { times factor } .\n                factor = number | '(' expr ')' .\n \n                plus = \"+\" | \"-\" .\n                times = \"*\" | \"/\" .\n \n                number = digit { digit } .\n                digit = \"0\" | \"1\" | \"2\" | \"3\" | \"4\" | \"5\" | \"6\" | \"7\" | \"8\" | \"9\" .\n            }>\n        ,\n        teststrings => [\n            '2',\n            '2*3 + 4/23 - 7',\n            '(3 + 4) * 6-2+(4*(4))',\n            '-2',\n            '3 +',\n            '(4 + 3'\n        ]\n    },\n    {\n        ebnf => q<a = \"1\";>,\n        teststrings => ['foobar']\n    },\n    {\n        ebnf => q<{ a = \"1\" ;>,\n        teststrings => ['foobar']\n    },\n    {\n        ebnf => q<{ hello world = \"1\"; }>,\n        teststrings => ['foobar']\n    },\n    {\n        ebnf => q<{ foo = bar . }>,\n        teststrings => ['foobar']\n    }\n);\n\n# Test the parser.\nmy $i = 1;\nfor @tests -> $test {\n    unless EBNF.parse($test<ebnf>) {\n         say \"Parsing EBNF grammar:\\n\";\n         say \"{$test<ebnf>.subst(/^^\\h*/,'',:g)}\\n\";\n         say \"Invalid syntax. Can not be parsed.\\n\";\n         say '*' x 79;\n         next;\n    }\n    my $p = EBNF.parse($test<ebnf>, :actions(EBNF::Actions));\n    my $grammar = $p.ast;\n    $grammar ~~ m/^'grammar '(\\w+)/;\n    my $title = $0;\n    my $fn = 'EBNFtest'~$i++;\n    my $fh = open($fn, :w) orelse .die;\n    $fh.say( \"\\{\\n\", $grammar );\n    $fh.say( qq|say \"Parsing EBNF grammar '$title':\\\\n\";| );\n    $fh.say( qq|say q<{$test<ebnf>.subst(/^^\\h*/,'',:g)}>;| );\n    $fh.say(  q|say \"\\nValid syntax.\\n\\nTesting:\\n\";| );\n    $fh.say(  q|CATCH { default { say \" - $_\" } };| );\n    my $len = max $test<teststrings>.flat>>.chars;\n    for $test<teststrings>.flat -> $s {\n        $fh.say( qq|printf \"%{$len}s\", '{$s}';| ~\n                 qq|printf \" - %s\\\\n\", {$title}.parse('{$s}')| ~\n                 qq| ?? 'valid.' !! 'NOT valid.';|\n               );\n    }\n    $fh.say( qq| \"\\\\n\"} |);\n    $fh.close;\n    say qqx/raku $fn/;\n    say '*' x 79, \"\\n\";\n    unlink $fn;\n}\n\n```\n\nOutput:\n\n```\nSyntax Tree:\n｢\"a\" {\n                a = \"a1\" ( \"a2\" | \"a3\" ) { \"a4\" } [ \"a5\" ] \"a6\" ;\n            } \"z\"｣\n title => ｢\"a\"｣\n  literal => ｢\"a\"｣\n production => ｢a = \"a1\" ( \"a2\" | \"a3\" ) { \"a4\" } [ \"a5\" ] \"a6\" ;\n            ｣\n  name => ｢a｣\n   identifier => ｢a｣\n  expression => ｢\"a1\" ( \"a2\" | \"a3\" ) { \"a4\" } [ \"a5\" ] \"a6\" ｣\n   term => ｢\"a1\" ( \"a2\" | \"a3\" ) { \"a4\" } [ \"a5\" ] \"a6\" ｣\n    factor => ｢\"a1\" ｣\n     literal => ｢\"a1\"｣\n    factor => ｢( \"a2\" | \"a3\" ) ｣\n     group => ｢( \"a2\" | \"a3\" ) ｣\n      expression => ｢\"a2\" | \"a3\" ｣\n       term => ｢\"a2\" ｣\n        factor => ｢\"a2\" ｣\n         literal => ｢\"a2\"｣\n       term => ｢ \"a3\" ｣\n        factor => ｢\"a3\" ｣\n         literal => ｢\"a3\"｣\n    factor => ｢{ \"a4\" } ｣\n     repeat => ｢{ \"a4\" } ｣\n      expression => ｢\"a4\" ｣\n       term => ｢\"a4\" ｣\n        factor => ｢\"a4\" ｣\n         literal => ｢\"a4\"｣\n    factor => ｢[ \"a5\" ] ｣\n     optional => ｢[ \"a5\" ] ｣\n      expression => ｢\"a5\" ｣\n       term => ｢\"a5\" ｣\n        factor => ｢\"a5\" ｣\n         literal => ｢\"a5\"｣\n    factor => ｢\"a6\" ｣\n     literal => ｢\"a6\"｣\n comment => ｢\"z\"｣\n  literal => ｢\"z\"｣\n\nParsing EBNF grammar 'a':\n\n\"a\" {\na = \"a1\" ( \"a2\" | \"a3\" ) { \"a4\" } [ \"a5\" ] \"a6\" ;\n} \"z\"\n\nValid syntax.\n\nTesting:\n\n     a1a3a4a4a5a6 - valid.\n          a1 a2a6 - valid.\n      a1 a3 a4 a6 - valid.\n      a1 a4 a5 a6 - NOT valid.\na1 a2 a4 a4 a5 a6 - valid.\na1 a2 a4 a5 a5 a6 - NOT valid.\na1 a2 a4 a5 a6 a7 - NOT valid.\n     your ad here - NOT valid.\n\n*******************************************************************************\n\nSyntax Tree:\n｢{\n                expr = term { plus term } .\n                term = factor { times factor } .\n                factor = number | '(' expr ')' .\n\n                plus = \"+\" | \"-\" .\n                times = \"*\" | \"/\" .\n\n                number = digit { digit } .\n                digit = \"0\" | \"1\" | \"2\" | \"3\" | \"4\" | \"5\" | \"6\" | \"7\" | \"8\" | \"9\" .\n            }｣\n production => ｢expr = term { plus term } .\n                ｣\n  name => ｢expr｣\n   identifier => ｢expr｣\n  expression => ｢term { plus term } ｣\n   term => ｢term { plus term } ｣\n    factor => ｢term ｣\n     identifier => ｢term｣\n    factor => ｢{ plus term } ｣\n     repeat => ｢{ plus term } ｣\n      expression => ｢plus term ｣\n       term => ｢plus term ｣\n        factor => ｢plus ｣\n         identifier => ｢plus｣\n        factor => ｢term ｣\n         identifier => ｢term｣\n production => ｢term = factor { times factor } .\n                ｣\n  name => ｢term｣\n   identifier => ｢term｣\n  expression => ｢factor { times factor } ｣\n   term => ｢factor { times factor } ｣\n    factor => ｢factor ｣\n     identifier => ｢factor｣\n    factor => ｢{ times factor } ｣\n     repeat => ｢{ times factor } ｣\n      expression => ｢times factor ｣\n       term => ｢times factor ｣\n        factor => ｢times ｣\n         identifier => ｢times｣\n        factor => ｢factor ｣\n         identifier => ｢factor｣\n production => ｢factor = number | '(' expr ')' .\n\n                ｣\n  name => ｢factor｣\n   identifier => ｢factor｣\n  expression => ｢number | '(' expr ')' ｣\n   term => ｢number ｣\n    factor => ｢number ｣\n     identifier => ｢number｣\n   term => ｢ '(' expr ')' ｣\n    factor => ｢'(' ｣\n     literal => ｢'('｣\n    factor => ｢expr ｣\n     identifier => ｢expr｣\n    factor => ｢')' ｣\n     literal => ｢')'｣\n production => ｢plus = \"+\" | \"-\" .\n                ｣\n  name => ｢plus｣\n   identifier => ｢plus｣\n  expression => ｢\"+\" | \"-\" ｣\n   term => ｢\"+\" ｣\n    factor => ｢\"+\" ｣\n     literal => ｢\"+\"｣\n   term => ｢ \"-\" ｣\n    factor => ｢\"-\" ｣\n     literal => ｢\"-\"｣\n production => ｢times = \"*\" | \"/\" .\n\n                ｣\n  name => ｢times｣\n   identifier => ｢times｣\n  expression => ｢\"*\" | \"/\" ｣\n   term => ｢\"*\" ｣\n    factor => ｢\"*\" ｣\n     literal => ｢\"*\"｣\n   term => ｢ \"/\" ｣\n    factor => ｢\"/\" ｣\n     literal => ｢\"/\"｣\n production => ｢number = digit { digit } .\n                ｣\n  name => ｢number｣\n   identifier => ｢number｣\n  expression => ｢digit { digit } ｣\n   term => ｢digit { digit } ｣\n    factor => ｢digit ｣\n     identifier => ｢digit｣\n    factor => ｢{ digit } ｣\n     repeat => ｢{ digit } ｣\n      expression => ｢digit ｣\n       term => ｢digit ｣\n        factor => ｢digit ｣\n         identifier => ｢digit｣\n production => ｢digit = \"0\" | \"1\" | \"2\" | \"3\" | \"4\" | \"5\" | \"6\" | \"7\" | \"8\" | \"9\" .\n            ｣\n  name => ｢digit｣\n   identifier => ｢digit｣\n  expression => ｢\"0\" | \"1\" | \"2\" | \"3\" | \"4\" | \"5\" | \"6\" | \"7\" | \"8\" | \"9\" ｣\n   term => ｢\"0\" ｣\n    factor => ｢\"0\" ｣\n     literal => ｢\"0\"｣\n   term => ｢ \"1\" ｣\n    factor => ｢\"1\" ｣\n     literal => ｢\"1\"｣\n   term => ｢ \"2\" ｣\n    factor => ｢\"2\" ｣\n     literal => ｢\"2\"｣\n   term => ｢ \"3\" ｣\n    factor => ｢\"3\" ｣\n     literal => ｢\"3\"｣\n   term => ｢ \"4\" ｣\n    factor => ｢\"4\" ｣\n     literal => ｢\"4\"｣\n   term => ｢ \"5\" ｣\n    factor => ｢\"5\" ｣\n     literal => ｢\"5\"｣\n   term => ｢ \"6\" ｣\n    factor => ｢\"6\" ｣\n     literal => ｢\"6\"｣\n   term => ｢ \"7\" ｣\n    factor => ｢\"7\" ｣\n     literal => ｢\"7\"｣\n   term => ｢ \"8\" ｣\n    factor => ｢\"8\" ｣\n     literal => ｢\"8\"｣\n   term => ｢ \"9\" ｣\n    factor => ｢\"9\" ｣\n     literal => ｢\"9\"｣\n\nParsing EBNF grammar 'unnamed':\n\n{\nexpr = term { plus term } .\nterm = factor { times factor } .\nfactor = number | '(' expr ')' .\n\nplus = \"+\" | \"-\" .\ntimes = \"*\" | \"/\" .\n\nnumber = digit { digit } .\ndigit = \"0\" | \"1\" | \"2\" | \"3\" | \"4\" | \"5\" | \"6\" | \"7\" | \"8\" | \"9\" .\n}\n\nValid syntax.\n\nTesting:\n\n                    2 - valid.\n       2*3 + 4/23 - 7 - valid.\n(3 + 4) * 6-2+(4*(4)) - valid.\n                   -2 - NOT valid.\n                  3 + - NOT valid.\n               (4 + 3 - NOT valid.\n\n*******************************************************************************\n\nParsing EBNF grammar:\n\na = \"1\";\n\nInvalid syntax. Can not be parsed.\n\n*******************************************************************************\nParsing EBNF grammar:\n\n{ a = \"1\" ;\n\nInvalid syntax. Can not be parsed.\n\n*******************************************************************************\nParsing EBNF grammar:\n\n{ hello world = \"1\"; }\n\nInvalid syntax. Can not be parsed.\n\n*******************************************************************************\nSyntax Tree:\n｢{ foo = bar . }｣\n production => ｢foo = bar . ｣\n  name => ｢foo｣\n   identifier => ｢foo｣\n  expression => ｢bar ｣\n   term => ｢bar ｣\n    factor => ｢bar ｣\n     identifier => ｢bar｣\n\nParsing EBNF grammar 'unnamed':\n\n{ foo = bar . }\n\nValid syntax.\n\nTesting:\n\nfoobar - No such method 'bar' for invocant of type 'unnamed'\n\n*******************************************************************************\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a stack-based evaluator for an expression in   reverse Polish notation (RPN)   that also shows the changes in the stack as each individual token is processed *as a table*.\n\n* Assume an input of a correct, space separated, string of tokens of an RPN expression\n* Test with the RPN expression generated from the   Parsing/Shunting-yard algorithm   task:\n\n`3 4 2 * 1 5 - 2 3 ^ ^ / +`\n\n* Print or display the output here\n\nNotes\n\n* ****^****    means exponentiation in the expression above.\n* ****/****    means division.\n\nSee also\n\n* Parsing/Shunting-yard algorithm for a method of generating an RPN from an infix expression.\n* Several solutions to 24 game/Solve make use of RPN evaluators (although tracing how they work is not a part of that task).\n* Parsing/RPN to infix conversion.\n* Arithmetic evaluation."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-25\n\n```\nmy $proggie = '3 4 2 * 1 5 - 2 3 ^ ^ / +';\n\nclass RPN is Array {\n\n   method binop(&op) { self.push: self.pop R[&op] self.pop }\n\n   method run($p) {\n       for $p.words {\n           say \"$_ ({self})\";\n           when /\\d/ { self.push: $_ }\n           when '+'  { self.binop: &[+] }\n           when '-'  { self.binop: &[-] }\n           when '*'  { self.binop: &[*] }\n           when '/'  { self.binop: &[/] }\n           when '^'  { self.binop: &[**] }\n           default   { die \"$_ is bogus\" }\n       }\n       say self;\n   }\n}\n\nRPN.new.run($proggie);\n\n```\n\nOutput:\n\n```\n3 ()\n4 (3)\n2 (3 4)\n* (3 4 2)\n1 (3 8)\n5 (3 8 1)\n- (3 8 1 5)\n2 (3 8 -4)\n3 (3 8 -4 2)\n^ (3 8 -4 2 3)\n^ (3 8 -4 8)\n/ (3 8 65536)\n+ (3 0.0001220703125)\n3.0001220703125\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nTask\n\nCreate a program that takes an RPN representation of an expression formatted as a space separated sequence of tokens and generates the equivalent expression in infix notation.\n\n* Assume an input of a correct, space separated, string of tokens\n* Generate a space separated output string representing the same expression in infix notation\n* Show how the major datastructure of your algorithm changes with each new token parsed.\n* Test with the following input RPN strings then print and display the output here.\n\n:   :   :   :   :   | RPN input | sample output |\n                    | --- | --- |\n                    | `3 4 2 * 1 5 - 2 3 ^ ^ / +` | `3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3` |\n                    | `1 2 + 3 4 + ^ 5 6 + ^` | `( ( 1 + 2 ) ^ ( 3 + 4 ) ) ^ ( 5 + 6 )` |\n\n* Operator precedence and operator associativity is given in this table:\n\n:   :   :   :   :   :   :   :   | operator | precedence | associativity | operation |\n                                | --- | --- | --- | --- |\n                                | ^ | 4 | right | exponentiation |\n                                | \\* | 3 | left | multiplication |\n                                | / | 3 | left | division |\n                                | + | 2 | left | addition |\n                                | - | 2 | left | subtraction |\n\nSee also\n\n* Parsing/Shunting-yard algorithm   for a method of generating an RPN from an infix expression.\n* Parsing/RPN calculator algorithm   for a method of calculating a final value from this output RPN expression.\n* Postfix to infix   from the RubyQuiz site."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub p ($pair, $prec) { $pair.key < $prec ?? \"( {$pair.value} )\" !! $pair.value }\n\nsub rpm-to-infix($string) {\n    my @stack;\n    for $string.words {\n        when /\\d/      { @stack.push: 9 => $_ }\n        my ($y,$x) = @stack.pop, @stack.pop;\n        when '^'       { @stack.push: 4 => ~(p($x,5), $_, p($y,4)) }\n        when '*' | '/' { @stack.push: 3 => ~(p($x,3), $_, p($y,3)) }\n        when '+' | '-' { @stack.push: 2 => ~(p($x,2), $_, p($y,2)) }\n    }\n    ($string, @stack».value).join(\"\\n\") ~ \"\\n\";\n}\n\nsay rpm-to-infix $_ for\n    '3 4 2 * 1 5 - 2 3 ^ ^ / +',\n    '1 2 + 3 4 + ^ 5 6 + ^';\n\n```\n\nOutput:\n\n```\n3 4 2 * 1 5 - 2 3 ^ ^ / +\n3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3\n\n1 2 + 3 4 + ^ 5 6 + ^\n( ( 1 + 2 ) ^ ( 3 + 4 ) ) ^ ( 5 + 6 )\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven the operator characteristics and input from the Shunting-yard algorithm page and tables, use the algorithm to show the changes in the operator stack and RPN output\nas each individual token is processed.\n\n* Assume an input of a correct, space separated, string of tokens representing an infix expression\n* Generate a space separated output string representing the RPN\n* Test with the input string:\n\n:   :   :   :   `3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3`\n\n* print and display the output here.\n* Operator precedence is given in this table:\n\n:   | operator | precedence | associativity | operation |\n    | --- | --- | --- | --- |\n    | ^ | 4 | right | exponentiation |\n    | \\* | 3 | left | multiplication |\n    | / | 3 | left | division |\n    | + | 2 | left | addition |\n    | - | 2 | left | subtraction |\n\nExtra credit\n\nAdd extra text explaining the actions and an optional comment for the action on receipt of each token.\n\nNote\n\nThe handling of functions and arguments is not required.\n\nSee also\n\n* Parsing/RPN calculator algorithm for a method of calculating a final value from this output RPN expression.\n* Parsing/RPN to infix conversion."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n my %prec =\n   '^' => 4,\n   '*' => 3,\n   '/' => 3,\n   '+' => 2,\n   '-' => 2,\n   '(' => 1;\n\nmy %assoc =\n   '^' => 'right',\n   '*' => 'left',\n   '/' => 'left',\n   '+' => 'left',\n   '-' => 'left';\n\nsub shunting-yard ($prog) {\n   my @inp = $prog.words;\n   my @ops;\n   my @res;\n\n   sub report($op) { printf \"%25s    %-7s %10s %s\\n\", ~@res, ~@ops, $op, ~@inp }\n   sub shift($t)  { report( \"shift $t\"); @ops.push: $t }\n   sub reduce($t) { report(\"reduce $t\"); @res.push: $t }\n\n   while @inp {\n     given @inp.shift {\n       when /\\d/ { reduce $_ };\n       when '(' { shift $_ }\n       when ')' { while @ops and (my $x = @ops.pop and $x ne '(') { reduce $x } }\n       default {\n         my $newprec = %prec{$_};\n           while @ops {\n              my $oldprec = %prec{@ops[*-1]};\n              last if $newprec > $oldprec;\n              last if $newprec == $oldprec and %assoc{$_} eq 'right';\n              reduce @ops.pop;\n           }\n           shift $_;\n       }\n     }\n   }\n   reduce @ops.pop while @ops;\n   @res;\n}\n\nsay shunting-yard '3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3';\n\n```\n\nOutput:\n\n```\n                                       reduce 3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3\n                        3               shift + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3\n                        3    +         reduce 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3\n                      3 4    +          shift * 2 / ( 1 - 5 ) ^ 2 ^ 3\n                      3 4    + *       reduce 2 / ( 1 - 5 ) ^ 2 ^ 3\n                    3 4 2    +         reduce * ( 1 - 5 ) ^ 2 ^ 3\n                  3 4 2 *    +          shift / ( 1 - 5 ) ^ 2 ^ 3\n                  3 4 2 *    + /        shift ( 1 - 5 ) ^ 2 ^ 3\n                  3 4 2 *    + / (     reduce 1 - 5 ) ^ 2 ^ 3\n                3 4 2 * 1    + / (      shift - 5 ) ^ 2 ^ 3\n                3 4 2 * 1    + / ( -   reduce 5 ) ^ 2 ^ 3\n              3 4 2 * 1 5    + / (     reduce - ^ 2 ^ 3\n            3 4 2 * 1 5 -    + /        shift ^ 2 ^ 3\n            3 4 2 * 1 5 -    + / ^     reduce 2 ^ 3\n          3 4 2 * 1 5 - 2    + / ^      shift ^ 3\n          3 4 2 * 1 5 - 2    + / ^ ^   reduce 3 \n        3 4 2 * 1 5 - 2 3    + / ^     reduce ^ \n      3 4 2 * 1 5 - 2 3 ^    + /       reduce ^ \n    3 4 2 * 1 5 - 2 3 ^ ^    +         reduce / \n  3 4 2 * 1 5 - 2 3 ^ ^ /              reduce + \n3 4 2 * 1 5 - 2 3 ^ ^ / +\n```"}]}
{"messages": [{"role": "user", "content": "Partial function application   is the ability to take a function of many\nparameters and apply arguments to some of the parameters to create a new\nfunction that needs only the application of the remaining arguments to\nproduce the equivalent of applying all arguments to the original function.\n\nE.g:\n\n:   Given values `v1, v2`\n:   Given `f(param1, param2)`\n:   Then `partial(f, param1=v1)` returns `f'(param2)`\n:   And `f(param1=v1, param2=v2) == f'(param2=v2)` (for any value v2)\n\nNote that in the partial application of a parameter, (in the above case param1), other parameters are not explicitly mentioned. This is a recurring feature of partial function application.\n\nTask\n\n* Create a function fs( f, s ) that takes a function, f( n ), of one value and a sequence of values s.  \n   Function fs should return an ordered sequence of the result of applying function f to every value of s in turn.\n\n* Create function f1 that takes a value and returns it multiplied by 2.\n* Create function f2 that takes a value and returns it squared.\n\n* Partially apply f1 to fs to form function fsf1( s )\n* Partially apply f2 to fs to form function fsf2( s )\n\n* Test fsf1 and fsf2 by evaluating them with s being the sequence of integers from 0 to 3 inclusive and then the sequence of even integers from 2 to 8 inclusive.\n\nNotes\n\n* In partially applying the functions f1 or f2 to fs, there should be no *explicit* mention of any other parameters to fs, although introspection of fs within the partial applicator to find its parameters *is* allowed.\n* This task is more about *how* results are generated rather than just getting results."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-25\n\nAll Code objects have the .assuming method, which partially applies its arguments. For both type safety reasons and parsing sanity reasons we do not believe in implicit partial application by leaving out arguments. Also, people can understand \"assuming\" without being steeped in FP culture.\n\n```\nsub fs ( Code $f, @s ) { @s.map: { .$f } }\n \nsub f1 ( $n ) { $n *  2 }\nsub f2 ( $n ) { $n ** 2 }\n \nmy &fsf1 := &fs.assuming(&f1);\nmy &fsf2 := &fs.assuming(&f2);\n \nfor [1..3], [2, 4 ... 8] X &fsf1, &fsf2 -> ($s, $f) {\n    say $f.($s);\n}\n\n```\n\nOutput:\n\n```\n(2 4 6)\n(1 4 9)\n(4 8 12 16)\n(4 16 36 64)\n```\n\nThe \\*+2 is also a form of partial application in Raku. In this case we partially apply the infix:<+> function with a second argument of 2. That is, the star (known as the \"whatever\" star) indicates which argument *not* to apply. In contrast to languages that keep some arguments unbound by leaving holes, the explicit star in Raku allows us to avoid syntactic ambiguity in whether to expect a term or an infix operator; such self-clocking code contributes to better error messages when things go wrong."}]}
{"messages": [{"role": "user", "content": "Implement a particle fountain.\n\nEmulate a fountain of water droplets in a gravitational field being sprayed up and then falling back down.\n\nThe particle fountain should be generally ordered but individually chaotic; the particles should be going mostly in the same direction, but should have slightly different vectors.\n\nYour fountain should have at least several hundred particles in motion at any one time, and ideally several thousand.\n\nIt is optional to have the individual particle interact with each other.\n\nIf at all possible, link to a short video clip of your fountain in action.\n\nOff-site link to a demo video"}, {"role": "assistant", "content": "Has options to vary the direction at which the fountain sprays, the \"spread\" angle and the color of the emitted particles.\n\n```\nuse NativeCall;\nuse SDL2::Raw;\n\nmy int ($w, $h) = 800, 800;\nmy SDL_Window $window;\nmy SDL_Renderer $renderer;\n\nmy int $particlenum = 3000;\n\n\nSDL_Init(VIDEO);\n$window = SDL_CreateWindow(\n   \"Raku Particle System!\",\n   SDL_WINDOWPOS_CENTERED_MASK, SDL_WINDOWPOS_CENTERED_MASK,\n   $w, $h,\n   RESIZABLE\n);\n$renderer = SDL_CreateRenderer( $window, -1, ACCELERATED );\n\nSDL_ClearError();\n\nmy num @positions  = 0e0 xx ($particlenum * 2);\nmy num @velocities = 0e0 xx ($particlenum * 2);\nmy num @lifetimes  = 0e0 xx  $particlenum;\n\nmy CArray[int32] $points .= new;\nmy int $numpoints;\nmy Num $saturation = 4e-1;\nmy Num $spread = 15e-1;\nmy &reciprocate = sub { 0 }\nmy $range = 1.5;\n\nsub update (num \\df) {\n   my int $xidx = 0;\n   my int $yidx = 1;\n   my int $pointidx = 0;\n   loop (my int $idx = 0; $idx < $particlenum; $idx = $idx + 1) {\n       my int $willdraw = 0;\n       if (@lifetimes[$idx] <= 0e0) {\n           if (rand < df) {\n               @lifetimes[$idx]   = 25e-1;                       # time to live\n               @positions[$xidx]  = ($w / 20e0).Num;             # starting position x\n               @positions[$yidx]  = ($h / 10).Num;               # and y\n               @velocities[$xidx] = ($spread * rand - $spread/2 + reciprocate()) * 10; # starting velocity x\n               @velocities[$yidx] = (rand - 2.9e0) * $h / 20.5;    # and y (randomized slightly so points reach different heights)\n               $willdraw = 1;\n           }\n       } else {\n           if @positions[$yidx] > $h / 10 && @velocities[$yidx] > 0 {\n               @velocities[$yidx] = @velocities[$yidx] * -0.3e0; # \"bounce\"\n           }\n\n           @velocities[$yidx] = @velocities[$yidx] + $h/10.Num * df;         # adjust velocity\n           @positions[$xidx]  = @positions[$xidx] + @velocities[$xidx] * df; # adjust position x\n           @positions[$yidx]  = @positions[$yidx] + @velocities[$yidx] * df; # and y\n\n           @lifetimes[$idx]   = @lifetimes[$idx] - df;\n           $willdraw = 1;\n       }\n\n       if ($willdraw) {\n           $points[$pointidx++] = (@positions[$xidx] * 10).floor; # gather all of the points that\n           $points[$pointidx++] = (@positions[$yidx] * 10).floor; # are still going to be rendered\n       }\n\n       $xidx = $xidx + 2;\n       $yidx = $xidx + 1;\n   }\n   $numpoints = ($pointidx - 1) div 2;\n}\n\nsub render {\n   SDL_SetRenderDrawColor($renderer, 0x0, 0x0, 0x0, 0xff);\n   SDL_RenderClear($renderer);\n\n   SDL_SetRenderDrawColor($renderer, |hsv2rgb(((now % 5) / 5).round(.01), $saturation, 1), 0x7f);\n   SDL_RenderDrawPoints($renderer, $points, $numpoints);\n\n   SDL_RenderPresent($renderer);\n}\n\nenum KEY_CODES (\n   K_UP     => 82,\n   K_DOWN   => 81,\n   K_LEFT   => 80,\n   K_RIGHT  => 79,\n   K_SPACE  => 44,\n   K_PGUP   => 75,\n   K_PGDN   => 78,\n   K_Q      => 20,\n);\n\nsay q:to/DOCS/;\nUse UP and DOWN arrow keys to modify the saturation of the particle colors.\nUse PAGE UP and PAGE DOWN keys to modify the \"spread\" of the particles.\nToggle reciprocation off / on with the SPACE bar.\nUse LEFT and RIGHT arrow keys to modify angle range for reciprocation.\nPress the \"q\" key to quit.\nDOCS\n\nmy $event = SDL_Event.new;\n\nmy num $df = 0.0001e0;\n\nmain: loop {\n   my $start = now;\n\n   while SDL_PollEvent($event) {\n       my $casted_event = SDL_CastEvent($event);\n\n       given $casted_event {\n           when *.type == QUIT {\n               last main;\n           }\n           when *.type == WINDOWEVENT {\n               if .event == RESIZED {\n                   $w = .data1;\n                   $h = .data2;\n               }\n           }\n           when *.type == KEYDOWN {\n               if KEY_CODES(.scancode) -> $comm {\n                   given $comm {\n                       when 'K_UP'    { $saturation = (($saturation + .1) min 1e0) }\n                       when 'K_DOWN'  { $saturation = (($saturation - .1) max 0e0) }\n                       when 'K_PGUP'  { $spread = (($spread + .1) min 5e0) }\n                       when 'K_PGDN'  { $spread = (($spread - .1) max 2e-1) }\n                       when 'K_RIGHT' { $range = (($range + .1) min 2e0) }\n                       when 'K_LEFT'  { $range = (($range - .1) max 1e-1) }\n                       when 'K_SPACE' { &reciprocate = reciprocate() == 0 ?? sub { $range * sin(now) } !! sub { 0 } }\n                       when 'K_Q'     { last main }\n                   }\n               }\n           }\n       }\n   }\n\n   update($df);\n\n   render();\n\n   $df = (now - $start).Num;\n\n   print fps();\n}\n\nsay '';\n\nsub fps {\n   state $fps-frames = 0;\n   state $fps-now    = now;\n   state $fps        = '';\n   $fps-frames++;\n   if now - $fps-now >= 1 {\n       $fps = [~] \"\\r\", ' ' x 20, \"\\r\",\n           sprintf \"FPS: %5.1f  \", ($fps-frames / (now - $fps-now));\n       $fps-frames = 0;\n       $fps-now = now;\n   }\n   $fps\n}\n\nsub hsv2rgb ( $h, $s, $v ){\n   state %cache;\n   %cache{\"$h|$s|$v\"} //= do {\n       my $c = $v * $s;\n       my $x = $c * (1 - abs( (($h*6) % 2) - 1 ) );\n       my $m = $v - $c;\n       [(do given $h {\n           when   0..^1/6 { $c, $x, 0 }\n           when 1/6..^1/3 { $x, $c, 0 }\n           when 1/3..^1/2 { 0, $c, $x }\n           when 1/2..^2/3 { 0, $x, $c }\n           when 2/3..^5/6 { $x, 0, $c }\n           when 5/6..1    { $c, 0, $x }\n       } ).map: ((*+$m) * 255).Int]\n   }\n}\n\n```\n\nLink to off-site .mp4 video"}]}
{"messages": [{"role": "user", "content": "Particle Swarm Optimization (PSO) is an optimization method in which multiple candidate solutions ('particles') migrate through the solution space under the influence of local and global best known positions. PSO does not require that the objective function be differentiable and can optimize over very large problem spaces, but is not guaranteed to converge. The method should be demonstrated by application of the functions recommended below, and possibly other standard or well-known optimization test cases.\n\nThe goal of parameter selection is to ensure that the global minimum is discriminated from any local minima, and that the minimum is accurately determined, and that convergence is achieved with acceptable resource usage. To provide a common basis for comparing implementations, the following test cases are recommended:\n\n* McCormick function - bowl-shaped, with a single minimum\n  function parameters and bounds (recommended):+ -1.5 < x1 < 4\n  + -3 < x2 < 4\n  search parameters (suggested):+ omega = 0\n  + phi p = 0.6\n  + phi g = 0.3\n  + number of particles = 100\n  + number of iterations = 40\n* Michalewicz function - steep ridges and valleys, with multiple minima\n  function parameters and bounds (recommended):+ 0 < x1 < pi\n  + 0 < x2 < pi\n  search parameters (suggested):+ omega = 0.3\n  + phi p = 0.3\n  + phi g = 0.3\n  + number of particles = 1000\n  + number of iterations = 30\n\nReferences:\n\n* [Particle Swarm Optimization[1]]\n* [Virtual Library of Optimization Test Functions[2]]"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: J (via Javascript, Kotlin, D, Python)\n\n```\nsub pso-init (%y) {\n    my $d = @(%y{'min'});\n    my $n = %y{'n'};\n\n    %y{'gbval'} = Inf;\n    %y{'gbpos'} = [Inf xx $d];\n    %y{'bval'}  = [Inf xx $n];\n    %y{'bpos'}  = [%y{'min'} xx $n];\n    %y{'pos'}   = [%y{'min'} xx $n];\n    %y{'vel'}   = [[0 xx $d] xx $n];\n\n    %y;\n}\n\nsub pso (&fn, %y) {\n    my %p      = %y{'p'};\n    my $n      = %y{'n'};\n    my $d      = @(%y{'min'});\n    my @bpos   = %y{'min'} xx $n;\n    my $gbval  = Inf;\n    my $rand-g = rand;\n    my (@pos, @vel, @v, @gbpos, @bval);\n\n    for 0 ..^ $n -> \\j {\n        @v[j] = &fn(%y{'pos'}[j]); # evaluate\n\n        # update\n        if @v[j] < %y{'bval'}[j] {\n            @bpos[j] = %y{'pos'}[j];\n            @bval[j] = @v[j];\n        } else {\n            @bpos[j] = %y{'bpos'}[j];\n            @bval[j] = %y{'bval'}[j];\n        }\n        if @bval[j] < $gbval {\n            $gbval = @bval[j];\n            @gbpos = |@bpos[j];\n        }\n    }\n\n    # migrate\n    for 0 ..^ $n -> \\j {\n        my $rand-p = rand;\n        my $ok = True;\n        for 0 ..^ $d -> \\k {\n            @vel[j;k] = %p{'ω'} × %y{'vel'}[j;k]\n                       + %p{'φ-p'} × $rand-p × (@bpos[j;k] - %y{'pos'}[j;k])\n                       + %p{'φ-g'} × $rand-g × (@gbpos[k]  - %y{'pos'}[j;k]);\n            @pos[j;k] = %y{'pos'}[j;k] + @vel[j;k];\n            $ok = %y{'min'}[k] < @pos[j;k] < %y{'max'}[k] if $ok;\n        }\n        next if $ok;\n        @pos[j;$_] = %y{'min'}[$_] + (%y{'max'}[$_] - %y{'min'}[$_]) × rand for 0 ..^ $d;\n    }\n\n    return {gbpos => @gbpos, gbval => $gbval, bpos => @bpos, bval => @bval, pos => @pos, vel => @vel,\n            min => %y{'min'}, max => %y{'max'}, p=> %y{'p'}, n => $n}\n}\n\nsub report ($function-name, %state) {\n    say $function-name;\n    say '🌐 best position: ' ~ %state{'gbpos'}.fmt('%.5f');\n    say '🌐 best value:    ' ~ %state{'gbval'}.fmt('%.5f');\n    say '';\n}\n\nsub mccormick (@x) {\n    my ($a,$b) = @x;\n    sin($a+$b) + ($a-$b)**2 + (1 + 2.5×$b - 1.5×$a)\n}\n\nmy %state = pso-init( {\n    min => [-1.5, -3],\n    max => [4, 4],\n    n   => 100,\n    p   => {ω=> 0, φ-p=> 0.6, φ-g=> 0.3},\n} );\n%state = pso(&mccormick, %state) for 1 .. 40;\nreport 'McCormick', %state;\n\nsub michalewicz (@x) {\n    my $sum;\n    my $m = 10;\n    for 1..@x -> $i {\n        my $j = @x[$i-1];\n        my $k = sin($i × $j**2/π);\n        $sum += sin($j) × $k**(2×$m)\n    }\n    -$sum\n}\n\n%state = pso-init( {\n    min => [0, 0],\n    max => [π, π],\n    n   => 1000,\n    p   => {ω=> 0.3, φ-p=> 0.3, φ-g=> 0.3},\n} );\n%state = pso(&michalewicz, %state) for 1 .. 30;\nreport 'Michalewicz', %state;\n\n```\n\nOutput:\n\n```\nMcCormick\n🌐 best position: -0.54714 -1.54710\n🌐 best value:    -1.91322\n\nMichalewicz\n🌐 best position: 2.20291 1.57080\n🌐 best value:    -1.80130\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nPartition a positive integer   **X**   into   **N**   distinct primes.\n\nOr, to put it in another way:\n\nFind   **N**   unique primes such that they add up to   **X**.\n\nShow in the output section the sum   **X**   and the   **N**   primes in ascending order separated by plus (**+**) signs:\n\n```\n     •    partition  99809  with   1 prime.\n     •    partition    18   with   2 primes.\n     •    partition    19   with   3 primes.\n     •    partition    20   with   4 primes.\n     •    partition   2017  with  24 primes.\n     •    partition  22699  with   1,  2,  3,  and  4  primes.\n     •    partition  40355  with   3 primes.\n\n```\n\nThe output could/should be shown in a format such as:\n\n```\n    Partitioned  19  with  3  primes:  3+5+11\n\n```\n\n:   :   * Use any spacing that may be appropriate for the display.\n        * You need not validate the input(s).\n        * Use the lowest primes possible;   use  **18 = 5+13**,   not   **18 = 7+11**.\n        * You only need to show one solution.\n\nThis task is similar to factoring an integer.\n\nRelated tasks\n:   * Count in factors\n    * Prime decomposition\n    * Factors of an integer\n    * Sieve of Eratosthenes\n    * Primality by trial division\n    * Factors of a Mersenne number\n    * Factors of a Mersenne number\n    * Sequence of primes by trial division"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nAttempt This Online!\n\n```\n# short circuit for '1' partition\nmulti partition ( Int $number, 1 ) { $number.is-prime ?? $number !! () }\n\nmy @primes = lazy (^Inf).grep: &is-prime;\n\nmulti partition ( Int $number, Int $parts where * > 1 = 2 ) {\n    my @these = @primes[^($number div $parts)];\n    shift @these if (($number %% 2) && ($parts %% 2)) || (($number % 2) && ($parts % 2));\n    for @these.combinations($parts - 1) { \n        my $maybe = $number - .sum;\n        return (|$_, $maybe) if $maybe.is-prime && ($maybe ∉ $_)\n    };\n    ()\n}\n\n# TESTING\n(18,2, 19,3, 20,4, 99807,1, 99809,1, 99820,6, 2017,24, 22699,1, 22699,2, 22699,3, 22699,4, 40355,3)\\\n  .race(:1batch).map: -> $number, $parts {\n    say (sprintf \"Partition %5d into %2d prime piece\", $number, $parts),\n    $parts == 1 ?? ':  ' !! 's: ', join '+', partition($number, $parts) || 'not possible'\n}\n\n```\n\nOutput:\n\n```\nPartition    18 into  2 prime pieces: 5+13\nPartition    19 into  3 prime pieces: 3+5+11\nPartition    20 into  4 prime pieces: not possible\nPartition 99807 into  1 prime piece:  not possible\nPartition 99809 into  1 prime piece:  99809\nPartition 99820 into  6 prime pieces: 3+5+7+11+61+99733\nPartition  2017 into 24 prime pieces: 2+3+5+7+11+13+17+19+23+29+31+37+41+43+47+53+59+61+67+71+73+79+97+1129\nPartition 22699 into  1 prime piece:  22699\nPartition 22699 into  2 prime pieces: 2+22697\nPartition 22699 into  3 prime pieces: 3+5+22691\nPartition 22699 into  4 prime pieces: 2+3+43+22651\nPartition 40355 into  3 prime pieces: 3+139+40213\n```"}]}
{"messages": [{"role": "user", "content": "The Partition Function P is the function P(n), where n∈ℤ, defined as the number of distinct ways in which n can be expressed as the sum of non-increasing positive integers.\n\nExample\n\n```\n P(4) = 5   because   4 = Σ(4) = Σ(3,1) = Σ(2,2) = Σ(2,1,1) = Σ(1,1,1,1)\n\n```\n\nP(n) can be expressed as the recurrence relation:\n\n```\n P(n) = P(n-1) +P(n-2) -P(n-5) -P(n-7) +P(n-12) +P(n-15) -P(n-22) -P(n-26) +P(n-35) +P(n-40) ...\n\n```\n\nThe successive numbers in the above equation have the differences:   1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8 ...\n\nThis task may be of popular interest because Mathologer made the video, The hardest \"What comes next?\" (Euler's pentagonal formula), where he asks the programmers among his viewers to calculate P(666). The video was viewed more than 100,000 times in the first couple of weeks after its release.\n\nIn Wolfram Language, this function has been implemented as PartitionsP.\n\nTask\n\nWrite a function which returns the value of PartitionsP(n). Solutions can be iterative or recursive.\n\nBonus task: show how long it takes to compute PartitionsP(6666).\n\nReferences\n\n* The hardest \"What comes next?\" (Euler's pentagonal formula) The explanatory video by Mathologer that makes this task a popular interest.\n* Partition Function P Mathworld entry for the Partition function.\n* Partition function (number theory) Wikipedia entry for the Partition function.\n\nRelated tasks\n\n* 9 billion names of God the integer"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.09\n\nNot the fastest, but it gets the job done.\n\n```\nmy @P = 1, { p(++$) } … *;\nmy @i = lazy [\\+] flat 1, ( 1..* Z (1..*).map: * × 2 + 1 );\nsub p ($n) { sum @P[$n X- @i] Z× (flat (1, 1, -1, -1) xx *) }\n\nput @P[^26];\nput @P[6666];\n\n```\n\nOutput:\n\n```\n1 1 2 3 5 7 11 15 22 30 42 56 77 101 135 176 231 297 385 490 627 792 1002 1255 1575 1958\n193655306161707661080005073394486091998480950338405932486880600467114423441282418165863\n```"}]}
{"messages": [{"role": "user", "content": "A pascal matrix is a two-dimensional square matrix holding numbers from   Pascal's triangle,   also known as   binomial coefficients   and which can be shown as   nCr.\n\nShown below are truncated   5-by-5   matrices   M[i, j]   for   i,j   in range   0..4.\n\nA Pascal upper-triangular matrix that is populated with   jCi:\n\n```\n[[1, 1, 1, 1, 1],\n [0, 1, 2, 3, 4],\n [0, 0, 1, 3, 6],\n [0, 0, 0, 1, 4],\n [0, 0, 0, 0, 1]]\n\n```\n\nA Pascal lower-triangular matrix that is populated with   iCj   (the transpose of the upper-triangular matrix):\n\n```\n[[1, 0, 0, 0, 0],\n [1, 1, 0, 0, 0],\n [1, 2, 1, 0, 0],\n [1, 3, 3, 1, 0],\n [1, 4, 6, 4, 1]]\n\n```\n\nA Pascal symmetric matrix that is populated with   i+jCi:\n\n```\n[[1, 1, 1, 1, 1],\n [1, 2, 3, 4, 5],\n [1, 3, 6, 10, 15],\n [1, 4, 10, 20, 35],\n [1, 5, 15, 35, 70]]\n\n```\n\nTask\n\nWrite functions capable of generating each of the three forms of   n-by-n   matrices.\n\nUse those functions to display upper, lower, and symmetric Pascal   5-by-5   matrices on this page.\n\nThe output should distinguish between different matrices and the rows of each matrix   (no showing a list of 25 numbers assuming the reader should split it into rows).\n\nNote\n\nThe   Cholesky decomposition   of a Pascal symmetric matrix is the Pascal lower-triangle matrix of the same size."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016-12\n\nHere is a rather more general solution than required. The grow-matrix function will grow any N by N matrix into an N+1 x N+1 matrix, using any function of the three leftward/upward neighbors, here labelled \"West\", \"North\", and \"Northwest\". We then define three iterator functions that can grow Pascal matrices, and use those iterators to define three constants, each of which is an infinite sequence of ever-larger Pascal matrices. Normal subscripting then pulls out the ones of the specified size.\n\n```\n# Extend a matrix in 2 dimensions based on 3 neighbors.\nsub grow-matrix(@matrix, &func) {\n    my $n = @matrix.shape eq '*' ?? 1 !! @matrix.shape[0];\n    my @m[$n+1;$n+1];\n    for ^$n X ^$n -> ($i, $j) {\n       @m[$i;$j] = @matrix[$i;$j];\n    }\n#                     West         North        NorthWest\n    @m[$n; 0] = func( 0,           @m[$n-1;0],  0            );\n    @m[ 0;$n] = func( @m[0;$n-1],  0,           0            );\n    @m[$_;$n] = func( @m[$_;$n-1], @m[$_-1;$n], @m[$_-1;$n-1]) for 1 ..^ $n;\n    @m[$n;$_] = func( @m[$n;$_-1], @m[$n-1;$_], @m[$n-1;$_-1]) for 1 ..  $n;\n    @m;\n}\n\n# I am but mad north-northwest...\nsub madd-n-nw(@m) { grow-matrix @m, -> $w, $n, $nw {  $n + $nw } }\nsub madd-w-nw(@m) { grow-matrix @m, -> $w, $n, $nw {  $w + $nw } }\nsub madd-w-n (@m) { grow-matrix @m, -> $w, $n, $nw {  $w + $n  } }\n\n# Define 3 infinite sequences of Pascal matrices.\nconstant upper-tri = [1], &madd-w-nw ... *;\nconstant lower-tri = [1], &madd-n-nw ... *;\nconstant symmetric = [1], &madd-w-n  ... *;\n\nshow_m upper-tri[4];\nshow_m lower-tri[4];\nshow_m symmetric[4];\n\nsub show_m (@m) {\nmy \\n = @m.shape[0];\nfor ^n X ^n -> (\\i, \\j) {\n    print @m[i;j].fmt(\"%{1+max(@m).chars}d\"); \n    print \"\\n\" if j+1 eq n;\n}\nsay '';\n}\n\n```\n\nOutput:\n\n```\n 1 1 1 1 1\n 0 1 2 3 4\n 0 0 1 3 6\n 0 0 0 1 4\n 0 0 0 0 1\n\n 1 0 0 0 0\n 1 1 0 0 0\n 1 2 1 0 0\n 1 3 3 1 0\n 1 4 6 4 1\n\n  1  1  1  1  1\n  1  2  3  4  5\n  1  3  6 10 15\n  1  4 10 20 35\n  1  5 15 35 70\n```"}]}
{"messages": [{"role": "user", "content": "Pascal's triangle is an arithmetic and geometric figure often associated with the name of Blaise Pascal, but also studied centuries earlier in India, Persia, China and elsewhere.\n\nIts first few rows look like this:\n\n```\n    1\n   1 1\n  1 2 1\n 1 3 3 1 \n\n```\n\nwhere each element of each row is either 1 or the sum of the two elements right above it.\n\nFor example, the next row of the triangle would be:\n\n:   :   :   **1**   (since the first element of each row doesn't have two elements above it)\n        :   **4**   (1 + 3)\n        :   **6**   (3 + 3)\n        :   **4**   (3 + 1)\n        :   **1**   (since the last element of each row doesn't have two elements above it)\n\nSo the triangle now looks like this:\n\n```\n    1\n   1 1\n  1 2 1\n 1 3 3 1\n1 4 6 4 1 \n\n```\n\nEach row    n    (starting with row   0   at the top) shows the coefficients of the binomial expansion of    (x + y)n.\n\nTask\n\nWrite a function that prints out the first    n    rows of the triangle   (with    f(1)    yielding the row consisting of only the element **1**).\n\nThis can be done either by summing elements from the previous rows or using a binary coefficient or combination function.\n\nBehavior for    n ≤ 0    does not need to be uniform, but should be noted.\n\nSee also\n\n* Evaluate binomial coefficients"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-10-03\n\n### using a lazy sequence generator\n\nThe following routine returns a lazy list of lines using the sequence operator (...). With a lazy result you need not tell the routine how many you want; you can just use a slice subscript to get the first N lines:\n\n```\nsub pascal {\n    [1], { [0, |$_ Z+ |$_, 0] } ... *\n}\n \n.say for pascal[^10];\n```\n\nOne problem with the routine above is that it might recalculate the sequence each time you call it. Slightly more idiomatic would be to define the sequence as a lazy constant. Here we use the @ sigil to indicate that the sequence should cache its values for reuse, and use an explicit parameter $prev for variety:\n\n```\nconstant @pascal = [1], -> $prev { [0, |$prev Z+ |$prev, 0] } ... *;\n \n.say for @pascal[^10];\n```\n\nSince we use ordinary subscripting, non-positive inputs throw an index-out-of-bounds error.\n\n### recursive\n\n**Translation of**: Haskell\n\n```\nmulti sub pascal (1) { $[1] }\nmulti sub pascal (Int $n where 2..*) {\n    my @rows = pascal $n - 1;\n    |@rows, [0, |@rows[*-1] Z+ |@rows[*-1], 0 ];\n}\n \n.say for pascal 10;\n```\n\nNon-positive inputs throw a multiple-dispatch error.\n\n### iterative\n\n**Translation of**: Perl\n\n```\nsub pascal ($n where $n >= 1) {\n   say my @last = 1;\n   for 1 .. $n - 1 -> $row {\n       @last = 1, |map({ @last[$_] + @last[$_ + 1] }, 0 .. $row - 2), 1;\n       say @last;\n   }\n}\n \npascal 10;\n```\n\nNon-positive inputs throw a type check error.\n\nOutput:\n\n```\n[1]\n[1 1]\n[1 2 1]\n[1 3 3 1]\n[1 4 6 4 1]\n[1 5 10 10 5 1]\n[1 6 15 20 15 6 1]\n[1 7 21 35 35 21 7 1]\n[1 8 28 56 70 56 28 8 1]\n[1 9 36 84 126 126 84 36 9 1]\n```"}]}
{"messages": [{"role": "user", "content": "This puzzle involves a Pascals Triangle, also known as a Pyramid of Numbers.\n\n```\n           [ 151]\n          [  ][  ]\n        [40][  ][  ]\n      [  ][  ][  ][  ]\n    [ X][11][ Y][ 4][ Z]\n\n```\n\nEach brick of the pyramid is the sum of the two bricks situated below it.  \nOf the three missing numbers at the base of the pyramid,\nthe middle one is the sum of the other two (that is, Y = X + Z).\n\nTask\n\nWrite a program to find a solution to this puzzle."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\n# set up triangle\nmy $rows = 5;\nmy @tri = (1..$rows).map: { [ { x => 0, z => 0, v => 0, rhs => Nil } xx $_ ] }\n@tri[0][0]<rhs> = 151;\n@tri[2][0]<rhs> = 40;\n@tri[4][0]<x> = 1;\n@tri[4][1]<v> = 11;\n@tri[4][2]<x> = 1;\n@tri[4][2]<z> = 1;\n@tri[4][3]<v> = 4;\n@tri[4][4]<z> = 1;\n \n# aggregate from bottom to top\nfor @tri - 2 ... 0 -> $row {\n    for 0 ..^ @tri[$row] -> $col {\n        @tri[$row][$col]{$_} = @tri[$row+1][$col]{$_} + @tri[$row+1][$col+1]{$_} for 'x','z','v';\n    }\n}\n\n# find equations\nmy @eqn = gather for @tri -> $row {\n    for @$row -> $cell {\n        take [ $cell<x>, $cell<z>, $cell<rhs> - $cell<v> ] if defined $cell<rhs>;\n    }\n}\n\n# print equations\nsay \"Equations:\";\nsay \"  x +   z = y\";\nfor @eqn -> [$x,$z,$y] { say \"$x x + $z z = $y\" }\n\n# solve\nmy $f = @eqn[0][1] / @eqn[1][1];\n@eqn[0][$_] -=  $f * @eqn[1][$_] for 0..2;\n$f = @eqn[1][0] / @eqn[0][0];\n@eqn[1][$_] -=  $f * @eqn[0][$_] for 0..2;\n\n# print solution\nsay \"Solution:\";\nmy $x = @eqn[0][2] / @eqn[0][0];\nmy $z = @eqn[1][2] / @eqn[1][1];\nmy $y = $x + $z;\nsay \"x=$x, y=$y, z=$z\";\n\n```\n\nOutput:\n\n```\nEquations:\n  x +   z = y\n7 x + 7 z = 91\n2 x + 1 z = 18\nSolution:\nx=5, y=13, z=8\n```"}]}
{"messages": [{"role": "user", "content": "Create a password generation program which will generate passwords containing random ASCII characters from the following groups:\n\n```\n         lower-case letters:  a ──► z\n         upper-case letters:  A ──► Z\n                     digits:  0 ──► 9\n other printable characters:  !\"#$%&'()*+,-./:;<=>?@[]^_{|}~ \n (the above character list excludes white-space, backslash and grave) \n\n```\n\nThe generated password(s) must include   *at least one*   (of each of the four groups):\n\n```\n   lower-case letter, \n   upper-case letter,\n   digit  (numeral),   and \n   one  \"other\"  character. \n\n```\n\nThe user must be able to specify the password length and the number of passwords to generate.\n\nThe passwords should be displayed or written to a file, one per line.\n\nThe randomness should be from a system source or library.\n\nThe program should implement a help option or button which should describe the program and options when invoked.\n\nYou may also allow the user to specify a seed value, and give the option of excluding visually similar characters.\n\nFor example:            Il1     O0     5S     2Z            where the characters are:\n\n:   :   :   :   * capital eye, lowercase ell, the digit one\n                * capital oh, the digit zero\n                * the digit five, capital ess\n                * the digit two, capital zee"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.05\n\n```\nmy @chars =\n  set('a' .. 'z'),\n  set('A' .. 'Z'),\n  set('0' .. '9'),\n  set(<!\"#$%&'()*+,-./:;<=>?@[]^_{|}~>.comb);\n\n# bleh. unconfuse syntax highlighter. '\"\n\nsub MAIN ( Int :$l = 8, Int :$c = 1, Str :$x = '' ) {\n    note 'Password length must be >= 4' and exit if $l < 4;\n    note 'Can not generate fewer than 0 passwords' and exit if $c < 0;\n    my $chars = [∪] @chars».=&filter;\n    note 'Can not exclude an entire required character group' and exit\n      if any(@chars».elems) == 0;\n    for ^$c {\n        my @pswd;\n        @pswd.push( @chars[$_].roll ) for ^4;\n        @pswd.push( $chars    .roll ) for 4 ..^ $l;\n        say [~] @pswd.pick(*);\n    }\n\n    sub filter (Set $set) { $set ∖ set($x.comb) }\n}\n\nsub USAGE() {\n    say qq:to/END/;\n    Specify a length:              --l=8 (default 8),\n    Specify a count:               --c=1 (default 1),\n    Specify characters to exclude: --x=\n    (must escape characters significant to the shell)\n    E.G.\n    {$*PROGRAM-NAME} --l=14 --c=5 --x=0O\\\\\\\"\\\\\\'1l\\\\\\|I\n    END\n}\n\n```\n\n**Sample output:**\nUsing defaults:\n\n```\nc?6!xU+u\n```\n\nWith passed parameters: --l=14 --c=5 --x=0O\\'\\\"1l\\|I\n\n```\n6H~jC+5(+&H44x\n+Rr}2>htHMa.Y9\nt~#&N]sp_zGK2#\nTcP73CJ@euFMjj\n9%-tYX]z?8-xA5\n```\n\n### functional\n\n```\nmy @char-groups =\n    ['a' .. 'z'],\n    ['A' .. 'Z'],\n    ['0' .. '9'],\n    < $ % & \\ ` ~ ! * + , - . / :  ;  = ? @ ^ _  ~ [ ] ( ) { | } # ' \" \\< \\> >.Array;\n\nsubset MinimumPasswordLength of  Int where * >= 4;\nsubset NumberOfPasswords     of UInt where * != 0;\n\nsub MAIN( NumberOfPasswords :c(:$count) = 1, MinimumPasswordLength :l(:$length) = 8, Str :x(:$exclude) = '' ) {\n    &USAGE() if 1 == (.comb ∖ $exclude.comb).elems for @char-groups; \n    .say for password-characters($length, $exclude )\n        .map( *.split(' ') )\n        .map( *.pick: Inf ) # shuffle, so we don't get a predictable pattern\n        .map( *.join )\n        .head( $count );\n}\n\nsub password-characters( $len, $exclude ) {\n    ( (( char-groups($exclude)       xx Inf ).map: *.pick).batch(     4)\n     Z~\n      (( char-groups($exclude, $len) xx Inf ).map: *.pick).batch($len-4) )\n}\n\nmulti char-groups( $exclude )              { | @char-groups.map( * (-) $exclude.comb ) }\nmulti char-groups( $exclude, $max-weight ) { flat (char-groups($exclude)>>.keys.map: {$_ xx ^$max-weight .roll}) }\n\nsub USAGE() {\n    say qq:to/END/;\n    Specify a length:              -l=10    (minimum 4)\n    Specify a count:               -c=5     (minimum 1)\n    Specify characters to exclude: -x=xkcd  (optional)\n    Password must have at least one of each: lowercase letter, uppercase letter, digit, punctuation.\n   END\n}\n\n```\n\n**Sample output:**\n\nWithout parameters:\n\n```\nd[G2r4;i\n```\n\nWith passed parameters: -c=5 -l=12 -x=aeiou\n\n```\nx7)YbEZQ2xp2\nCEpZ>#4'rO7d\npn(5B;wb66DM\nKA;3T7=s+I5{\nLL<tB~L1~Y*q\n```"}]}
{"messages": [{"role": "user", "content": "Most programmers are familiar with the inexactness of floating point calculations in a binary processor.\n\nThe classic example being:\n\n```\n0.1 + 0.2 =  0.30000000000000004\n\n```\n\nIn many situations the amount of error in such calculations is very small and can be overlooked or eliminated with rounding.\n\nThere are pathological problems however, where seemingly simple, straight-forward calculations are extremely sensitive to even tiny amounts of imprecision.\n\nThis task's purpose is to show how your language deals with such classes of problems.\n\n**A sequence that seems to converge to a wrong limit.**\n\nConsider the sequence:\n\n:   :   :   :   :   :   v1 = 2\n                    :   v2 = -4\n                    :   vn = 111   -   1130   /   vn-1   +   3000  /   (vn-1 \\* vn-2)\n\nAs   **n**   grows larger, the series should converge to   **6**   but small amounts of error will cause it to approach   **100**.\n\nTask 1\n\nDisplay the values of the sequence where   n =   3, 4, 5, 6, 7, 8, 20, 30, 50 & 100   to at least **16** decimal places.\n\n```\n    n = 3     18.5\n    n = 4      9.378378\n    n = 5      7.801153\n    n = 6      7.154414\n    n = 7      6.806785\n    n = 8      6.5926328\n    n = 20     6.0435521101892689\n    n = 30     6.006786093031205758530554\n    n = 50     6.0001758466271871889456140207471954695237\n    n = 100    6.000000019319477929104086803403585715024350675436952458072592750856521767230266\n\n```\n\nTask 2\n\n**The Chaotic Bank Society**   is offering a new investment account to their customers.\n\nYou first deposit   $e - 1   where   e   is   2.7182818...   the base of natural logarithms.\n\nAfter each year, your account balance will be multiplied by the number of years that have passed, and $1 in service charges will be removed.\n\nSo ...\n\n:   :   * after 1 year, your balance will be multiplied by 1 and $1 will be removed for service charges.\n        * after 2 years your balance will be doubled and $1 removed.\n        * after 3 years your balance will be tripled and $1 removed.\n        * **...**\n        * after 10 years, multiplied by 10 and $1 removed, and so on.\n\nWhat will your balance be after   25   years?\n\n```\n   Starting balance: $e-1\n   Balance = (Balance * year) - 1 for 25 years\n   Balance after 25 years: $0.0399387296732302\n\n```\n\nTask 3, extra credit\n\n**Siegfried Rump's example.**   Consider the following function, designed by Siegfried Rump in 1988.\n\n:   :   :   :   :   :   f(a,b) = 333.75b6 + a2( 11a2b2 - b6 - 121b4 - 2 ) + 5.5b8 + a/(2b)\n                    :   compute    f(a,b)    where    a=77617.0    and    b=33096.0\n                    :   f(77617.0, 33096.0)   =   -0.827396059946821\n\nDemonstrate how to solve at least one of the first two problems, or both, and the third if you're feeling particularly jaunty.\n\nSee also;\n\n* Floating-Point Arithmetic   Section 1.3.2 Difficult problems."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016-01\n\nThe simple solution to doing calculations where floating point numbers exhibit pathological behavior is: don't do floating point calculations. :-) Raku is just as susceptible to floating point error as any other C based language, however, it offers built-in rational Types; where numbers are represented as a ratio of two integers. For normal precision it uses Rats - accurate to 1/2^64, and for arbitrary precision, FatRats, whose denominators can grow as large as available memory. Rats don't require any special setup to use. Any decimal number within its limits of precision is automatically stored as a Rat. FatRats require explicit coercion and are \"sticky\". Any FatRat operand in a calculation will cause all further results to be stored as FatRats.\n\n```\nsay '1st: Convergent series';\nmy @series = 2.FatRat, -4, { 111 - 1130 / $^v + 3000 / ( $^v * $^u ) } ... *;\nfor flat 3..8, 20, 30, 50, 100 -> $n {say \"n = {$n.fmt(\"%3d\")} @series[$n-1]\"};\n\nsay \"\\n2nd: Chaotic bank society\";\nsub postfix:<!> (Int $n) { [*] 2..$n } # factorial operator\nmy $years = 25;\nmy $balance = sum map { 1 / FatRat.new($_!) }, 1 .. $years + 15; # Generate e-1  to sufficient precision with a Taylor series\nput \"Starting balance, \\$(e-1): \\$$balance\";\nfor 1..$years -> $i { $balance = $i * $balance - 1 }\nprintf(\"After year %d, you will have \\$%1.16g in your account.\\n\", $years, $balance);\n\nprint \"\\n3rd: Rump's example: f(77617.0, 33096.0) = \";\nsub f (\\a, \\b) { 333.75*b⁶ + a²*( 11*a²*b² - b⁶ - 121*b⁴ - 2 ) + 5.5*b⁸ + a/(2*b) }\nsay f(77617.0, 33096.0).fmt(\"%0.16g\");\n\n```\n\nOutput:\n\n```\n1st: Convergent series\nn =   3 18.5\nn =   4 9.378378\nn =   5 7.801153\nn =   6 7.154414\nn =   7 6.806785\nn =   8 6.5926328\nn =  20 6.0435521101892689\nn =  30 6.006786093031205758530554\nn =  50 6.0001758466271871889456140207471954695237\nn = 100 6.000000019319477929104086803403585715024350675436952458072592750856521767230266\n\n2nd: Chaotic bank society\nStarting balance, $(e-1): $1.7182818284590452353602874713526624977572470936999\nAfter year 25, you will have $0.0399387296732302 in your account.\n\n3rd: Rump's example: f(77617.0, 33096.0) = -0.827396059946821\n\n```"}]}
{"messages": [{"role": "user", "content": "In chess, a queen attacks positions from where it is, in straight lines up-down and left-right as well as on both its diagonals. It attacks only pieces *not* of its own colour.\n\n|  |  |  |  |  |\n| --- | --- | --- | --- | --- |\n|  | ⇖ | ⇑ | ⇗ |  |\n| ⇐ | ⇐ | ♛ | ⇒ | ⇒ |\n|  | ⇙ | ⇓ | ⇘ |  |\n| ⇙ |  | ⇓ |  | ⇘ |\n|  |  | ⇓ |  |  |\n\nThe goal of Peaceful chess queen armies is to arrange `m` black queens and `m` white queens on an `n-by-n` square grid, (the board), so that *no queen attacks another of a different colour*.\n\nTask\n\n1. Create a routine to represent two-colour queens on a 2-D board. (Alternating black/white background colours, Unicode chess pieces and other embellishments are not necessary, but may be used at your discretion).\n2. Create a routine to generate at least one solution to placing `m` equal numbers of black and white queens on an `n` square board.\n3. Display here results for the `m=4, n=5` case.\n\nReferences\n\n* Peaceably Coexisting Armies of Queens (Pdf) by Robert A. Bosch. Optima, the Mathematical Programming Socity newsletter, issue 62.\n* A250000 OEIS"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\n# recursively place the next queen\nsub place ($board, $n, $m, $empty-square) {\n    my $cnt;\n    state (%seen,$attack);\n    state $solution = False;\n\n    # logic of regex: queen ( ... paths between queens containing only empty squares ... ) queen of other color\n    once {\n      my %Q = 'WBBW'.comb; # return the queen of alternate color\n      my $re =\n        '(<[WB]>)' ~                # 1st queen\n        '[' ~\n          join(' |',\n            qq/<[$empty-square]>*/,\n            map {\n              qq/ . ** {$_}[<[$empty-square]> . ** {$_}]*/\n            }, $n-1, $n, $n+1\n          ) ~\n        ']' ~\n        '<{%Q{$0}}>';               # 2nd queen\n      $attack = \"rx/$re/\".EVAL;\n    }\n\n    # return first result found (omit this line to get last result found)\n    return $solution if $solution;\n\n    # bail out if seen this configuration previously, or attack detected\n    return if %seen{$board}++ or $board ~~ $attack;\n\n    # success if queen count is m×2, set state variable and return from recursion\n    $solution = $board and return if $m * 2 == my $queens = $board.comb.Bag{<W B>}.sum;\n\n    # place the next queen (alternating colors each time)\n    place( $board.subst( /<[◦•]>/, {<W B>[$queens % 2]}, :nth($cnt) ), $n, $m, $empty-square )\n        while $board ~~ m:nth(++$cnt)/<[◦•]>/;\n\n    return $solution\n}\n\nmy ($m, $n) = @*ARGS == 2 ?? @*ARGS !! (4, 5);\nmy $empty-square = '◦•';\nmy $board = ($empty-square x $n**2).comb.rotor($n)>>.join[^$n].join: \"\\n\";\n\nmy $solution = place $board, $n, $m, $empty-square;\n\nsay $solution\n    ?? \"Solution to $m $n\\n\\n{S:g/(\\N)/$0 / with $solution}\"\n    !! \"No solution to $m $n\";\n\n```\n\nOutput:\n\n```\nW • ◦ • W\n• ◦ B ◦ •\n◦ B ◦ B ◦\n• ◦ B ◦ •\nW • ◦ • W\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nProduce a graphical or ASCII-art representation of a Peano curve of at least order 3."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.06\n\n```\nuse SVG;\n\nrole Lindenmayer {\n    has %.rules;\n    method succ {\n        self.comb.map( { %!rules{$^c} // $c } ).join but Lindenmayer(%!rules)\n    }\n}\n\nmy $peano = 'L' but Lindenmayer( { 'L' => 'LFRFL-F-RFLFR+F+LFRFL', 'R' => 'RFLFR+F+LFRFL-F-RFLFR' } );\n\n$peano++ xx 4;\nmy @points = (10, 10);\n\nfor $peano.comb {\n    state ($x, $y) = @points[0,1];\n    state $d = 0 + 8i;\n    when 'F' { @points.append: ($x += $d.re).round(1), ($y += $d.im).round(1) }\n    when /< + - >/ { $d *= \"{$_}1i\" }\n    default { }\n}\n\nsay SVG.serialize(\n    svg => [\n        :660width, :660height, :style<stroke:lime>,\n        :rect[:width<100%>, :height<100%>, :fill<black>],\n        :polyline[ :points(@points.join: ','), :fill<black> ],\n    ],\n);\n\n```\n\nSee: Peano curve (SVG image)"}]}
{"messages": [{"role": "user", "content": "**Pell numbers** are an infinite sequence of integers that comprise the denominators of the closest rational approximations to the square root of 2 but have many other interesting uses and relationships.\n\nThe numerators of each term of rational approximations to the square root of 2 may *also* be derived from **Pell numbers**, or may be found by taking half of each term of the related sequence: **Pell-Lucas** or **Pell-companion numbers**.\n\nThe **Pell numbers**: **0, 1, 2, 5, 12, 29, 70, etc.**, are defined by the recurrence relation:\n\n```\n\nP0 = 0;\nP1 = 1;\nPn = 2 × Pn-1 + Pn-2;\n\n\n```\n\nOr, may also be expressed by the closed form formula:\n\n```\n\nPn = ((1 + √2)n - (1 - √2)n) / (2 × √2);\n\n\n```\n\n**Pell-Lucas** or **Pell-companion numbers**: **2, 2, 6, 14, 34, 82, etc.**, are defined by a very similar recurrence relation, differing only in the first two terms:\n\n```\n\nQ0 = 2;\nQ1 = 2;\nQn = 2 × Qn-1 + Qn-2;\n\n\n```\n\nOr, may also be expressed by the closed form formula:\n\n```\n\nQn = (1 + √2)n + (1 - √2)n;\n\n\n```\n\nor\n\n```\n\nQn = P2n / Pn;\n\n\n```\n\nThe sequence of rational approximations to the square root of 2 begins:\n\n```\n\n1/1, 3/2, 7/5, 17/12, 41/29, ...\n\n\n```\n\nStarting from **n = 1**, for each term, the denominator is **Pn** and the numerator is **Qn / 2** or **Pn-1 + Pn**.\n\n**Pell primes** are **Pell numbers** that are prime. **Pell prime indices** are the indices of the primes in the **Pell numbers** sequence. Every **Pell prime** index is prime, though not every prime index corresponds to a prime **Pell number**.\n\nIf you take the sum **S** of the first **4n + 1** **Pell numbers**, the sum of the terms **P2n** and **P2n + 1** will form the square root of **S**.\n\nFor instance, the sum of the **Pell numbers** up to **P5**; **0 + 1 + 2 + 5 + 12 + 29 == 49**, is the square of **P2 + P3 == 2 + 5 == 7**. The sequence of numbers formed by the sums **P2n + P2n + 1** are known as **Newman-Shank-Williams numbers** or **NSW numbers**.\n\n**Pell numbers** may also be used to find Pythagorean triple **near isosceles right triangles**; right triangles whose legs differ by exactly **1**. E.G.: **(3,4,5), (20,21,29), (119,120,169), etc.**\n\nFor **n > 0**, each right triangle hypotenuse is **P2n + 1**. The shorter leg length is the sum of the terms *up to* **P2n + 1**. The longer leg length is **1** more than that.\n\nTask\n\n* Find and show at least the first 10 **Pell numbers**. * Find and show at least the first 10 **Pell-Lucas numbers**. * Use the **Pell** (and optionally, **Pell-Lucas**) **numbers** sequence to find and show at least the first 10 rational approximations to √2 in both rational and decimal representation. * Find and show at least the first 10 **Pell primes**. * Find and show at least the first 10 indices of **Pell primes**. * Find and show at least the first 10 **Newman-Shank-Williams numbers** * Find and show at least the first 10 Pythagorean triples corresponding to **near isosceles right triangles**.\n\nSee also\n\n* Wikipedia: Pell number * OEIS:A000129 - Pell numbers * OEIS:A002203 - Companion Pell numbers (Pell-Lucas numbers) * OEIS:A001333 - Numerators of continued fraction convergents to sqrt(2) (Companion Pell numbers / 2) * OEIS:A086383 - Prime terms in the sequence of Pell numbers * OEIS:A096650 - Indices of prime Pell numbers * OEIS:A002315 - NSW numbers (Newman-Shank-Williams numbers) * Wikipedia: Pythagorean triple * Pythagorean triples"}, {"role": "assistant", "content": "```\nmy $pell = cache lazy 0, 1, * + * × 2 … *;\nmy $pell-lucas = lazy 2, 2, * + * × 2 … *;\n\nmy $upto = 20;\n\nsay   \"First $upto Pell numbers:\\n\" ~ $pell[^$upto];\n\nsay \"\\nFirst $upto Pell-Lucas numbers:\\n\" ~ $pell-lucas[^$upto];\n\nsay \"\\nFirst $upto rational approximations of √2 ({sqrt(2)}):\\n\" ~\n(1..$upto).map({ sprintf \"%d/%d - %1.16f\", $pell[$_-1] + $pell[$_], $pell[$_], ($pell[$_-1]+$pell[$_])/$pell[$_] }).join: \"\\n\";\n\nsay \"\\nFirst $upto Pell primes:\\n\" ~ $pell.grep(&is-prime)[^$upto].join: \"\\n\";\n\nsay \"\\nIndices of first $upto Pell primes:\\n\" ~ (^∞).grep({$pell[$_].is-prime})[^$upto];\n\nsay \"\\nFirst $upto Newman-Shank-Williams numbers:\\n\" ~ (^$upto).map({ $pell[2 × $_, 2 × $_+1].sum });\n\nsay \"\\nFirst $upto near isosceles right triangles:\";\nmap -> \\p { printf \"(%d, %d, %d)\\n\", |($_, $_+1 given $pell[^(2 × p + 1)].sum), $pell[2 × p + 1] }, 1..$upto;\n\n```\n\nOutput:\n\n```\nFirst 20 Pell numbers:\n0 1 2 5 12 29 70 169 408 985 2378 5741 13860 33461 80782 195025 470832 1136689 2744210 6625109\n\nFirst 20 Pell-Lucas numbers:\n2 2 6 14 34 82 198 478 1154 2786 6726 16238 39202 94642 228486 551614 1331714 3215042 7761798 18738638\n\nFirst 20 rational approximations of √2 (1.4142135623730951):\n1/1 - 1.0000000000000000\n3/2 - 1.5000000000000000\n7/5 - 1.4000000000000000\n17/12 - 1.4166666666666667\n41/29 - 1.4137931034482758\n99/70 - 1.4142857142857144\n239/169 - 1.4142011834319526\n577/408 - 1.4142156862745099\n1393/985 - 1.4142131979695431\n3363/2378 - 1.4142136248948696\n8119/5741 - 1.4142135516460548\n19601/13860 - 1.4142135642135643\n47321/33461 - 1.4142135620573204\n114243/80782 - 1.4142135624272734\n275807/195025 - 1.4142135623637995\n665857/470832 - 1.4142135623746899\n1607521/1136689 - 1.4142135623728214\n3880899/2744210 - 1.4142135623731420\n9369319/6625109 - 1.4142135623730870\n22619537/15994428 - 1.4142135623730965\n\nFirst 20 Pell primes:\n2\n5\n29\n5741\n33461\n44560482149\n1746860020068409\n68480406462161287469\n13558774610046711780701\n4125636888562548868221559797461449\n4760981394323203445293052612223893281\n161733217200188571081311986634082331709\n2964793555272799671946653940160950323792169332712780937764687561\n677413820257085084326543915514677342490435733542987756429585398537901\n4556285254333448771505063529048046595645004014152457191808671945330235841\n54971607658948646301386783144964782698772613513307493180078896702918825851648683235325858118170150873214978343601463118106546653220435805362395962991295556488036606954237309847762149971207793263738989\n14030291214037674827921599320400561033992948898216351802670122530401263880575255235196727095109669287799074570417579539629351231775861429098849146880746524269269235328805333087546933690012894630670427794266440579064751300508834822795162874147983974059159392260220762973563561382652223360667198516093199367134903695783143116067743023134509886357032327271649\n2434804314652199381956027075145741187716221548707931096877274520825143228915116227412484991366386864484767844200542482630246332092069382947111767723898168035847078557798454111405556629400142434835890123610082763986456199467423944182141028870863302603437534363208996458153115358483747994095302552907353919742211197822912892578751357668345638404394626711701120567186348490247426710813709165801137112237291901437566040249805155494297005186344325519103590369653438042689\n346434895614929444828445967916634653215454504812454865104089892164276080684080254746939261017687341632569935171059945916359539268094914543114024020158787741692287531903178502306292484033576487391159597130834863729261484555671037916432206867189514675750227327687799973497042239286045783392065227614939379139866240959756584073664244580698830046194724340448293320938108876004367449471918175071251610962540447986139876845105399212429593945098472125140242905536711601925585608153109062121115635939797709\n32074710952523740376423283403256578238321646122759160107427497117576305397686814013623874765833543023397971470911301264845142006214276865917420065183527313421909784286074786922242104480428021290764613639424408361555091057197776876849282654018358993099016644054242247557103410808928387071991436781136646322261169941417916607548507224950058710729258466238995253184617782314756913932650536663800753256087990078866003788647079369825102832504351225446531057648755795494571534144773842019836572551455718577614678081652481281009\n\nIndices of first 20 Pell primes:\n2 3 5 11 13 29 41 53 59 89 97 101 167 181 191 523 929 1217 1301 1361\n\nFirst 20 Newman-Shank-Williams numbers:\n1 7 41 239 1393 8119 47321 275807 1607521 9369319 54608393 318281039 1855077841 10812186007 63018038201 367296043199 2140758220993 12477253282759 72722761475561 423859315570607\n\nFirst 20 near isosceles right triangles:\n(3, 4, 5)\n(20, 21, 29)\n(119, 120, 169)\n(696, 697, 985)\n(4059, 4060, 5741)\n(23660, 23661, 33461)\n(137903, 137904, 195025)\n(803760, 803761, 1136689)\n(4684659, 4684660, 6625109)\n(27304196, 27304197, 38613965)\n(159140519, 159140520, 225058681)\n(927538920, 927538921, 1311738121)\n(5406093003, 5406093004, 7645370045)\n(31509019100, 31509019101, 44560482149)\n(183648021599, 183648021600, 259717522849)\n(1070379110496, 1070379110497, 1513744654945)\n(6238626641379, 6238626641380, 8822750406821)\n(36361380737780, 36361380737781, 51422757785981)\n(211929657785303, 211929657785304, 299713796309065)\n(1235216565974040, 1235216565974041, 1746860020068409)\n```"}]}
{"messages": [{"role": "user", "content": "**Pell's equation**   (also called the **Pell–Fermat** equation)   is a   Diophantine equation   of the form:\n\n:   :   :   :   :   :   **x2   -   ny2   =   1**\n\nwith integer solutions for   **x**   and   **y**,   where   **n**   is a given non-square positive integer.\n\nTask requirements\n:   * find the smallest solution in positive integers to Pell's equation for   **n** = {61, 109, 181, 277}.\n\nSee also\n:   * Wikipedia entry: Pell's equation."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\n**Translation of**: Perl\n\n```\nuse Lingua::EN::Numbers;\n\nsub pell (Int $n) {\n\n    my $y = my $x = Int(sqrt $n);\n    my $z = 1;\n    my $r = 2 * $x;\n\n    my ($e1, $e2) = (1, 0);\n    my ($f1, $f2) = (0, 1);\n\n    loop {\n        $y = $r * $z - $y;\n        $z = Int(($n - $y²) / $z);\n        $r = Int(($x + $y) / $z);\n\n        ($e1, $e2) = ($e2, $r * $e2 + $e1);\n        ($f1, $f2) = ($f2, $r * $f2 + $f1);\n\n        my $A = $e2 + $x * $f2;\n        my $B = $f2;\n\n        if ($A² - $n * $B² == 1) {\n            return ($A, $B);\n        }\n    }\n}\n\nfor 61, 109, 181, 277, 8941 -> $n {\n    next if $n.sqrt.narrow ~~ Int;\n    my ($x, $y) = pell($n);\n    printf \"x² - %sy² = 1 for:\\n\\tx = %s\\n\\ty = %s\\n\\n\", $n, |($x, $y)».&comma;\n}\n\n```\n\nOutput:\n\n```\nx² - 61y² = 1 for:\n\tx = 1,766,319,049\n\ty = 226,153,980\n\nx² - 109y² = 1 for:\n\tx = 158,070,671,986,249\n\ty = 15,140,424,455,100\n\nx² - 181y² = 1 for:\n\tx = 2,469,645,423,824,185,801\n\ty = 183,567,298,683,461,940\n\nx² - 277y² = 1 for:\n\tx = 159,150,073,798,980,475,849\n\ty = 9,562,401,173,878,027,020\n\nx² - 8941y² = 1 for:\n\tx = 2,565,007,112,872,132,129,669,406,439,503,954,211,359,492,684,749,762,901,360,167,370,740,763,715,001,557,789,090,674,216,330,243,703,833,040,774,221,628,256,858,633,287,876,949,448,689,668,281,446,637,464,359,482,677,366,420,261,407,112,316,649,010,675,881,349,744,201\n\ty = 27,126,610,172,119,035,540,864,542,981,075,550,089,190,381,938,849,116,323,732,855,930,990,771,728,447,597,698,969,628,164,719,475,714,805,646,913,222,890,277,024,408,337,458,564,351,161,990,641,948,210,581,361,708,373,955,113,191,451,102,494,265,278,824,127,994,180\n```"}]}
{"messages": [{"role": "user", "content": "Penholodigital squares are perfect square numbers that contain all of the digits from the base in which the number is represented, except for zero, exactly once.\n\n*From the Latin prefix **pene-** (before, or next to, nearly)*  \n\n*and **holo-** (whole, or all)*\n\n***penholodigital**: Nearly-all-digits.*\n\nSo, in a particular base, a penholodigital square number will contain all of the digits used in that base (except zero) once, and only once. Base eight penholodigitals contain the digits 1 through 7, base 10, 1 through 9, etc.\n\nFor example\n\nIn base 10, **139854276** is a penholodigital square. It is the square of the integer **11826**, and contains every digit from 1 through 9 exactly once.\n\nPenholodigital squares can occur in many, though not every, base. They tend to be pretty rare in lower bases.\n\n```\nThere is a total of 1 penholodigital squares in base 2:\n1² = 1\n\nThere is a total of 0 penholodigital squares in base 3:\n\nThere is a total of 0 penholodigital squares in base 4:\n\nThere is a total of 0 penholodigital squares in base 5:\n\nThere is a total of 2 penholodigital squares in base 6:\n122² = 15324, 221² = 53241\n\nThere is a total of 1 penholodigital squares in base 7:\n645² = 623514\n\nThere is a total of 1 penholodigital squares in base 8:\n2453² = 6532471\n```\n\nTask\n\nFind and display the total count, and the penholodigital squares and the integers that are squared to produce them, represented in the base in which they are calculated, for bases 9, 10, 11 and 12.\n\nStretch\n\nFind and display the total count, and the **first and last** penholodigital squares and the integers that are squared to produce them, represented in the base in which they are calculated, for bases 13, 14, 15, ... ?\n\nSee also\n\n* OEIS:A036744 - Penholodigital squares in base 10 * Related task: First perfect square in base n with n unique digits"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\n\n(9 .. 12).map: -> $base {\n    my $test = (1 ..^ $base)».base($base).join;\n    my $skip = ($base - 1).&prime-factors.tail;\n    my $start = $test     .parse-base($base).sqrt.Int div $skip;\n    my $end   = $test.flip.parse-base($base).sqrt.Int div $skip;\n    say \"\\nThere is a total of {+$_} penholodigital squares in base $base:\\n\" ~\n        .map({\"{.base($base)}² = {.².base($base)}\"}).batch(3)».join(\", \").join: \"\\n\" given\n        cache ($start .. $end).map({$_ * $skip}).hyper.map: { next unless .².base($base).comb.sort.join eq $test; $_ } \n}\n\n(13 .. 16).map: -> $base {\n    my $test = (1 ..^ $base)».base($base).join;\n    my $skip = ($base - 1).&prime-factors.tail;\n    my $start = $test     .parse-base($base).sqrt.Int div $skip;\n    my $end   = $test.flip.parse-base($base).sqrt.Int div $skip;\n    my @penholo = ($start .. $end).map({$_ * $skip}).hyper.map: { next unless .².base($base).comb.sort.join eq $test; $_ } \n    say \"\\nThere is a total of {+@penholo} penholodigital squares in base $base:\";\n    say @penholo[0,*-1].map({\"{.base($base)}² = {.².base($base)}\"}).batch(3)».join(\", \").join: \"\\n\" if +@penholo;\n}\n\n```\n\nOutput:\n\n```\nThere is a total of 10 penholodigital squares in base 9:\n3825² = 16328547, 3847² = 16523874, 4617² = 23875614\n4761² = 25487631, 6561² = 47865231, 6574² = 48162537\n6844² = 53184267, 7285² = 58624317, 7821² = 68573241\n8554² = 82314657\n\nThere is a total of 30 penholodigital squares in base 10:\n11826² = 139854276, 12363² = 152843769, 12543² = 157326849\n14676² = 215384976, 15681² = 245893761, 15963² = 254817369\n18072² = 326597184, 19023² = 361874529, 19377² = 375468129\n19569² = 382945761, 19629² = 385297641, 20316² = 412739856\n22887² = 523814769, 23019² = 529874361, 23178² = 537219684\n23439² = 549386721, 24237² = 587432169, 24276² = 589324176\n24441² = 597362481, 24807² = 615387249, 25059² = 627953481\n25572² = 653927184, 25941² = 672935481, 26409² = 697435281\n26733² = 714653289, 27129² = 735982641, 27273² = 743816529\n29034² = 842973156, 29106² = 847159236, 30384² = 923187456\n\nThere is a total of 20 penholodigital squares in base 11:\n42045² = 165742A893, 43152² = 173A652894, 44926² = 18792A6453\n47149² = 1A67395824, 47257² = 1A76392485, 52071² = 249A758631\n54457² = 2719634A85, 55979² = 286A795314, 59597² = 314672A895\n632A4² = 3671A89245, 64069² = 376198A254, 68335² = 41697528A3\n71485² = 46928A7153, 81196² = 5A79286413, 83608² = 632A741859\n86074² = 6713498A25, 89468² = 7148563A29, 91429² = 76315982A4\n93319² = 795186A234, A3A39² = 983251A764\n\nThere is a total of 23 penholodigital squares in base 12:\n117789² = 135B7482A69, 16357B² = 23A5B976481, 16762B² = 24AB5379861\n16906B² = 25386749BA1, 173434² = 26B859A3714, 178278² = 2835BA17694\n1A1993² = 34A8125B769, 1A3595² = 354A279B681, 1B0451² = 3824B7569A1\n1B7545² = 3A5B2487961, 2084A9² = 42A1583B769, 235273² = 5287BA13469\n2528B5² = 5B23A879641, 25B564² = 62937B5A814, 262174² = 63A8527B194\n285A44² = 73B615A8294, 29A977² = 7B9284A5361, 2A7617² = 83AB5479261\n2B0144² = 8617B35A294, 307381² = 93825A67B41, 310828² = 96528AB7314\n319488² = 9AB65823714, 319A37² = 9B2573468A1\n\nThere is a total of 0 penholodigital squares in base 13:\n\nThere is a total of 160 penholodigital squares in base 14:\n1129535² = 126A84D79C53B, 3A03226² = DB3962A7541C8\n\nThere is a total of 419 penholodigital squares in base 15:\n4240C58² = 12378DA5B6EC94, EE25E4A² = ED4C93285671BA\n\nThere is a total of 740 penholodigital squares in base 16:\n11156EB6² = 123DA7F85BCE964, 3FD8F786² = FEC81B69573DA24\n```"}]}
{"messages": [{"role": "user", "content": "Penney's game is a game where two players bet on being the first to see a particular sequence of heads or tails in consecutive tosses of a fair coin.\n\nIt is common to agree on a sequence length of three then one player will openly choose a sequence, for example:\n\n```\n Heads,  Tails,  Heads, or HTH for short.\n\n```\n\nThe other player on seeing the first players choice will choose his sequence. The coin is tossed and the first player to see his sequence in the sequence of coin tosses wins.\n\nExample\n\nOne player might choose the sequence **HHT** and the other **THT**.\n\nSuccessive coin tosses of **HTTHT** gives the win to the second player as the last three coin tosses are his sequence.\n\nTask\n\nCreate a program that tosses the coin, keeps score and plays Penney's game against a human opponent.\n\n* Who chooses and shows their sequence of three should be chosen randomly.\n* If going first, the computer should randomly choose its sequence of three.\n* If going second, the computer should automatically play the optimum sequence.\n* Successive coin tosses should be shown.\n\nShow output of a game where the computer chooses first and a game where the user goes first here on this page.\n\nSee also\n\n* The Penney Ante Part 1 (Video).\n* The Penney Ante Part 2 (Video)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.02\n\n```\nenum Coin <Heads Tails>;\nenum Yay <Yay Good Super Hah Ooh Yipee Sweet Cool Yes Haha>;\nenum Boo <Drat Darn Crumb Oops Rats Bah Criminy Argh Shards>;\nenum Bozo «'Dude' 'Cha' 'Bzzt' 'Hey' 'Silly dilly' 'Say what!?' 'You numbskull'»;\n\nsub flipping {\n    for 1..4 {\n        print \"-\\b\";  sleep .1;\n        print \"\\\\\\b\"; sleep .1;\n        print \"|\\b\";  sleep .1;\n        print \"/\\b\";  sleep .1;\n    }\n}\n \nsub your-choice($p is copy) {\n    loop (my @seq; @seq != 3; $p = \"{Bozo.pick}! Please pick exactly 3: \") {\n        @seq = prompt($p).uc.comb(/ H | T /).map: {\n            when 'H' { Heads }\n            when 'T' { Tails }\n        }\n    }\n    @seq;\n}\n \nrepeat until prompt(\"Wanna play again? \").lc ~~ /^n/ {\n    my $mefirst = Coin.roll;\n    print tc \"$mefirst I start, {Coin(+!$mefirst).lc} you start, flipping...\\n\\t\";\n    flipping;\n    say my $flip = Coin.roll;\n\n    my @yours;\n    my @mine;\n\n    if $flip == $mefirst {\n        print \"{Yay.pick}! I get to choose first, and I choose: \"; sleep 2; say @mine = |Coin.roll(3);\n        @yours = your-choice(\"Now you gotta choose: \");\n        while @yours eqv @mine {\n            say \"{Bozo.pick}! We'd both win at the same time if you pick that!\";\n            @yours = your-choice(\"Pick something different from me: \");\n        }\n        say \"So, you'll win if we see: \", @yours;\n    }\n    else {\n        @yours = your-choice(\"{Boo.pick}! First you choose: \");\n        say \"OK, you'll win if we see: \", @yours;\n        print \"In that case, I'll just randomly choose: \"; sleep 2; say @mine = Coin(+!@yours[1]), |@yours[0,1];\n    }\n     \n    sub check($a,$b,$c) {\n        given [$a,$b,$c] {\n            when @mine  { say \"\\n{Yay.pick}, I win, and you lose!\"; Nil }\n            when @yours { say \"\\n{Boo.pick}, you win, but I'll beat you next time!\"; Nil }\n            default     { Coin.roll }\n        }\n    }\n\n    sleep 1;\n    say < OK! Ready? Right... So... Yo!>.pick;\n    sleep .5;\n    say (\"Pay attention now!\",\n        \"Watch closely!\",\n        \"Let's do it...\",\n        \"You feeling lucky?\",\n        \"No way you gonna win this...\",\n        \"Can I borrow that coin again?\").pick;\n    sleep 1;\n    print \"Here we go!\\n\\t\";\n    for |Coin.roll(3), &check ...^ :!defined {\n        flipping;\n        print \"$_ \";\n    }\n}\n\n```\n\nOutput:\n\nNote: the actual run displays a little coin-flipping animation, but that won't show up here:\n\n```\nHeads I start, tails you start, flipping...\n\tHeads\nYipee! I get to choose first, and I choose: Heads Heads Tails\nNow you gotta choose: tth\nSo, you'll win if we see: Tails Tails Heads\nYo!\nCan I borrow that coin again?\nHere we go!\n\tTails Tails Tails Tails Tails Heads \nArgh, you win, but I'll beat you next time!\nWanna play again? y\nTails I start, heads you start, flipping...\n\tTails\nYes! I get to choose first, and I choose: Heads Tails Tails\nNow you gotta choose: H T T\nDude! We'd both win at the same time if you pick that!\nPick something different from me: heads tails tails\nSilly dilly! We'd both win at the same time if you pick that!\nPick something different from me: h,h,h\nSo, you'll win if we see: Heads Heads Heads\nOK!\nYou feeling lucky?\nHere we go!\n\tTails Tails Tails Heads Heads Heads \nDrat, you win, but I'll beat you next time!\nWanna play again? y\nHeads I start, tails you start, flipping...\n\tTails\nShards! First you choose: tht\nOK, you'll win if we see: Tails Heads Tails\nIn that case, I'll just randomly choose: Tails Tails Heads\nRight...\nPay attention now!\nHere we go!\n\tHeads Tails Tails Heads \nHah, I win, and you lose!\nWanna play again? n\n```"}]}
{"messages": [{"role": "user", "content": "A Penrose tiling can cover an entire plane without creating a pattern that periodically repeats.\n\nThere are many tile sets that can create non-periodic tilings, but those can typically also be used to create a periodic\ntiling. What makes Penrose tiles special is that they *can only be used to produce non-periodic tilings*.\n\nThe two best-known Penrose tile sets are `Kite and Dart (P2)` and `Thin Rhombus and Fat Rhombus (P3)`\n\nThese so-called prototiles are usually depicted with smooth edges, but in reality Penrose tiles have interlocking tabs\nand cut-outs like the pieces of a jigsaw puzzle. For convenience these deformations are often replaced\nwith *matching rules*, which ensure that the tiles are only connected in ways that guarantee\na non-periodic tiling. (Otherwise, for instance, you could combine the kite and dart to form a rhombus,\nand easily create a periodic tiling from there.)\n\nYou can construct a Penrose tiling by setting up some prototiles, and adding tiles through trial and error, backtracking whenever you get stuck.\n\nMore commonly a method is used that takes advantage of the fact that Penrose tilings, like fractals,\nhave a self-similarity on different levels. When zooming out it can be observed that groups of tiles are enclosed in areas that\nform exactly the same pattern as the tiles on the lower level. Departing from an inflated level, the prototiles can be\nsubdivided into smaller tiles, always observing the matching rules. The subdivision may have to be repeated several times, before the desired level of detail is reached. This process is called deflation.\n\nMore information can be found through the links below.\n\n**The task**: fill a rectangular area with a Penrose tiling.\n\nSee also\n\n* A good introduction (ams.org)\n* Deflation explained for both sets (tartarus.org)\n* Deflation explained for Kite and Dart, includes Python code (preshing.com)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.05\n\nGenerated with a P3 tile set using a Lindenmayer system.\n\n```\nuse SVG;\n\nrole Lindenmayer {\n    has %.rules;\n    method succ {\n\t    self.comb.map( { %!rules{$^c} // $c } ).join but Lindenmayer(%!rules)\n    }\n}\n\nmy $penrose = '[N]++[N]++[N]++[N]++[N]' but Lindenmayer(\n    {\n        A => '',\n        M => 'OA++PA----NA[-OA----MA]++',\n        N => '+OA--PA[---MA--NA]+',\n        O => '-MA++NA[+++OA++PA]-',\n        P => '--OA++++MA[+PA++++NA]--NA'\n    }\n);\n\n$penrose++ xx 4;\n\nmy @lines;\nmy @stack;\n\nfor $penrose.comb {\n    state ($x, $y) = 300, 200;\n    state $d = 55 + 0i;\n    when 'A' { @lines.push: 'line' => [:x1($x.round(.01)), :y1($y.round(.01)), :x2(($x += $d.re).round(.01)), :y2(($y += $d.im).round(.01))] }\n    when '[' { @stack.push: ($x.clone, $y.clone, $d.clone) }\n    when ']' { ($x, $y, $d) = @stack.pop }\n    when '+' { $d *= cis -π/5 }\n    when '-' { $d *= cis  π/5 }\n    default { }\n}\n\nsay SVG.serialize(\n    svg => [\n        :600width, :400height, :style<stroke:rgb(250,12,210)>,\n        :rect[:width<100%>, :height<100%>, :fill<black>],\n        |@lines,\n    ],\n);\n\n```\n\nSee: Penrose tiling image"}]}
{"messages": [{"role": "user", "content": "Generate the sequence of penta-power prime seeds: positive integers **n** such that:\n\n```\n   n0 + n + 1, n1 + n + 1, n2 + n + 1, n3 + n + 1 and n4 + n + 1 are all prime.\n\n```\n\nTask\n\n* Find and display the first thirty penta-power prime seeds. (Or as many as are reasonably supported by your languages math capability if it is less.)\n\nStretch\n\n* Find and display the position and value of first with a value greater than ten million.\n\nSee also\n\n* Task: Quad-power prime seeds\n\n*I can find no mention or record of this sequence anywhere. Perhaps I've invented it.*"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\n\nmy @ppps = lazy (^∞).hyper(:5000batch).map(* × 2 + 1).grep: -> \\n { my \\k = n + 1; (1+k).is-prime && (n+k).is-prime && (n²+k).is-prime && (n³+k).is-prime && (n⁴+k).is-prime }\n\nsay \"First thirty penta-power prime seeds:\\n\" ~ @ppps[^30].batch(10)».&comma».fmt(\"%9s\").join: \"\\n\";\n\nsay \"\\nFirst penta-power prime seed greater than:\";\n\nfor 1..10 {\n    my $threshold = Int(1e6 × $_);\n    my $key = @ppps.first: * > $threshold, :k;\n    say \"{$threshold.&cardinal.fmt: '%13s'} is the {ordinal-digit $key + 1}: {@ppps[$key].&comma}\";\n}\n\n```\n\nOutput:\n\n```\nFirst thirty penta-power prime seeds:\n        1         5        69     1,665     2,129    25,739    29,631    62,321    77,685    80,535\n   82,655   126,489   207,285   211,091   234,359   256,719   366,675   407,945   414,099   628,859\n  644,399   770,531   781,109   782,781   923,405 1,121,189 1,158,975 1,483,691 1,490,475 1,512,321\n\nFirst penta-power prime seed greater than:\n  one million is the 26th: 1,121,189\n  two million is the 39th: 2,066,079\nthree million is the 47th: 3,127,011\n four million is the 51st: 4,059,525\n five million is the 59th: 5,279,175\n  six million is the 63rd: 6,320,601\nseven million is the 68th: 7,291,361\neight million is the 69th: 8,334,915\n nine million is the 71st: 9,100,671\n  ten million is the 72nd: 10,347,035\n```"}]}
{"messages": [{"role": "user", "content": "A pentagram is a star polygon, consisting of a central pentagon of which each side forms the base of an isosceles triangle. The vertex of each triangle, a point of the star, is 36 degrees.\n\nTask\n\nDraw (or print) a regular pentagram, in any orientation. Use a different color (or token) for stroke and fill, and background. For the fill it should be assumed that all points inside the triangles and the pentagon are inside the pentagram.\n\nSee also\n\n* Angle sum of a pentagram"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.08\n\nGenerate an SVG file to STDOUT. Redirect to a file to capture and display it.\n\n```\nuse SVG;\n\nconstant $dim = 200;\nconstant $sides = 5;\n\nmy @vertices = map { 0.9 * $dim * cis($_ * τ / $sides) }, ^$sides;\n\nmy @points   = map |*.reals.fmt(\"%0.3f\"),\n  flat @vertices[0, 2 ... *], @vertices[1, 3 ... *], @vertices[0];\n\nsay SVG.serialize(\n    svg => [\n        :width($dim*2), :height($dim*2),\n        :rect[:width<100%>, :height<100%>, :style<fill:bisque;>],\n        :polyline[ :points(@points.join: ','),\n          :style(\"stroke:blue; stroke-width:3; fill:seashell;\"),\n          :transform(\"translate($dim,$dim) rotate(-90)\")\n        ],\n    ],\n);\n\n```\n\nSee Pentagram (offsite svg image)\n\nEver wondered what a regular 7 sided star looks like? Change $sides to 7 and re-run.\nSee Heptagram"}]}
{"messages": [{"role": "user", "content": "A pentomino is a polyomino that consists of 5 squares. There are 12 pentomino shapes,\nif you don't count rotations and reflections. Most pentominoes can form their own mirror image through\nrotation, but some of them have to be flipped over.\n\n```\n        I                                                                        \n        I     L       N                                                 Y        \n FF     I     L      NN     PP     TTT              V       W     X    YY      ZZ\nFF      I     L      N      PP      T     U U       V      WW    XXX    Y      Z \n F      I     LL     N      P       T     UUU     VVV     WW      X     Y     ZZ\n```\n\nA Pentomino tiling is an example of an exact cover problem and can take on many forms.\nA traditional tiling presents an 8 by 8 grid, where 4 cells are left uncovered. The other cells are covered\nby the 12 pentomino shapes, without overlaps, with every shape only used once.\n\nThe 4 uncovered cells should be chosen at random. Note that not all configurations are solvable.\n\nTask\n\nCreate an 8 by 8 tiling and print the result.\n\nExample\n\n```\nF I I I I I L N\nF F F L L L L N\nW F - X Z Z N N\nW W X X X Z N V\nT W W X - Z Z V\nT T T P P V V V\nT Y - P P U U U\nY Y Y Y P U - U\n```\n\nRelated tasks\n\n* Free polyominoes enumeration"}, {"role": "assistant", "content": "**Translation of**: Java\n\n```\n# 20201028 Raku programming solution\n\nmy \\F = [ <1 -1 1 0 1 1 2 1>,  <0 1 1 -1 1 0 2 0>,   <1 0 1 1 1 2 2 1>,\n          <1 0 1 1 2 -1 2 0>,  <1 -2 1 -1 1 0 2 -1>, <0 1 1 1 1 2 2 1>,\n          <1 -1 1 0 1 1 2 -1>, <1 -1 1 0 2 0 2 1> ];\n\nmy \\I = [ <0 1 0 2 0 3 0 4>, <1 0 2 0 3 0 4 0> ];\n\nmy \\L = [ <1 0 1 1 1 2 1 3>,  <1 0 2 0 3 0 3 1>,   <0 1 0 2 0 3 1 3>,\n          <0 1 1 0 2 0 3 0>,  <0 1 1 1 2 1 3 1>,   <0 1 0 2 0 3 1 0>,\n          <1 0 2 0 3 -1 3 0>, <1 -3 1 -2 1 -1 1 0> ];\n\nmy \\N = [ <0 1 1 -2 1 -1 1 0>, <1 0 1 1 2 1 3 1>,   <0 1 0 2 1 -1 1 0>,\n          <1 0 2 0 2 1 3 1>,   <0 1 1 1 1 2 1 3>,   <1 0 2 -1 2 0 3 -1>,\n          <0 1 0 2 1 2 1 3>,   <1 -1 1 0 2 -1 3 -1> ];\n\nmy \\P = [ <0 1 1 0 1 1 2 1>,  <0 1 0 2 1 0 1 1>, <1 0 1 1 2 0 2 1>,\n          <0 1 1 -1 1 0 1 1>, <0 1 1 0 1 1 1 2>, <1 -1 1 0 2 -1 2 0>,\n          <0 1 0 2 1 1 1 2>,  <0 1 1 0 1 1 2 0> ];\n\nmy \\T = [ <0 1 0 2 1 1 2 1>,  <1 -2 1 -1 1 0 2 0>,\n          <1 0 2 -1 2 0 2 1>, <1 0 1 1 1 2 2 0> ];\n\nmy \\U = [ <0 1 0 2 1 0 1 2>, <0 1 1 1 2 0 2 1>,\n          <0 2 1 0 1 1 1 2>, <0 1 1 0 2 0 2 1> ];\n\nmy \\V = [ <1 0 2 0 2 1 2 2>,   <0 1 0 2 1 0 2 0>,\n          <1 0 2 -2 2 -1 2 0>, <0 1 0 2 1 2 2 2>  ];\n\nmy \\W = [ <1 0 1 1 2 1 2 2>, <1 -1 1 0 2 -2 2 -1>,\n          <0 1 1 1 1 2 2 2>, <0 1 1 -1 1 0 2 -1>  ];\n\nmy \\X = [ <1 -1 1 0 1 1 2 0> , ]; # self-ref: reddit.com/r/rakulang/comments/jpys5p/gbi71jt/\n\nmy \\Y = [ <1 -2 1 -1 1 0 1 1>, <1 -1 1 0 2 0 3 0>, <0 1 0 2 0 3 1 1>,\n          <1 0 2 0 2 1 3 0>,   <0 1 0 2 0 3 1 2>,  <1 0 1 1 2 0 3 0>,\n          <1 -1 1 0 1 1 1 2>,  <1 0 2 -1 2 0 3 0> ];\n\nmy \\Z = [ <0 1 1 0 2 -1 2 0>, <1 0 1 1 1 2 2 2>,\n          <0 1 1 1 2 1 2 2>,  <1 -2 1 -1 1 0 2 -2> ];\n\nour @shapes =  F, I, L, N, P, T, U, V, W, X, Y, Z ;\n\nmy @symbols = \"FILNPTUVWXYZ-\".comb;\nmy %symbols = @symbols.pairs;\nmy $nRows = my $nCols = 8; my $blank = 12;\nmy @grid = [ [-1 xx $nCols ] xx $nRows ];\nmy @placed;\n\nsub shuffleShapes {\n   my @rand = (0 ..^+@shapes).pick(*);\n   for (0 ..^+@shapes) -> \\i {\n      (@shapes[i],  @shapes[@rand[i]])  = (@shapes[@rand[i]],  @shapes[i]);\n      (@symbols[i], @symbols[@rand[i]]) = (@symbols[@rand[i]], @symbols[i])\n   }\n}\n\nsub solve($pos,$numPlaced)  {\n   return True if $numPlaced == +@shapes;\n\n   my \\row = $pos div $nCols;\n   my \\col = $pos mod $nCols;\n\n   return solve($pos + 1, $numPlaced) if @grid[row;col] != -1;\n\n   for ^+@shapes -> \\i {\n      if !@placed[i] {\n         for @shapes[i] -> @orientation {\n            for @orientation -> @o {\n               next if !tryPlaceOrientation(@o, row, col, i);\n               @placed[i] = True;\n               return True if solve($pos + 1, $numPlaced + 1);\n               removeOrientation(@o, row, col);\n               @placed[i] = False;\n            }\n         }\n      }\n   }\n   return False\n}\n\nsub tryPlaceOrientation (@o, $r, $c, $shapeIndex) {\n\n   loop (my $i = 0; $i < +@o; $i += 2) {\n      my \\x = $c + @o[$i + 1];\n      my \\y = $r + @o[$i];\n      return False if\n         (x < 0 or x ≥ $nCols or y < 0 or y ≥ $nRows or @grid[y;x] != -1)\n   }\n\n   @grid[$r;$c] = $shapeIndex;\n   loop ($i = 0; $i < +@o; $i += 2) {\n      @grid[ $r + @o[$i] ; $c + @o[$i + 1] ] = $shapeIndex;\n   }\n   return True\n}\n\nsub removeOrientation(@o, $r, $c) {\n   @grid[$r;$c] = -1;\n   loop (my $i = 0; $i < +@o; $i += 2) {\n      @grid[ $r + @o[$i] ; $c + @o[$i + 1] ] = -1;\n   }\n}\n\nsub PrintResult {\n   my $output;\n   for @grid[*] -> @line {\n      $output ~= \"%symbols{$_}  \" for @line;\n      $output ~= \"\\n\"\n   }\n   if my \\Embedded_Marketing_Mode = True {\n      $output .= subst('-', $_.chr) for < 0x24c7 0x24b6 0x24c0 0x24ca >\n   }\n   say $output\n}\n\n#shuffleShapes(); # xkcd.com/221\n\nfor ^4 {\n   loop {\n      if @grid[my \\R = (^$nRows).roll;my \\C = (^$nCols).roll] != $blank\n         { @grid[R;C] = $blank and last }\n   }\n}\n\nPrintResult() if solve 0,0\n\n```\n\nOutput:\n\n```\nF F Ⓡ I I I I I\nⒶ F F N L L L L\nP F N N X U U L\nP P N X X X U Ⓚ\nP P N W X U U T\nV Z Ⓤ W W T T T\nV Z Z Z W W Y T\nV V V Z Y Y Y Y\n```"}]}
{"messages": [{"role": "user", "content": "Compute the percentage of difference between 2 JPEG images of the same size. Alternatively, compare two bitmaps as defined in basic bitmap storage.\n\nUseful for comparing two JPEG images saved with a different compression ratios.\n\nYou can use these pictures for testing (use the full-size version of each):\n\n| 50% quality JPEG | 100% quality JPEG |\n| --- | --- |\n|  |  |\n| link to full size 50% image | link to full size 100% image |\n\nThe expected difference for these two images is 1.62125%"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUsing GD::Raw from the Raku ecosystem.\n\n```\nuse GD::Raw;\n\nmy $fh1 = fopen('./Lenna50.jpg', \"rb\") or die;\nmy $img1 = gdImageCreateFromJpeg($fh1);\nmy $fh2 = fopen('./Lenna100.jpg', \"rb\") or die;\nmy $img2 = gdImageCreateFromJpeg($fh2);\n\nmy $img1X = gdImageSX($img1);\nmy $img1Y = gdImageSY($img1);\nmy $img2X = gdImageSX($img2);\nmy $img2Y = gdImageSY($img2);\n\n($img1X == $img2X and $img1Y == $img2Y) or die \"Image dimensions must match.\";\n\nmy $diff = 0;\nmy ($px1, $px2);\nloop (my $i = 0; $i < $img1X; $i++) {\n   loop (my $j = 0; $j < $img1Y; $j++) {\n\n      $px1 = gdImageGetPixel($img1, $i, $j);\n      $px2 = gdImageGetPixel($img2, $i, $j);\n\n      $diff += abs(gdImageRed($img1, $px1) - gdImageRed($img2, $px2));\n      $diff += abs(gdImageGreen($img1, $px1) - gdImageGreen($img2, $px2));\n      $diff += abs(gdImageBlue($img1, $px1) - gdImageBlue($img2, $px2));\n   }\n}\n\nsay \"%difference = \", $diff/($img1X*$img1Y*3*255)*100;\n\ngdImageDestroy($img1);\ngdImageDestroy($img2);\n\n```\n\nOutput:\n\n```\n%difference = 1.625593098\n\n```"}]}
{"messages": [{"role": "user", "content": "A perceptron is an algorithm used in machine-learning. It's the simplest of all neural networks, consisting of only one neuron, and is typically used for pattern recognition.\n\nA perceptron attempts to separate input into a positive and a negative class with the aid of a linear function. The inputs are each multiplied by weights, random weights at first, and then summed. Based on the sign of the sum a decision is made.\n\nIn order for the perceptron to make the right decision, it needs to train with input for which the *correct outcome is known*, so that the weights can slowly be adjusted until they start producing the desired results.\n\nTask\n\nThe website The Nature of Code demonstrates a perceptron by making it perform a very simple task : determine if a randomly chosen point (x, y) is above or below a line:\n\n```\n y = mx + b\n\n```\n\nImplement this perceptron and display an image (or some other visualization) of the result.\n\nSee also\n\n* Neural networks (nature of code)\n* Machine Learning - Perceptrons (youtube)"}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20201116 Raku programming solution\n\nuse MagickWand;\n\nour ( \\c, \\runs ) = 0.00001, 2000 ;\n\nclass Trainer { has ( @.inputs, $.answer ) is rw }\n\nsub linear(\\x) { return x*0.7 + 40 }\n\nclass Perceptron { \n   \n   has ( @.weights, Trainer @.training ) is rw ;\n\n   submethod BUILD(:n($n), :w($w), :h($h)) {\n      @!weights  = [ rand*2-1 xx ^$n ];\n      @!training = (^runs).map: {\n          my (\\x,\\y) = rand*$w , rand*$h ;\n          my \\a      = y < linear(x) ?? 1 !! -1;\n          Trainer.new: inputs => (x,y,1), answer => a \n      }\n   }\n\n   method feedForward(@inputs) { \n      die \"weights and input length mismatch\" if +@inputs != +self.weights;\n      return ( sum( @inputs »*« self.weights ) > 0 ) ?? 1 !! -1\n   }\n\n   method train(@inputs, \\desired) {\n      self.weights »+«= @inputs »*» (c*(desired - self.feedForward(@inputs)))\n   }\n\n   method draw(\\img) {\n      for ^runs { self.train(self.training[$_].inputs, self.training[$_].answer) }\n      my $y = linear(my $x = img.width) ;\n      img».&{ .stroke-width(3) or .stroke('black') or .fill('none') } # C returns \n      img.draw-line(0.0, linear(0), $x, $y);\n      img.stroke-width( 1 );\n      for ^runs {\n         my $guess = self.feedForward(self.training[$_].inputs);\n         ($x, $y) = self.training[$_].inputs[0,1] »-» 4;  \n         $guess > 0 ?? img.stroke( 'blue' ) !! img.stroke( 'red' ); \n         img.circle( $x, $y, $x+8, $y );\n      }\n   }\n}\n\nmy ($w, $h) = 640, 360;\nmy $perc = Perceptron.new: n => 3, w => $w, h => $h;\nmy $o = MagickWand.new or die; \n$o.create( $w, $h, \"white\" );\n$perc.draw($o);\n$o.write('./perceptron.png') or die\n\n```"}]}
{"messages": [{"role": "user", "content": "Given an \n\nM\n×\nN\n{\\displaystyle {\\displaystyle M\\times N}}\n rectangular array of cells numbered \n\nc\ne\nl\nl\n[\n0..\nM\n−\n1\n,\n0..\nN\n−\n1\n]\n{\\displaystyle {\\displaystyle \\mathrm {cell} [0..M-1,0..N-1]}}\n, assume \n\nM\n{\\displaystyle {\\displaystyle M}}\n is horizontal and \n\nN\n{\\displaystyle {\\displaystyle N}}\n is downwards. Each \n\nc\ne\nl\nl\n[\nm\n,\nn\n]\n{\\displaystyle {\\displaystyle \\mathrm {cell} [m,n]}}\n is bounded by (horizontal) walls \n\nh\nw\na\nl\nl\n[\nm\n,\nn\n]\n{\\displaystyle {\\displaystyle \\mathrm {hwall} [m,n]}}\n and \n\nh\nw\na\nl\nl\n[\nm\n+\n1\n,\nn\n]\n{\\displaystyle {\\displaystyle \\mathrm {hwall} [m+1,n]}}\n; (vertical) walls \n\nv\nw\na\nl\nl\n[\nm\n,\nn\n]\n{\\displaystyle {\\displaystyle \\mathrm {vwall} [m,n]}}\n and \n\nv\nw\na\nl\nl\n[\nm\n,\nn\n+\n1\n]\n{\\displaystyle {\\displaystyle \\mathrm {vwall} [m,n+1]}}\n\nAssume that the probability of any wall being present is a constant \n\np\n{\\displaystyle {\\displaystyle p}}\n where\n\n:   0.0\n    ≤\n    p\n    ≤\n    1.0\n    {\\displaystyle {\\displaystyle 0.0\\leq p\\leq 1.0}}\n\nExcept for the outer horizontal walls at \n\nm\n=\n0\n{\\displaystyle {\\displaystyle m=0}}\n and \n\nm\n=\nM\n{\\displaystyle {\\displaystyle m=M}}\n which are always present.\n\nThe task\n\nSimulate pouring a fluid onto the top surface (\n\nn\n=\n0\n{\\displaystyle {\\displaystyle n=0}}\n) where the fluid will enter any empty cell it is adjacent to if there is no wall between where it currently is and the cell on the other side of the (missing) wall.\n\nThe fluid does not move beyond the horizontal constraints of the grid.\n\nThe fluid may move “up” within the confines of the grid of cells. If the fluid reaches a bottom cell that has a missing bottom wall then the fluid can be said to 'drip' out the bottom at that point.\n\nGiven \n\np\n{\\displaystyle {\\displaystyle p}}\n repeat the percolation \n\nt\n{\\displaystyle {\\displaystyle t}}\n times to estimate the proportion of times that the fluid can percolate to the bottom for any given \n\np\n{\\displaystyle {\\displaystyle p}}\n.\n\nShow how the probability of percolating through the random grid changes with \n\np\n{\\displaystyle {\\displaystyle p}}\n going from \n\n0.0\n{\\displaystyle {\\displaystyle 0.0}}\n to \n\n1.0\n{\\displaystyle {\\displaystyle 1.0}}\n in \n\n0.1\n{\\displaystyle {\\displaystyle 0.1}}\n increments and with the number of repetitions to estimate the fraction at any given \n\np\n{\\displaystyle {\\displaystyle p}}\n as \n\nt\n=\n100\n{\\displaystyle {\\displaystyle t=100}}\n.\n\nUse an \n\nM\n=\n10\n,\nN\n=\n10\n{\\displaystyle {\\displaystyle M=10,N=10}}\n grid of cells for all cases.\n\nOptionally depict fluid successfully percolating through a grid graphically.\n\nShow all output on this page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.02\n\nStarts \"filling\" from the top left. Fluid flow favours directions in Down, Left, Right, Up order. I interpreted p to be porosity, so small p mean low permeability, large p means high permeability.\n\n```\nmy @bond;\nmy $grid = 10;\nmy $geom = $grid - 1;\nmy $water = '▒';\n\nenum Direction <DeadEnd Up Right Down Left>;\n\nsay 'Sample percolation at .6';\npercolate .6;\n.join.say for @bond;\nsay \"\\n\";\n\nmy $tests = 100;\nsay \"Doing $tests trials at each porosity:\";\nfor .1, .2 ... 1 -> $p {\n    printf \"p = %0.1f: %0.2f\\n\", $p, (sum percolate($p) xx $tests) / $tests\n}\n\nsub percolate ( $prob ) {\n    generate $prob;\n    my @stack;\n    my $current = [1;0];\n    $current.&fill;\n\n    loop {\n        if my $dir = direction( $current ) {\n            @stack.push: $current;\n            $current = move $dir, $current\n        }\n        else {\n            return False unless @stack;\n            $current = @stack.pop\n        }\n        return True if $current[1] == +@bond - 1\n    }\n\n    sub direction( [$x, $y] ) {\n        ( Down  if @bond[$y + 1][$x].contains: ' ' ) ||\n        ( Left  if @bond[$y][$x - 1].contains: ' ' ) ||\n        ( Right if @bond[$y][$x + 1].contains: ' ' ) ||\n        ( Up    if @bond[$y - 1][$x].defined && @bond[$y - 1][$x].contains: ' ' ) ||\n        DeadEnd\n    }\n\n    sub move ( $dir, @cur ) {\n        my ( $x, $y ) = @cur;\n        given $dir {\n            when Up    { [$x,--$y].&fill xx 2 }\n            when Down  { [$x,++$y].&fill xx 2 }\n            when Left  { [--$x,$y].&fill xx 2 }\n            when Right { [++$x,$y].&fill xx 2 }\n        }\n        [$x, $y]\n    }\n\n    sub fill ( [$x, $y] ) { @bond[$y;$x].=subst(' ', $water, :g) }\n}\n\nsub generate ( $prob = .5 ) {\n    @bond = ();\n    my $sp = '   ';\n    append @bond, [flat '│', ($sp, ' ') xx $geom, $sp, '│'],\n                  [flat '├', (h(), '┬') xx $geom, h(), '┤'];\n    append @bond, [flat '│', ($sp, v()) xx $geom, $sp, '│'],\n                  [flat '├', (h(), '┼') xx $geom, h(), '┤'] for ^$geom;\n    append @bond, [flat '│', ($sp, v()) xx $geom, $sp, '│'],\n                  [flat '├', (h(), '┴') xx $geom, h(), '┤'],\n                  [flat '│', ($sp, ' ') xx $geom, $sp, '│'];\n\n    sub h () { rand < $prob ?? $sp !! '───' }\n    sub v () { rand < $prob ?? ' ' !! '│'   }\n}\n\n```\n\nOutput:\n\n```\nSample percolation at .6\n│▒▒▒                                    │\n├▒▒▒┬   ┬───┬   ┬   ┬   ┬   ┬   ┬───┬   ┤\n│▒▒▒▒▒▒▒                │   │           │\n├───┼▒▒▒┼   ┼   ┼   ┼   ┼   ┼───┼   ┼   ┤\n│▒▒▒▒▒▒▒▒▒▒▒│   │   │   │   │   │       │\n├▒▒▒┼───┼▒▒▒┼   ┼───┼   ┼───┼   ┼   ┼   ┤\n│▒▒▒│▒▒▒▒▒▒▒▒▒▒▒                │   │   │\n├▒▒▒┼───┼───┼▒▒▒┼   ┼   ┼───┼   ┼   ┼   ┤\n│▒▒▒│        ▒▒▒│   │   │           │   │\n├───┼   ┼   ┼▒▒▒┼───┼   ┼   ┼   ┼   ┼───┤\n│           │▒▒▒    │                   │\n├   ┼───┼   ┼▒▒▒┼───┼───┼───┼───┼   ┼───┤\n│           │▒▒▒│                       │\n├───┼   ┼───┼▒▒▒┼───┼───┼───┼───┼   ┼───┤\n│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒        │       │       │\n├▒▒▒┼▒▒▒┼───┼▒▒▒┼───┼   ┼───┼   ┼   ┼   ┤\n│▒▒▒│▒▒▒▒▒▒▒│▒▒▒▒▒▒▒│                   │\n├▒▒▒┼───┼───┼───┼───┼───┼   ┼   ┼   ┼   ┤\n│▒▒▒▒▒▒▒    │       │   │               │\n├▒▒▒┼▒▒▒┼───┼───┼   ┼───┼───┼   ┼   ┼   ┤\n│▒▒▒│▒▒▒    │               │           │\n├───┴▒▒▒┴   ┴   ┴   ┴───┴   ┴   ┴   ┴───┤\n│    ▒▒▒                                │\n\nDoing 100 trials at each porosity:\np = 0.1: 0.00\np = 0.2: 0.00\np = 0.3: 0.00\np = 0.4: 0.05\np = 0.5: 0.42\np = 0.6: 0.92\np = 0.7: 1.00\np = 0.8: 1.00\np = 0.9: 1.00\np = 1.0: 1.00\n```"}]}
{"messages": [{"role": "user", "content": "Let \n\nc\n{\\displaystyle {\\displaystyle c}}\n be a 2D boolean square matrix of \n\nn\n×\nn\n{\\displaystyle {\\displaystyle n\\times n}}\n values of either 1 or 0 where the\nprobability of any value being 1 is \n\np\n{\\displaystyle {\\displaystyle p}}\n, (and of 0 is therefore \n\n1\n−\np\n{\\displaystyle {\\displaystyle 1-p}}\n).\nWe define a *cluster* of 1's as being a group of 1's connected vertically or\nhorizontally (i.e., using the Von Neumann neighborhood rule) and bounded by either \n\n0\n{\\displaystyle {\\displaystyle 0}}\n or by the limits of the matrix.\nLet the number of such clusters in such a randomly constructed matrix be \n\nC\n\nn\n{\\displaystyle {\\displaystyle C\\_{n}}}\n.\n\nPercolation theory states that \n\nK\n(\np\n)\n{\\displaystyle {\\displaystyle K(p)}}\n (the mean cluster density) will satisfy \n\nK\n(\np\n)\n=\n\nC\n\nn\n\n/\n\nn\n\n2\n{\\displaystyle {\\displaystyle K(p)=C\\_{n}/n^{2}}}\n as \n\nn\n{\\displaystyle {\\displaystyle n}}\n tends to infinity. For \n\np\n=\n0.5\n{\\displaystyle {\\displaystyle p=0.5}}\n, \n\nK\n(\np\n)\n{\\displaystyle {\\displaystyle K(p)}}\n is found numerically to approximate \n\n0.065770\n{\\displaystyle {\\displaystyle 0.065770}}\n...\n\nTask\n\nShow the effect of varying \n\nn\n{\\displaystyle {\\displaystyle n}}\n on the accuracy of simulated \n\nK\n(\np\n)\n{\\displaystyle {\\displaystyle K(p)}}\n for \n\np\n=\n0.5\n{\\displaystyle {\\displaystyle p=0.5}}\n and\nfor values of \n\nn\n{\\displaystyle {\\displaystyle n}}\n up to at least \n\n1000\n{\\displaystyle {\\displaystyle 1000}}\n.\nAny calculation of \n\nC\n\nn\n{\\displaystyle {\\displaystyle C\\_{n}}}\n for finite \n\nn\n{\\displaystyle {\\displaystyle n}}\n is subject to randomness, so an approximation should be\ncomputed as the average of \n\nt\n{\\displaystyle {\\displaystyle t}}\n runs, where \n\nt\n{\\displaystyle {\\displaystyle t}}\n ≥ \n\n5\n{\\displaystyle {\\displaystyle 5}}\n.\n\nFor extra credit, graphically show clusters in a \n\n15\n×\n15\n{\\displaystyle {\\displaystyle 15\\times 15}}\n, \n\np\n=\n0.5\n{\\displaystyle {\\displaystyle p=0.5}}\n grid.\n\nShow your output here.\n\nSee also\n\n* s-Cluster on Wolfram mathworld."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.02\n\n```\nmy @perc;\nmy $fill = 'x';\n\nenum Direction <DeadEnd Up Right Down Left>;\n\nmy $𝘒 = perctest(15);\n.fmt(\"%-2s\").say for @perc;\nsay \"𝘱 = 0.5, 𝘕 = 15, 𝘒 = $𝘒\\n\";\n\nmy $trials = 5;\nfor 10, 30, 100, 300, 1000 -> $𝘕 {\n    my $𝘒 = ( [+] perctest($𝘕) xx $trials ) / $trials;\n    say \"𝘱 = 0.5, trials = $trials, 𝘕 = $𝘕, 𝘒 = $𝘒\";\n}\n\nsub infix:<deq> ( $a, $b ) { $a.defined && ($a eq $b) }\n\nsub perctest ( $grid ) {\n    generate $grid;\n    my $block = 1;\n    for ^$grid X ^$grid -> ($y, $x) {\n        fill( [$x, $y], $block++ ) if @perc[$y; $x] eq $fill\n    }\n    ($block - 1) / $grid²;\n}\n\nsub generate ( $grid ) {\n    @perc = ();\n    @perc.push: [ ( rand < .5 ?? '.' !! $fill ) xx $grid ] for ^$grid;\n}\n\nsub fill ( @cur, $block ) {\n    @perc[@cur[1]; @cur[0]] = $block;\n    my @stack;\n    my $current = @cur;\n\n    loop {\n        if my $dir = direction( $current ) {\n            @stack.push: $current;\n            $current = move $dir, $current, $block\n        }\n        else {\n            return unless @stack;\n            $current = @stack.pop\n        }\n    }\n\n    sub direction( [$x, $y] ) {\n        ( Down  if @perc[$y + 1][$x] deq $fill ) ||\n        ( Left  if @perc[$y][$x - 1] deq $fill ) ||\n        ( Right if @perc[$y][$x + 1] deq $fill ) ||\n        ( Up    if @perc[$y - 1][$x] deq $fill ) ||\n        DeadEnd\n    }\n\n    sub move ( $dir, @cur, $block ) {\n        my ( $x, $y ) = @cur;\n        given $dir {\n            when Up    { @perc[--$y; $x] = $block }\n            when Down  { @perc[++$y; $x] = $block }\n            when Left  { @perc[$y; --$x] = $block }\n            when Right { @perc[$y; ++$x] = $block }\n        }\n        [$x, $y]\n    }\n}\n\n```\n\nOutput:\n\n```\n.  .  1  .  2  .  .  3  .  .  .  4  .  .  . \n2  2  .  .  2  2  2  .  5  5  .  4  4  4  4 \n2  2  2  2  2  .  2  .  5  .  .  4  .  .  4 \n2  .  2  .  2  2  .  .  .  .  4  4  4  .  4 \n.  .  .  .  .  2  .  .  .  .  4  4  4  .  . \n6  6  6  6  .  .  7  7  .  .  4  .  4  4  . \n6  .  6  .  .  .  .  .  4  4  4  4  4  .  . \n6  6  6  .  .  .  8  8  .  4  4  4  .  .  4 \n6  .  .  .  9  .  .  .  .  .  .  4  4  .  4 \n.  10 .  11 .  .  12 12 .  4  .  .  4  4  4 \n11 .  11 11 11 11 .  12 .  4  .  4  4  4  . \n11 11 11 11 11 11 11 .  .  4  4  .  .  4  . \n11 11 11 11 .  11 .  .  .  4  4  4  4  4  . \n11 11 11 .  11 11 11 .  .  4  4  4  4  .  13\n.  11 11 .  11 11 .  .  .  .  4  4  .  14 . \n𝘱 = 0.5, 𝘕 = 15, 𝘒 = 0.062222\n\n𝘱 = 0.5, trials = 5, 𝘕 = 10, 𝘒 = 0.114\n𝘱 = 0.5, trials = 5, 𝘕 = 30, 𝘒 = 0.082444\n𝘱 = 0.5, trials = 5, 𝘕 = 100, 𝘒 = 0.06862\n𝘱 = 0.5, trials = 5, 𝘕 = 300, 𝘒 = 0.066889\n𝘱 = 0.5, trials = 5, 𝘕 = 1000, 𝘒 = 0.0659358\n\n```"}]}
{"messages": [{"role": "user", "content": "Let \n\nv\n{\\displaystyle {\\displaystyle v}}\n be a vector of \n\nn\n{\\displaystyle {\\displaystyle n}}\n values of either 1 or 0 where the probability of any\nvalue being 1 is \n\np\n{\\displaystyle {\\displaystyle p}}\n; the probability of a value being 0 is therefore \n\n1\n−\np\n{\\displaystyle {\\displaystyle 1-p}}\n.\nDefine a run of 1s as being a group of consecutive 1s in the vector bounded\neither by the limits of the vector or by a 0. Let the number of such runs in a given\nvector of length \n\nn\n{\\displaystyle {\\displaystyle n}}\n be \n\nR\n\nn\n{\\displaystyle {\\displaystyle R\\_{n}}}\n.\n\nFor example, the following vector has \n\nR\n\n10\n=\n3\n{\\displaystyle {\\displaystyle R\\_{10}=3}}\n\n```\n[1 1 0 0 0 1 0 1 1 1]\n ^^^       ^   ^^^^^\n\n```\n\nPercolation theory states that\n\n:   K\n    (\n    p\n    )\n    =\n\n    lim\n\n    n\n    →\n    ∞\n\n    R\n\n    n\n\n    /\n    n\n    =\n    p\n    (\n    1\n    −\n    p\n    )\n    {\\displaystyle {\\displaystyle K(p)=\\lim \\_{n\\to \\infty }R\\_{n}/n=p(1-p)}}\n\nTask\n\nAny calculation of \n\nR\n\nn\n\n/\nn\n{\\displaystyle {\\displaystyle R\\_{n}/n}}\n for finite \n\nn\n{\\displaystyle {\\displaystyle n}}\n is subject to randomness so should be\ncomputed as the average of \n\nt\n{\\displaystyle {\\displaystyle t}}\n runs, where \n\nt\n≥\n100\n{\\displaystyle {\\displaystyle t\\geq 100}}\n.\n\nFor values of \n\np\n{\\displaystyle {\\displaystyle p}}\n of 0.1, 0.3, 0.5, 0.7, and 0.9, show the effect of varying \n\nn\n{\\displaystyle {\\displaystyle n}}\non the accuracy of simulated \n\nK\n(\np\n)\n{\\displaystyle {\\displaystyle K(p)}}\n.\n\nShow your output here.\n\nSee also\n\n* s-Run on Wolfram mathworld."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub R($n, $p) { [+] ((rand < $p) xx $n).squish }\n\nsay 't= ', constant t = 100;\n\nfor .1, .3 ... .9 -> $p {\n    say \"p= $p, K(p)= {$p*(1-$p)}\";\n    for 10, 100, 1000 -> $n {\n\tprintf \"  R(%6d, p)= %f\\n\", $n, t R/ [+] R($n, $p)/$n xx t\n    }\n}\n\n```\n\nOutput:\n\n```\nt= 100\np= 0.1, K(p)= 0.09\n  R(    10, p)= 0.088000\n  R(   100, p)= 0.085600\n  R(  1000, p)= 0.089150\np= 0.3, K(p)= 0.21\n  R(    10, p)= 0.211000\n  R(   100, p)= 0.214600\n  R(  1000, p)= 0.211160\np= 0.5, K(p)= 0.25\n  R(    10, p)= 0.279000\n  R(   100, p)= 0.249200\n  R(  1000, p)= 0.250870\np= 0.7, K(p)= 0.21\n  R(    10, p)= 0.258000\n  R(   100, p)= 0.215400\n  R(  1000, p)= 0.209560\np= 0.9, K(p)= 0.09\n  R(    10, p)= 0.181000\n  R(   100, p)= 0.094500\n  R(  1000, p)= 0.091330\n```"}]}
{"messages": [{"role": "user", "content": "Given an \n\nM\n×\nN\n{\\displaystyle {\\displaystyle M\\times N}}\n rectangular array of cells numbered \n\nc\ne\nl\nl\n[\n0..\nM\n−\n1\n,\n0..\nN\n−\n1\n]\n{\\displaystyle {\\displaystyle \\mathrm {cell} [0..M-1,0..N-1]}}\nassume \n\nM\n{\\displaystyle {\\displaystyle M}}\n is horizontal and \n\nN\n{\\displaystyle {\\displaystyle N}}\n is downwards.\n\nAssume that the probability of any cell being filled is a constant \n\np\n{\\displaystyle {\\displaystyle p}}\n where\n\n:   0.0\n    ≤\n    p\n    ≤\n    1.0\n    {\\displaystyle {\\displaystyle 0.0\\leq p\\leq 1.0}}\n\nThe task\n\nSimulate creating the array of cells with probability \n\np\n{\\displaystyle {\\displaystyle p}}\n and then\ntesting if there is a route through adjacent filled cells from any on row \n\n0\n{\\displaystyle {\\displaystyle 0}}\n to any on row \n\nN\n{\\displaystyle {\\displaystyle N}}\n, i.e. testing for site percolation.\n\nGiven \n\np\n{\\displaystyle {\\displaystyle p}}\n repeat the percolation \n\nt\n{\\displaystyle {\\displaystyle t}}\n times to estimate the proportion of times that the fluid can percolate to the bottom for any given \n\np\n{\\displaystyle {\\displaystyle p}}\n.\n\nShow how the probability of percolating through the random grid changes with \n\np\n{\\displaystyle {\\displaystyle p}}\n going from \n\n0.0\n{\\displaystyle {\\displaystyle 0.0}}\n to \n\n1.0\n{\\displaystyle {\\displaystyle 1.0}}\n in \n\n0.1\n{\\displaystyle {\\displaystyle 0.1}}\n increments and with the number of repetitions to estimate the fraction at any given \n\np\n{\\displaystyle {\\displaystyle p}}\n as \n\nt\n>=\n100\n{\\displaystyle {\\displaystyle t>=100}}\n.\n\nUse an \n\nM\n=\n15\n,\nN\n=\n15\n{\\displaystyle {\\displaystyle M=15,N=15}}\n grid of cells for all cases.\n\nOptionally depict a percolation through a cell grid graphically.\n\nShow all output on this page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.02\n\n```\nmy $block = '▒';\nmy $water = '+';\nmy $pore  = ' ';\nmy $grid  = 15;\nmy @site;\n\nenum Direction <DeadEnd Up Right Down Left>;\n\nsay 'Sample percolation at .6';\npercolate(.6);\n.join.say for @site;\nsay \"\\n\";\n\nmy $tests = 1000;\nsay \"Doing $tests trials at each porosity:\";\nfor .1, .2 ... 1 -> $p {\n    printf \"p = %0.1f: %0.3f\\n\", $p, (sum percolate($p) xx $tests) / $tests\n}\n\nsub infix:<deq> ( $a, $b ) { $a.defined && ($a eq $b) }\n\nsub percolate ( $prob  = .6 ) {\n    @site[0] = [$pore xx $grid];\n    @site[$grid + 1] = [$pore xx $grid];\n\n    for ^$grid X 1..$grid -> ($x, $y) {\n        @site[$y;$x] = rand < $prob ?? $pore !! $block\n    }\n    @site[0;0] = $water;\n\n    my @stack;\n    my $current = [0;0];\n\n    loop {\n        if my $dir = direction( $current ) {\n            @stack.push: $current;\n            $current = move( $dir, $current )\n        }\n        else {\n            return False unless @stack;\n            $current = @stack.pop\n        }\n        return True if $current[1] > $grid\n    }\n\n    sub direction( [$x, $y] ) {\n        (Down  if @site[$y + 1][$x] deq $pore) ||\n        (Left  if @site[$y][$x - 1] deq $pore) ||\n        (Right if @site[$y][$x + 1] deq $pore) ||\n        (Up    if @site[$y - 1][$x] deq $pore) ||\n        DeadEnd\n    }\n\n    sub move ( $dir, @cur ) {\n        my ( $x, $y ) = @cur;\n        given $dir {\n            when Up    { @site[--$y][$x] = $water }\n            when Down  { @site[++$y][$x] = $water }\n            when Left  { @site[$y][--$x] = $water }\n            when Right { @site[$y][++$x] = $water }\n        }\n        [$x, $y]\n    }\n}\n\n```\n\nOutput:\n\n```\nSample percolation at .6\n++++           \n▒▒▒+ ▒ ▒ ▒ ▒ ▒▒\n ▒▒++ ▒▒   ▒▒  \n   ▒+   ▒▒ ▒ ▒▒\n▒▒ ▒++++▒ ▒▒   \n ▒ ▒+▒▒+▒   ▒  \n  ▒++▒++ ▒▒▒ ▒ \n  ▒▒▒ +▒       \n▒▒ ▒ ▒++ ▒   ▒▒\n▒▒▒▒▒▒▒+▒▒▒    \n▒   ▒  +   ▒   \n ▒▒   ▒+ ▒  ▒ ▒\n▒  ▒ ▒▒+    ▒  \n▒▒ ▒ ▒++▒   ▒  \n   ▒  +▒ ▒▒  ▒▒\n▒  ▒▒▒+    ▒▒ ▒\n      +        \n\n\nDoing 1000 trials at each porosity:\np = 0.1: 0.000\np = 0.2: 0.000\np = 0.3: 0.000\np = 0.4: 0.005\np = 0.5: 0.096\np = 0.6: 0.573\np = 0.7: 0.959\np = 0.8: 0.999\np = 0.9: 1.000\np = 1.0: 1.000\n\n```"}]}
{"messages": [{"role": "user", "content": "Write a function which says whether a number is perfect.\n\nA perfect number is a positive integer that is the sum of its proper positive divisors excluding the number itself.\n\nEquivalently, a perfect number is a number that is half the sum of all of its positive divisors (including itself).\n\nNote:   The faster   Lucas-Lehmer test   is used to find primes of the form    2*n*-1,   all *known* perfect numbers can be derived from these primes\nusing the formula    (2*n* - 1) × 2*n* - 1.\n\nIt is not known if there are any odd perfect numbers (any that exist are larger than 102000).\n\nThe number of   *known*   perfect numbers is   **51**   (as of December, 2018),   and the largest known perfect number contains  **49,724,095**  decimal digits.\n\nSee also\n:   * Rational Arithmetic\n    * Perfect numbers on OEIS\n    * Odd Perfect showing the current status of bounds on odd perfect numbers."}, {"role": "assistant", "content": "(formerly Perl 6)\nNaive (very slow) version\n\n```\nsub is-perf($n) { $n == [+] grep $n %% *, 1 .. $n div 2 }\n\n# used as\nput ((1..Inf).hyper.grep: {.&is-perf})[^4];\n```\n\nOutput:\n\n```\n6 28 496 8128\n```\n\nMuch, much faster version:\n\n```\nmy @primes   = lazy (2,3,*+2 … Inf).grep: { .is-prime };\nmy @perfects = lazy gather for @primes {\n    my $n = 2**$_ - 1;\n    take $n * 2**($_ - 1) if $n.is-prime;\n}\n\n.put for @perfects[^12];\n```\n\nOutput:\n\n```\n6\n28\n496\n8128\n33550336\n8589869056\n137438691328\n2305843008139952128\n2658455991569831744654692615953842176\n191561942608236107294793378084303638130997321548169216\n13164036458569648337239753460458722910223472318386943117783728128\n14474011154664524427946373126085988481573677491474835889066354349131199152128\n```"}]}
{"messages": [{"role": "user", "content": "A perfect shuffle (or faro/weave shuffle) means splitting a deck of cards into equal halves, and perfectly interleaving them - so that you end up with the first card from the left half, followed by the first card from the right half, and so on:\n\n:   :   :   7♠ 8♠ 9♠ J♠ Q♠ K♠\n\n            →\n\n            7♠  8♠  9♠  \n              J♠  Q♠  K♠\n\n            →\n\n            7♠ J♠ 8♠ Q♠ 9♠ K♠\n\nWhen you repeatedly perform perfect shuffles on an even-sized deck of unique cards, it will at some point arrive back at its original order. How many shuffles this takes, depends solely on the number of cards in the deck - for example for a deck of eight cards it takes three shuffles:\n\n:   :   :   :   :   |  |  |\n                    | --- | --- |\n                    | *original:* | 1 2 3 4 5 6 7 8 |\n                    | *after 1st shuffle:* | 1 5 2 6 3 7 4 8 |\n                    | *after 2nd shuffle:* | 1 3 5 7 2 4 6 8 |\n                    | *after 3rd shuffle:* | 1 2 3 4 5 6 7 8 |\n\n***The Task***\n\n1. Write a function that can perform a perfect shuffle on an even-sized list of values.\n2. Call this function repeatedly to count how many shuffles are needed to get a deck back to its original order, for each of the deck sizes listed under \"Test Cases\" below.\n   * You can use a list of numbers (or anything else that's convenient) to represent a deck; just make sure that all \"cards\" are unique within each deck.\n   * Print out the resulting shuffle counts, to demonstrate that your program passes the test-cases.\n\n***Test Cases***\n\n:   :   :   :   :   | input *(deck size)* | output *(number of shuffles required)* |\n                    | --- | --- |\n                    | 8 | 3 |\n                    | 24 | 11 |\n                    | 52 | 8 |\n                    | 100 | 30 |\n                    | 1020 | 1018 |\n                    | 1024 | 10 |\n                    | 10000 | 300 |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nfor 8, 24, 52, 100, 1020, 1024, 10000 -> $size {\n    my ($n, @deck) = 1, |^$size;\n    $n++ until [<] @deck = flat [Z] @deck.rotor: @deck/2;\n    printf \"%5d cards: %4d\\n\", $size, $n;\n}\n\n```\n\nOutput:\n\n```\n    8 cards:    3\n   24 cards:   11\n   52 cards:    8\n  100 cards:   30\n 1020 cards: 1018\n 1024 cards:   10\n10000 cards:  300\n\n```"}]}
{"messages": [{"role": "user", "content": "Generate and show here, the first twenty Perfect totient numbers.\n\nRelated task\n:   :   * Totient function\n\nAlso see\n:   :   * the OEIS entry for   perfect totient numbers.\n        * mrob   list of the first 54"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.11\n\n```\nuse Prime::Factor;\n\nmy \\𝜑 = lazy 0, |(1..*).hyper.map: -> \\t { t * [*] t.&prime-factors.squish.map: 1 - 1/* }\nmy \\𝜑𝜑 = Nil, |(3, *+2 … *).grep: -> \\p { p == sum 𝜑[p], { 𝜑[$_] } … 1 };\n\nput \"The first twenty Perfect totient numbers:\\n\",  𝜑𝜑[1..20];\n\n```\n\nOutput:\n\n```\nThe first twenty Perfect totient numbers:\n3 9 15 27 39 81 111 183 243 255 327 363 471 729 2187 2199 3063 4359 4375 5571\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay the row and column in the periodic table of the given atomic number.\n\nThe periodic table\n\nLet us consider the following periodic table representation.\n\n```\n     __________________________________________________________________________ \n    |   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18 |\n    |                                                                          |\n    |1  H                                                                   He |\n    |                                                                          |\n    |2  Li  Be                                          B   C   N   O   F   Ne |\n    |                                                                          |\n    |3  Na  Mg                                          Al  Si  P   S   Cl  Ar |\n    |                                                                          |\n    |4  K   Ca  Sc  Ti  V   Cr  Mn  Fe  Co  Ni  Cu  Zn  Ga  Ge  As  Se  Br  Kr |\n    |                                                                          |\n    |5  Rb  Sr  Y   Zr  Nb  Mo  Tc  Ru  Rh  Pd  Ag  Cd  In  Sn  Sb  Te  I   Xe |\n    |                                                                          |\n    |6  Cs  Ba  *   Hf  Ta  W   Re  Os  Ir  Pt  Au  Hg  Tl  Pb  Bi  Po  At  Rn |\n    |                                                                          |\n    |7  Fr  Ra  °   Rf  Db  Sg  Bh  Hs  Mt  Ds  Rg  Cn  Nh  Fl  Mc  Lv  Ts  Og |\n    |__________________________________________________________________________|\n    |                                                                          |\n    |                                                                          |\n    |8  Lantanoidi* La  Ce  Pr  Nd  Pm  Sm  Eu  Gd  Tb  Dy  Ho  Er  Tm  Yb  Lu |\n    |                                                                          |\n    |9   Aktinoidi° Ak  Th  Pa  U   Np  Pu  Am  Cm  Bk  Cf  Es  Fm  Md  No  Lr |\n    |__________________________________________________________________________|\n\n```\n\nExample test cases;\n\n* `1` -> `1 1`\n* `2` -> `1 18`\n* `29` -> `4 11`\n* `42` -> `5 6`\n* `57` -> `8 4`\n* `58` -> `8 5`\n* `72` -> `6 4`\n* `89` -> `9 4`\n\nDetails;\n\nThe representation of the periodic table may be represented in various way. The one presented in this challenge does have the following property : Lantanides and Aktinoides are all in a dedicated row, hence there is no element that is placed at 6, 3 nor 7, 3.\n\nYou may take a look at the atomic number repartitions here.\n\nThe atomic number is at least 1, at most 118.\n\nSee also\n\n* the periodic table\n* This task was an idea from CompSciFact\n* The periodic table in ascii that was used as template"}, {"role": "assistant", "content": "```\nmy $b = 18;\nmy @offset = 16, 10, 10, (2×$b)+1, (-2×$b)-15, (2×$b)+1, (-2×$b)-15;\nmy @span   = flat ^8 Zxx <1 3 8 44 15 17 15 15>;\n\nfor <1 2 29 42 57 58 72 89 90 103> -> $n {\n    printf \"%3d: %2d, %2d\\n\", $n, map {$_+1}, ($n-1 + [+] @offset.head(@span[$n-1])).polymod($b).reverse;\n}\n\n```\n\nOutput:\n\n```\n  1:  1,  1\n  2:  1, 18\n 29:  4, 11\n 42:  5,  6\n 57:  8,  4\n 58:  8,  5\n 72:  6,  4\n 89:  9,  4\n 90:  9,  5\n103:  9, 18\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGenerate and display a Peripheral Drift Illusion\n\nThe image appears to be moving even though it is perfectly static.\n\nProvide a link to show the output, either by running the code online or a screenshot uploaded to a suitable image host.\n\nReferences\n\n* Codepen demo."}, {"role": "assistant", "content": "```\nuse SVG;\n\nmy @blocks = (1..15 X 1..10).map: -> ($X, $Y) {\n    my $x = $X * 75;\n    my $y = $Y * 75;\n    my $a = (my $r = ($X + $Y) div 2 % 4 * 90) > 0 ?? \"rotate($r,$x,$y) \" !! '';\n    :use['xlink:href'=>'#block', 'transform'=>\"{$a}translate($x,$y)\"]\n}\n\n'peripheral-drift-raku.svg'.IO.spurt: SVG.serialize(\n    svg => [\n        :1200width, :825height,\n        :rect[:width<100%>, :height<100%>, :fill<#d3d004>],\n        :defs[\n            :g[\n                :id<block>,\n                :polygon[:points<-25,-25,-25,25,25,25>, :fill<white>],\n                :polygon[:points<25,25,25,-25,-25,-25>, :fill<black>],\n                :rect[:x<-20>, :y<-20>, :width<40>, :height<40>, :fill<#3250ff>]\n            ]\n        ],\n        |@blocks,\n    ]\n)\n\n```\n\nSee offsite SVG image"}]}
{"messages": [{"role": "user", "content": "The **Perlin noise** is a kind of gradient noise invented by Ken Perlin around the end of the twentieth century and still currently heavily used in computer graphics, most notably to procedurally generate textures or heightmaps.\n\nThe Perlin noise is basically a pseudo-random mapping of \n\nR\n\nd\n{\\displaystyle {\\displaystyle \\mathbb {R} ^{d}}}\n into \n\nR\n{\\displaystyle {\\displaystyle \\mathbb {R} }}\n with an integer \n\nd\n{\\displaystyle {\\displaystyle d}}\n which can be arbitrarily large but which is usually 2, 3, or 4.\n\nEither by using a dedicated library or by implementing the algorithm, show that the Perlin noise (as defined in 2002 in the Java implementation below) of the point in 3D-space with coordinates 3.14, 42, 7 is 0.13691995878400012.\n\n*Note: this result assumes 64 bit IEEE-754 floating point calculations. If your language uses a different floating point representation, make a note of it and calculate the value accurate to 15 decimal places, or your languages accuracy threshold if it is less. Trailing zeros need not be displayed.*"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Java\n\n```\nconstant @p = flat { @_.sort.antipairs.Hash{@_} }(<\n  😅😎📸👑👐✌ 💻✊😻💀💁🍃😲🤦☺🤙🔵🌕💎🌎🎶🖕⚠💆🌖🤭❣⚽➡😮☹😂\n  🥰💣🤧🐷▶🌈😵🎁👼🦋🤐🙂💟🌔✅🌑🍒😟🌒👎🤪😃🍑👍😜❓💩📣😙😖🎵😝\n  🐶😓🏃📌🔴🌺🌊😔🐾😀😌🤣👉💙🤠💦🍻🙋💿🤢🤑💓👶🌞🍎🌸🥀🌚🤷💍🖤🍊\n  🎉⭐🎂😏☀🚩👆🐉🙈🐸💾😫🙇👏❄😗😹😴📍💸💞😬😍👌😒💋💗😶😛😪☎🎈\n  🍀🚶🤝🥵💨💧☝ 🙁🌗😁💡💪🪐👈👋🙌🙆🙅🍺🤞🌹✔🍓✨😤😭🌌🌟🤗😥😘🙏\n  💢🥳😆☄🌴😈😑🎼🤓😇💌😉😕🌱😚⚡💰❤🌘🧐❌💅💖💘👅💛🤘🤤😠😩💚💐\n  🛰 🥂💃🤟🥺🌓🤯😱🤫🙊🖥 ✈😯😡😐🤮👇🌿🗣 🤨🥴✋🤬💕🌻😰🚀🌏😣😷💔😋\n  😨👊🙃😞💝💥🌼🌷💫☕😄🧡🔥🤩🙄👻🤔💜🎤🌍⬇🏆🤲🕺💯😳👀🎊🚨🎀😊😢\n>.join.comb) xx 2;\n\nsub fade($_) { $_ * $_ * $_ * ($_ * ($_ * 6 - 15) + 10) }\nsub lerp($t, $a, $b) { $a + $t * ($b - $a) }\nsub grad($h is copy, $x, $y, $z) {\n    $h +&= 15;\n    my $u = $h < 8 ?? $x !! $y;\n    my $v = $h < 4 ?? $y !! $h == 12|14 ?? $x !! $z;\n    ($h +& 1 ?? -$u !! $u) + ($h +& 2 ?? -$v !! $v);\n}\n\nsub noise($x is copy, $y is copy, $z is copy) {\n    my ($u, $v, $w) = map &fade, ($x, $y, $z) »-=«\n    my ($X, $Y, $Z) = ($x, $y, $z)».floor »+&» 255;\n    my ($AA, $AB) = @p[$_] + $Z, @p[$_ + 1] + $Z given @p[$X] + $Y;\n    my ($BA, $BB) = @p[$_] + $Z, @p[$_ + 1] + $Z given @p[$X + 1] + $Y;\n    lerp($w, lerp($v, lerp($u, grad(@p[$AA    ], $x    , $y    , $z     ),\n                               grad(@p[$BA    ], $x - 1, $y    , $z     )),\n                      lerp($u, grad(@p[$AB    ], $x    , $y - 1, $z     ),\n                               grad(@p[$BB    ], $x - 1, $y - 1, $z     ))),\n             lerp($v, lerp($u, grad(@p[$AA + 1], $x    , $y    , $z - 1 ),\n                               grad(@p[$BA + 1], $x - 1, $y    , $z - 1 )),\n                      lerp($u, grad(@p[$AB + 1], $x    , $y - 1, $z - 1 ),\n                               grad(@p[$BB + 1], $x - 1, $y - 1, $z - 1 ))));\n}\n\nsay noise 3.14, 42, 7;\n\n```\n\nOutput:\n\n```\n0.13691995878\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nA new medical treatment was tested on a population of \n\nn\n+\nm\n{\\displaystyle {\\displaystyle n+m}}\nvolunteers, with each volunteer randomly assigned either to a group of\n\nn\n{\\displaystyle {\\displaystyle n}}\n treatment subjects, or to a group of \n\nm\n{\\displaystyle {\\displaystyle m}}\n control subjects.\n\nMembers of the treatment group were given the treatment,\nand members of the control group were given a placebo.\nThe effect of the treatment or placebo on each volunteer\nwas measured and reported in this table.\n\n:   :   :   :   :   :   :   Table of experimental results\n\n                            | Treatment group | Control group |\n                            | --- | --- |\n                            | 85 | 68 |\n                            | 88 | 41 |\n                            | 75 | 10 |\n                            | 66 | 49 |\n                            | 25 | 16 |\n                            | 29 | 65 |\n                            | 83 | 32 |\n                            | 39 | 92 |\n                            | 97 | 28 |\n                            |  | 98 |\n\nWrite a program that performs a\npermutation test to judge\nwhether the treatment had a significantly stronger effect than the\nplacebo.\n\n* Do this by considering every possible alternative assignment from the same pool of volunteers to a treatment group of size \n\n  n\n  {\\displaystyle {\\displaystyle n}}\n   and a control group of size \n\n  m\n  {\\displaystyle {\\displaystyle m}}\n   (i.e., the same group sizes used in the actual experiment but with the group members chosen differently), while assuming that each volunteer's effect remains constant regardless.\n* Note that the number of alternatives will be the binomial coefficient \n\n  (\n\n\n  n\n  +\n  m\n  n\n\n  )\n  {\\displaystyle {\\displaystyle {\\tbinom {n+m}{n}}}}\n  .\n* Compute the mean effect for each group and the difference in means between the groups in every case by subtracting the mean of the control group from the mean of the treatment group.\n* Report the percentage of alternative groupings for which the difference in means is less or equal to the actual experimentally observed difference in means, and the percentage for which it is greater.\n* Note that they should sum to 100%.\n\nExtremely dissimilar values are evidence of an effect not entirely due\nto chance, but your program need not draw any conclusions.\n\nYou may assume the experimental data are known at compile time if\nthat's easier than loading them at run time. Test your solution on the\ndata given above."}, {"role": "assistant", "content": "(formerly Perl 6)\nThe use of `.race` to allow concurrent calculations means that multiple 'workers' will be updating `@trials` simultaneously. To avoid race conditions, the `⚛++` operator is used, which guarantees safe updates without the use of locks. That is turn requires declaring that array as being composed of `atomicint`.\n\n**Works with**: Rakudo version 2018.09\n\n```\nsub stats ( @test, @all ) {\n    ([+] @test / +@test) - ([+] flat @all, (@test X* -1)) / @all - @test\n}\n\nmy int @treated = <85 88 75 66 25 29 83 39 97>;\nmy int @control = <68 41 10 49 16 65 32 92 28 98>;\nmy int @all = flat @treated, @control;\n\nmy $base = stats( @treated, @all );\n\nmy atomicint @trials[3] = 0, 0, 0;\n\n@all.combinations(+@treated).race.map: { @trials[ 1 + ( stats( $_, @all ) <=> $base ) ]⚛++ }\n\nsay 'Counts: <, =, > ', @trials;\nsay 'Less than    : %', 100 * @trials[0] / [+] @trials;\nsay 'Equal to     : %', 100 * @trials[1] / [+] @trials;\nsay 'Greater than : %', 100 * @trials[2] / [+] @trials;\nsay 'Less or Equal: %', 100 * ( [+] @trials[0,1] ) / [+] @trials;\n\n```\n\nOutput:\n\n```\nCounts: <, =, > 80238 313 11827\nLess than    : %86.858343\nEqual to     : %0.338825\nGreater than : %12.802832\nLess or Equal: %87.197168\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program that generates all   permutations   of   **n**   different objects.   (Practically numerals!)\n\nRelated tasks\n\n* Find the missing permutation\n* Permutations/Derangements\n\n:   :   :   :   The number of samples of size k from n objects.\n                  \n                  \n                With   combinations and permutations   generation tasks.\n\n                |  | Order Unimportant | Order Important |\n                | --- | --- | --- |\n                | Without replacement | (  n k  )  =  n  C  k =    n ( n − 1 ) … ( n − k + 1 )  k ( k − 1 ) … 1 {\\displaystyle {\\displaystyle {\\binom {n}{k}}=^{n}\\operatorname {C} \\_{k}={\\frac {n(n-1)\\ldots (n-k+1)}{k(k-1)\\dots 1}}}} | n  P  k = n ⋅ ( n − 1 ) ⋅ ( n − 2 ) ⋯ ( n − k + 1 ) {\\displaystyle {\\displaystyle ^{n}\\operatorname {P} \\_{k}=n\\cdot (n-1)\\cdot (n-2)\\cdots (n-k+1)}} |\n                | Task: Combinations | Task: Permutations |\n                | With replacement | (   n + k − 1 k  )  =  n + k − 1  C  k =    ( n + k − 1 ) !  ( n − 1 ) ! k ! {\\displaystyle {\\displaystyle {\\binom {n+k-1}{k}}=^{n+k-1}\\operatorname {C} \\_{k}={(n+k-1)! \\over (n-1)!k!}}} | n  k {\\displaystyle {\\displaystyle n^{k}}} |\n                | Task: Combinations with repetitions | Task: Permutations with repetitions |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.10\n\nFirst, you can just use the built-in method on any list type.\n\n```\n.say for <a b c>.permutations\n```\n\nOutput:\n\n```\na b c\na c b\nb a c\nb c a\nc a b\nc b a\n```\n\nHere is some generic code that works with any ordered type. To force lexicographic ordering, change after to gt. To force numeric order, replace it with >.\n\n```\nsub next_perm ( @a is copy ) {\n    my $j = @a.end - 1;\n    return Nil if --$j < 0 while @a[$j] after @a[$j+1];\n\n    my $aj = @a[$j];\n    my $k  = @a.end;\n    $k-- while $aj after @a[$k];\n    @a[ $j, $k ] .= reverse;\n\n    my $r = @a.end;\n    my $s = $j + 1;\n    @a[ $r--, $s++ ] .= reverse while $r > $s;\n    return @a;\n}\n\n.say for [<a b c>], &next_perm ...^ !*;\n```\n\nOutput:\n\n```\na b c\na c b\nb a c\nb c a\nc a b\nc b a\n\n```\n\nHere is another non-recursive implementation, which returns a lazy list. It also works with any type.\n\n```\nsub permute(+@items) {\n   my @seq := 1..+@items;\n   gather for (^[*] @seq) -> $n is copy {\n      my @order;\n      for @seq {\n         unshift @order, $n mod $_;\n         $n div= $_;\n      }\n      my @i-copy = @items;\n      take map { |@i-copy.splice($_, 1) }, @order;\n   }\n}\n.say for permute( 'a'..'c' )\n```\n\nOutput:\n\n```\n(a b c)\n(a c b)\n(b a c)\n(b c a)\n(c a b)\n(c b a)\n```\n\nFinally, if you just want zero-based numbers, you can call the built-in function:\n\n```\n.say for permutations(3);\n```\n\nOutput:\n\n```\n0 1 2\n0 2 1\n1 0 2\n1 2 0\n2 0 1\n2 1 0\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGenerate permutations of n items in which successive permutations differ from each other by the swapping of any two items.\n\nAlso generate the sign of the permutation which is +1 when the permutation is generated from an even number of swaps from the initial state, and -1 for odd.\n\nShow the permutations and signs of three items, in order of generation *here*.\n\nSuch data are of use in generating the determinant of a square matrix and any functions created should bear this in mind.\n\nNote: The Steinhaus–Johnson–Trotter algorithm generates successive permutations where *adjacent* items are swapped, but from this discussion adjacency is not a requirement.\n\nReferences\n\n* Steinhaus–Johnson–Trotter algorithm\n* Johnson-Trotter Algorithm Listing All Permutations\n* Heap's algorithm\n* [1] Tintinnalogia\n\nRelated tasks\n\n* Matrix arithmetic\n* Gray code"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Recursive\n\n**Works with**: rakudo version 2015-09-25\n\n```\nsub insert($x, @xs) { ([flat @xs[0 ..^ $_], $x, @xs[$_ .. *]] for 0 .. +@xs) }\nsub order($sg, @xs) { $sg > 0 ?? @xs !! @xs.reverse }\n \nmulti perms([]) {\n    [] => +1\n}\n \nmulti perms([$x, *@xs]) {\n    perms(@xs).map({ |order($_.value, insert($x, $_.key)) }) Z=> |(+1,-1) xx *\n}\n \n.say for perms([0..2]);\n\n```\n\nOutput:\n\n```\n[0 1 2] => 1\n[1 0 2] => -1\n[1 2 0] => 1\n[2 1 0] => -1\n[2 0 1] => 1\n[0 2 1] => -1\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n**Generate** a sequence of permutations of n elements drawn from choice of k values.\n\nThis sequence will have   \n\nn\n\nk\n{\\displaystyle {\\displaystyle n^{k}}}\n   elements, unless the program decides to terminate early.\n\nDo not store all the intermediate values of the sequence, rather generate them as required, and pass the intermediate result to a deciding routine for combinations selection and/or early generator termination.\n\nFor example: When \"cracking\" a *\"combination\"* lock a sequence is required, but the sequence is terminated once a successful *\"combination\"* is found. This case is a good example of where it is not required to store all the intermediate **permutations**.\n\n**See Also:**\n\n:   :   :   :   The number of samples of size k from n objects.\n                  \n                  \n                With   combinations and permutations   generation tasks.\n\n                |  | Order Unimportant | Order Important |\n                | --- | --- | --- |\n                | Without replacement | (  n k  )  =  n  C  k =    n ( n − 1 ) … ( n − k + 1 )  k ( k − 1 ) … 1 {\\displaystyle {\\displaystyle {\\binom {n}{k}}=^{n}\\operatorname {C} \\_{k}={\\frac {n(n-1)\\ldots (n-k+1)}{k(k-1)\\dots 1}}}} | n  P  k = n ⋅ ( n − 1 ) ⋅ ( n − 2 ) ⋯ ( n − k + 1 ) {\\displaystyle {\\displaystyle ^{n}\\operatorname {P} \\_{k}=n\\cdot (n-1)\\cdot (n-2)\\cdots (n-k+1)}} |\n                | Task: Combinations | Task: Permutations |\n                | With replacement | (   n + k − 1 k  )  =  n + k − 1  C  k =    ( n + k − 1 ) !  ( n − 1 ) ! k ! {\\displaystyle {\\displaystyle {\\binom {n+k-1}{k}}=^{n+k-1}\\operatorname {C} \\_{k}={(n+k-1)! \\over (n-1)!k!}}} | n  k {\\displaystyle {\\displaystyle n^{k}}} |\n                | Task: Combinations with repetitions | Task: Permutations with repetitions |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nWe can use the X operator (\"cartesian product\") to cross the list with itself.  \nFor \n\nn\n=\n2\n{\\displaystyle {\\displaystyle n=2}}\n:\n\n**Works with**: rakudo version 2016.07\n\n```\nmy @k = <a b c>;\n\n.say for @k X @k;\n\n```\n\nFor arbitrary \n\nn\n{\\displaystyle {\\displaystyle n}}\n:\n\n**Works with**: rakudo version 2016.07\n\n```\nmy @k = <a b c>;\nmy $n = 2;\n\n.say for [X] @k xx $n;\n\n```\n\nOutput:\n\n```\na a\na b\na c\nb a\nb b\nb c\nc a\nc b\nc c\n```\n\nHere is an other approach, counting all \n\nk\n\nn\n{\\displaystyle {\\displaystyle k^{n}}}\n possibilities in base \n\nk\n{\\displaystyle {\\displaystyle k}}\n:\n\n**Works with**: rakudo version 2016.07\n\n```\nmy @k = <a b c>;\nmy $n = 2;\n\nsay @k[.polymod: +@k xx $n-1] for ^@k**$n\n\n```\n\nOutput:\n\n```\na a\nb a\nc a\na b\nb b\nc b\na c\nb c\nc c\n```"}]}
{"messages": [{"role": "user", "content": "Sometimes you want to find all permutations of elements where some elements are repeated, e.g. you have 3 red balls, 2 blue balls and one black ball.\n\nIf you just do all permutations of the 6 elements, each permutation will be duplicated 12 times where you can't tell that the identical elements have switched places.\n\nGiven an input of the form   [a1, a2, ···, ak]   where   ak   denotes how many duplicates of element   k   you should have,\n  \neach   ak > 0   and the sum of all   ak   is   **n**.\n\nYou should get   n! / (a1! × a2! ... × ak!)   permutations as a result.\n\n(You may, of course, denote the elements   0..k-1   if that works better.)\n\nFor example, the input   [2,1]   should give results   (1,1,2),   (1,2,1)   and  (2,1,1).\n\nAlternatively, if zero-based:   (0,0,1),   (0,1,0)   and   (1,0,0).\n\nTask\n\nList the permutations you get from the input   [2, 3, 1].\n\nOptionally output the permutations as strings where the first element is represented by **A**, the second by **B** and the third by **C**  \n  \n(the example result would then be **AAB**, **ABA** and **BAA**).\n\nRelated tasks\n\n* Anagrams\n* Permutations\n* Permutations/Derangements"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07\n\n```\nsub permutations-with-some-identical-elements ( @elements, @reps = () ) {\n    with @elements { (@reps ?? flat $_ Zxx @reps !! flat .keys.map(*+1) Zxx .values).permutations».join.unique }\n }\n\nfor (<2 1>,), (<2 3 1>,), (<A B C>, <2 3 1>), (<🦋 ⚽ 🙄>, <2 2 1>) {\n    put permutations-with-some-identical-elements |$_;\n    say '';\n}\n\n```\n\nOutput:\n\n```\n112 121 211\n\n112223 112232 112322 113222 121223 121232 121322 122123 122132 122213 122231 122312 122321 123122 123212 123221 131222 132122 132212 132221 211223 211232 211322 212123 212132 212213 212231 212312 212321 213122 213212 213221 221123 221132 221213 221231 221312 221321 222113 222131 222311 223112 223121 223211 231122 231212 231221 232112 232121 232211 311222 312122 312212 312221 321122 321212 321221 322112 322121 322211\n\nAABBBC AABBCB AABCBB AACBBB ABABBC ABABCB ABACBB ABBABC ABBACB ABBBAC ABBBCA ABBCAB ABBCBA ABCABB ABCBAB ABCBBA ACABBB ACBABB ACBBAB ACBBBA BAABBC BAABCB BAACBB BABABC BABACB BABBAC BABBCA BABCAB BABCBA BACABB BACBAB BACBBA BBAABC BBAACB BBABAC BBABCA BBACAB BBACBA BBBAAC BBBACA BBBCAA BBCAAB BBCABA BBCBAA BCAABB BCABAB BCABBA BCBAAB BCBABA BCBBAA CAABBB CABABB CABBAB CABBBA CBAABB CBABAB CBABBA CBBAAB CBBABA CBBBAA\n\n🦋🦋⚽⚽🙄 🦋🦋⚽🙄⚽ 🦋🦋🙄⚽⚽ 🦋⚽🦋⚽🙄 🦋⚽🦋🙄⚽ 🦋⚽⚽🦋🙄 🦋⚽⚽🙄🦋 🦋⚽🙄🦋⚽ 🦋⚽🙄⚽🦋 🦋🙄🦋⚽⚽ 🦋🙄⚽🦋⚽ 🦋🙄⚽⚽🦋 ⚽🦋🦋⚽🙄 ⚽🦋🦋🙄⚽ ⚽🦋⚽🦋🙄 ⚽🦋⚽🙄🦋 ⚽🦋🙄🦋⚽ ⚽🦋🙄⚽🦋 ⚽⚽🦋🦋🙄 ⚽⚽🦋🙄🦋 ⚽⚽🙄🦋🦋 ⚽🙄🦋🦋⚽ ⚽🙄🦋⚽🦋 ⚽🙄⚽🦋🦋 🙄🦋🦋⚽⚽ 🙄🦋⚽🦋⚽ 🙄🦋⚽⚽🦋 🙄⚽🦋🦋⚽ 🙄⚽🦋⚽🦋 🙄⚽⚽🦋🦋\n\n```"}]}
{"messages": [{"role": "user", "content": "A derangement is a permutation of the order of distinct items in which *no item appears in its original place*.\n\nFor example, the only two derangements of the three items (0, 1, 2) are (1, 2, 0), and (2, 0, 1).\n\nThe number of derangements of *n* distinct items is known as the subfactorial of *n*, sometimes written as !*n*.\nThere are various ways to calculate !*n*.\n\nTask\n\n1. Create a named function/method/subroutine/... to generate derangements of the integers *0..n-1*, (or *1..n* if you prefer).\n2. Generate *and show* all the derangements of 4 integers using the above routine.\n3. Create a function that calculates the subfactorial of *n*, !*n*.\n4. Print and show a table of the *counted* number of derangements of *n* vs. the calculated !*n* for n from 0..9 inclusive.\n\nOptional stretch goal\n\n* Calculate    !*20*\n\nRelated tasks\n\n* Anagrams/Deranged anagrams\n* Best shuffle\n* Left\\_factorials\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n**Works with**: Rakudo version 2016.10\n\nGenerate `List.permutations` and keep the ones where no elements are in their original position. This is done by zipping each permutation with the original list, and keeping the ones where none of the zipped pairs are equal.\n\nI am using the `Z` infix zip operator with the `eqv` equivalence infix operator, all wrapped inside a `none()` Junction.\n\nAlthough not necessary for this task, I have used `eqv` instead of `==` so that the `derangements()` function also works with any set of arbitrary objects (eg. strings, lists, etc.)\n\n```\nsub derangements(@l) {\n    @l.permutations.grep(-> @p { none(@p Zeqv @l) })\n}\n\nsub prefix:<!>(Int $n) {\n    (1, 0, 1, -> $a, $b { ($++ + 2) × ($b + $a) } ... *)[$n]\n}\n\nsay 'derangements([1, 2, 3, 4])';\nsay derangements([1, 2, 3, 4]), \"\\n\";\n\nsay 'n == !n == derangements(^n).elems';\nfor 0 .. 9 -> $n {\n    say \"!$n == { !$n } == { derangements(^$n).elems }\"\n}\n\n```\n\nOutput:\n\n```\nderangements([1, 2, 3, 4])\n((2 1 4 3) (2 3 4 1) (2 4 1 3) (3 1 4 2) (3 4 1 2) (3 4 2 1) (4 1 2 3) (4 3 1 2) (4 3 2 1))\n\nn == !n == derangements(^n).elems\n!0 == 1 == 1\n!1 == 0 == 0\n!2 == 1 == 1\n!3 == 2 == 2\n!4 == 9 == 9\n!5 == 44 == 44\n!6 == 265 == 265\n!7 == 1854 == 1854\n!8 == 14833 == 14833\n!9 == 133496 == 133496\n\n```\n\nMuch faster to just calculate the subfactorial.\n\n```\nmy @subfactorial = 1,0,{++$ × ($^a + $^b)}…*;\n\nsay \"!$_: \",@subfactorial[$_] for |^10, 20, 200;\n\n```\n\nOutput:\n\n```\n!0: 1\n!1: 0\n!2: 1\n!3: 2\n!4: 9\n!5: 44\n!6: 265\n!7: 1854\n!8: 14833\n!9: 133496\n!20: 895014631192902121\n!200: 290131015521620609254546237518688936375622413566095185632876940298382875066633305125595907908697818551860745708196640009079772455670451355426573609799907339222509103785567575227183775791345718826220455840965346196540544976439608810006794385963854831693077054723298130736781093200499800934036993104223443563872463385599425635345341317933466521378117877578807421014599223577201\n```"}]}
{"messages": [{"role": "user", "content": "A particular ranking of a permutation associates an integer with a particular ordering of all the permutations of a set of distinct items.\nFor our purposes the ranking will assign integers \n\n0..\n(\nn\n!\n−\n1\n)\n{\\displaystyle {\\displaystyle 0..(n!-1)}}\n to an ordering of all the permutations of the integers \n\n0..\n(\nn\n−\n1\n)\n{\\displaystyle {\\displaystyle 0..(n-1)}}\n.\n\nFor example, the permutations of the digits zero to 3 arranged lexicographically have the following rank:\n\n```\n  PERMUTATION      RANK\n  (0, 1, 2, 3) ->  0\n  (0, 1, 3, 2) ->  1\n  (0, 2, 1, 3) ->  2\n  (0, 2, 3, 1) ->  3\n  (0, 3, 1, 2) ->  4\n  (0, 3, 2, 1) ->  5\n  (1, 0, 2, 3) ->  6\n  (1, 0, 3, 2) ->  7\n  (1, 2, 0, 3) ->  8\n  (1, 2, 3, 0) ->  9\n  (1, 3, 0, 2) -> 10\n  (1, 3, 2, 0) -> 11\n  (2, 0, 1, 3) -> 12\n  (2, 0, 3, 1) -> 13\n  (2, 1, 0, 3) -> 14\n  (2, 1, 3, 0) -> 15\n  (2, 3, 0, 1) -> 16\n  (2, 3, 1, 0) -> 17\n  (3, 0, 1, 2) -> 18\n  (3, 0, 2, 1) -> 19\n  (3, 1, 0, 2) -> 20\n  (3, 1, 2, 0) -> 21\n  (3, 2, 0, 1) -> 22\n  (3, 2, 1, 0) -> 23\n```\n\nAlgorithms exist that can generate a rank from a permutation for some particular ordering of permutations, and that can generate the same rank from the given individual permutation (i.e. given a rank of 17 produce (2, 3, 1, 0) in the example above).\n\nOne use of such algorithms could be in generating a small, random, sample of permutations of \n\nn\n{\\displaystyle {\\displaystyle n}}\n items without duplicates when the total number of permutations is large. Remember that the total number of permutations of \n\nn\n{\\displaystyle {\\displaystyle n}}\n items is given by \n\nn\n!\n{\\displaystyle {\\displaystyle n!}}\n which grows large very quickly: A 32 bit integer can only hold \n\n12\n!\n{\\displaystyle {\\displaystyle 12!}}\n, a 64 bit integer only \n\n20\n!\n{\\displaystyle {\\displaystyle 20!}}\n. It becomes difficult to take the straight-forward approach of generating all permutations then taking a random sample of them.\n\nA question on the Stack Overflow site asked how to generate one million random and indivudual permutations of 144 items.\n\nTask\n\n1. Create a function to generate a permutation from a rank.\n2. Create the inverse function that given the permutation generates its rank.\n3. Show that for \n\n   n\n   =\n   3\n   {\\displaystyle {\\displaystyle n=3}}\n    the two functions are indeed inverses of each other.\n4. Compute and show here 4 random, individual, samples of permutations of 12 objects.\n\nStretch goal\n\n* State how reasonable it would be to use your program to address the limits of the Stack Overflow question.\n\nReferences\n\n1. Ranking and Unranking Permutations in Linear Time by Myrvold & Ruskey. (Also available via Google here).\n2. Ranks on the DevData site.\n3. Another answer on Stack Overflow to a different question that explains its algorithm in detail.\n\nRelated tasks\n\n1. Factorial\\_base\\_numbers\\_indexing\\_permutations\\_of\\_a\\_collection"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nIt is similar to Haskell, but separate something like inversion vector.\nIt is easy generate random inversion vector without BigInt.\n\n```\nuse v6;\n\nsub rank2inv ( $rank, $n = * ) {\n    $rank.polymod( 1 ..^ $n );\n}\n\nsub inv2rank ( @inv ) {\n    [+] @inv Z* [\\*] 1, 1, * + 1 ... * \n}\n\nsub inv2perm ( @inv, @items is copy = ^@inv.elems ) {\n    my @perm;\n    for @inv.reverse -> $i {\n        @perm.append: @items.splice: $i, 1;\n    }\n    @perm;\n}\n\nsub perm2inv ( @perm ) {     #not in linear time \n    (\n        { @perm[++$ .. *].grep( * < $^cur ).elems } for @perm;  \n    ).reverse;\n}    \n    \nfor ^6 {\n    my @row.push: $^rank;\n    for ( *.&rank2inv(3) , &inv2perm, &perm2inv, &inv2rank )  -> &code {\n        @row.push: code( @row[*-1] );\n    }\n    say @row;\n}\n\nmy $perms =  4;      #100;\nmy $n     = 12;      #144;\n\nsay 'Via BigInt rank';\nfor ( ( ^([*] 1 .. $n) ).pick($perms) ) {\n    say $^rank.&rank2inv($n).&inv2perm; \n};\n\nsay 'Via inversion vectors';\nfor ( { my $i=0;  inv2perm (^++$i).roll xx $n } ... *  ).unique( with => &[eqv] ).[^$perms] {\n    .say;\n};\n\nsay 'Via Raku method pick';\nfor ( { [(^$n).pick(*)] } ... * ).unique( with => &[eqv] ).head($perms) {\n    .say\n};\n\n```\n\nOutput:\n\n```\n[0 (0 0 0) [0 1 2] (0 0 0) 0]\n[1 (0 1 0) [0 2 1] (0 1 0) 1]\n[2 (0 0 1) [1 0 2] (0 0 1) 2]\n[3 (0 1 1) [1 2 0] (0 1 1) 3]\n[4 (0 0 2) [2 0 1] (0 0 2) 4]\n[5 (0 1 2) [2 1 0] (0 1 2) 5]\nVia BigInt rank\n[4 3 1 8 6 2 0 7 9 11 5 10]\n[0 8 11 4 9 3 7 5 2 6 10 1]\n[5 7 9 11 10 6 4 1 2 3 0 8]\n[9 11 8 6 3 5 7 2 4 0 1 10]\nVia inversion vectors\n[9 0 3 1 8 2 4 5 11 7 10 6]\n[7 3 1 10 0 6 4 11 2 9 8 5]\n[9 8 5 11 1 10 0 7 4 6 2 3]\n[10 8 6 5 4 9 0 2 11 7 1 3]\nVia Raku method pick\n[11 0 7 10 9 4 1 8 6 5 2 3]\n[4 5 8 3 2 1 7 9 11 0 10 6]\n[11 7 9 4 0 8 10 1 5 2 6 3]\n[11 10 0 3 4 6 7 9 8 5 1 2]\n\n```"}]}
{"messages": [{"role": "user", "content": "Attribution\n\nThe following task is taken from Project Euler.\n\nTask\n\nFind the smallest positive integer **n** such that, when expressed in decimal, 2\\*n, 3\\*n, 4\\*n, 5\\*n, and 6\\*n contain *exactly* the same digits but in a different order."}, {"role": "assistant", "content": "```\nput display (^∞).map(1 ~ *).race.map( -> \\n { next unless [eq] (2,3,4,5,6).map: { (n × $_).comb.sort.join }; n } ).first;\n\nsub display ($n) { join \"\\n\", \" n: $n\", (2..6).map: { \"×$_: {$n×$_}\" } }\n\n```\n\nOutput:\n\n```\n n: 142857\n×2: 285714\n×3: 428571\n×4: 571428\n×5: 714285\n×6: 857142\n\n```"}]}
{"messages": [{"role": "user", "content": "A   pernicious number   is a positive integer whose   population count   is a prime.\n\nThe   *population count*   is the number of   *ones*   in the binary representation of a non-negative integer.\n\nExample\n\n**22**   (which is   **10110**   in binary)   has a population count of   **3**,   which is prime,   and therefore\n  \n**22**   is a pernicious number.\n\nTask\n\n* display the first   **25**   pernicious numbers   (in decimal).\n* display all pernicious numbers between   **888,888,877**   and   **888,888,888**   (inclusive).\n* display each list of integers on one line   (which may or may not include a title).\n\nSee also\n\n* Sequence   A052294 pernicious numbers on The On-Line Encyclopedia of Integer Sequences.\n* Rosetta Code entry   population count, evil numbers, odious numbers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nStraightforward implementation using Raku's *is-prime* built-in subroutine.\n\n```\nsub is-pernicious(Int $n --> Bool) {\n    is-prime [+] $n.base(2).comb;\n}\n\nsay (grep &is-pernicious, 0 .. *)[^25];\nsay grep &is-pernicious, 888_888_877 .. 888_888_888;\n\n```\n\nOutput:\n\n```\n3 5 6 7 9 10 11 12 13 14 17 18 19 20 21 22 24 25 26 28 31 33 34 35 36\n888888877 888888878 888888880 888888883 888888885 888888886\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a string of space separated words containing the following phrase:\n\n```\n rosetta code phrase reversal\n\n```\n\n:   1. Reverse the characters of the string.\n    2. Reverse the characters of each individual word in the string, maintaining original word order within the string.\n    3. Reverse the order of each word of the string, maintaining the order of characters in each word.\n\nShow your output here.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $s = 'rosetta code phrase reversal';\n\nput 'Input               : ', $s;\nput 'String reversed     : ', $s.flip;\nput 'Each word reversed  : ', $s.words».flip;\nput 'Word-order reversed : ', $s.words.reverse;\n\n```\n\nOutput:\n\n```\nInput               : rosetta code phrase reversal\nString reversed     : lasrever esarhp edoc attesor\nEach word reversed  : attesor edoc esarhp lasrever\nWord-order reversed : reversal phrase code rosetta\n```"}]}
{"messages": [{"role": "user", "content": "Create a program to continually calculate and output the next decimal digit of   \n\nπ\n{\\displaystyle {\\displaystyle \\pi }}\n   (pi).\n\nThe program should continue forever (until it is aborted by the user) calculating and outputting each decimal digit in succession.\n\nThe output should be a decimal sequence beginning   3.14159265 ...\n\nNote: this task is about   *calculating*   pi.   For information on built-in pi constants see Real constants and functions.\n\nRelated Task Arithmetic-geometric mean/Calculate Pi"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.10\n\n```\n# based on http://www.mathpropress.com/stan/bibliography/spigot.pdf\n\nsub stream(&next, &safe, &prod, &cons, $z is copy, @x) {\n    gather loop {\n        $z = safe($z, my $y = next($z)) ??\n             prod($z, take $y)          !!\n             cons($z, @x[$++])  \n    }\n}\n\nsub extr([$q, $r, $s, $t], $x) {\n    ($q * $x + $r) div ($s * $x + $t)\n}\n\nsub comp([$q,$r,$s,$t], [$u,$v,$w,$x]) {\n    [$q * $u + $r * $w,\n     $q * $v + $r * $x,\n     $s * $u + $t * $w,\n     $s * $v + $t * $x]\n}\n\nmy $pi := \n    stream -> $z { extr($z, 3) },\n           -> $z, $n { $n == extr($z, 4) },\n           -> $z, $n { comp([10, -10*$n, 0, 1], $z) },\n           &comp,\n           <1 0 0 1>,\n           (1..*).map: { [$_, 4 * $_ + 2, 0, 2 * $_ + 1] }\n\nfor ^Inf -> $i {\n    print $pi[$i];\n    once print '.'\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Demonstrate how to pick a random element from a list."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-12-07\n\nIn a nutshell, picking an element from a list\nis implemented with a method conveniently called \"pick\":\n\n```\nsay (1, 2, 3).pick;\n\n```\n\nThere are various ways of doing something similar, though.\nRaku has actually two methods (with associated functional forms)\nto return random elements depending on whether you are doing selection\nwith or without replacement.\n\nSelection with replacement: (roll of a die)\n\n```\nsay (1..6).roll;          # return 1 random value in the range 1 through 6\nsay (1..6).roll(3);       # return a list of 3 random values in the range 1 through 6\nsay (1..6).roll(*)[^100]; # return first 100 values from a lazy infinite list of random values in the range 1 through 6\n\n```\n\nSelection without replacement: (pick a card from a deck)\n\n```\n# define the deck\nmy @deck = <2 3 4 5 6 7 8 9 J Q K A> X~ <♠ ♣ ♥ ♦>;\nsay @deck.pick;    # Pick a card\nsay @deck.pick(5); # Draw 5\nsay @deck.pick(*); # Get a shuffled deck\n\n```\n\nOr you can always use the normal rand built-in\nto generate a subscript (which automatically truncates any fractional part):\n\n```\n@array[@array * rand]\n\n```\n\nHowever, the pick and roll methods (not to be confused\nwith the pick-and-roll method in basketball) are more general\ninsofar as they may be used on any enumerable type:\n\n```\nsay Bool.pick;  # returns either True or False\n\n```"}]}
{"messages": [{"role": "user", "content": "A Pierpont prime is a prime number of the form: **2*u*3*v* + 1** for some non-negative integers  ***u***  and  ***v*** .\n\nA Pierpont prime of the second kind is a prime number of the form: **2*u*3*v* - 1** for some non-negative integers  ***u***  and  ***v*** .\n\n*The term \"Pierpont primes\" is generally understood to mean the first definition, but will be called \"Pierpont primes of the first kind\" on this page to distinguish them.*\n\nTask\n\n:   * Write a routine (function, procedure, whatever) to find Pierpont primes of the first & second kinds.\n\n:   * Use the routine to find and display here, on this page, the first **50 Pierpont primes of the first kind**.\n\n:   * Use the routine to find and display here, on this page, the first **50 Pierpont primes of the second kind**\n\n:   * If your language supports large integers, find and display here, on this page, the **250th Pierpont prime of the first kind** and the **250th Pierpont prime of the second kind**.\n\nSee also\n\n:   * **Wikipedia - Pierpont primes**\n    * **OEIS:A005109 - Class 1 -, or Pierpont primes**\n    * **OEIS:A005105 - Class 1 +, or Pierpont primes of the second kind**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\n### Finesse version\n\nThis finesse version never produces more Pierpont numbers than it needs to\nfulfill the requested number of primes. It uses a series of parallel iterators\nwith additional iterators added as required. No need to speculatively generate\nan overabundance. No need to rely on magic numbers. No need to sort them. It\nproduces exactly what is needed, in order, on demand.\n\n**Library:** ntheory\n\n```\nuse ntheory:from<Perl5> <is_prime>;\n\nsub pierpont ($kind is copy = 1) {\n    fail \"Unknown type: $kind. Must be one of 1 (default) or 2\" if $kind !== 1|2;\n    $kind = -1 if $kind == 2;\n    my $po3 = 3;\n    my $add-one = 3;\n    my @iterators = [1,2,4,8 … *].iterator, [3,9,27 … *].iterator;\n    my @head = @iterators».pull-one;\n\n    gather {\n        loop {\n            my $key = @head.pairs.min( *.value ).key;\n            my $min = @head[$key];\n            @head[$key] = @iterators[$key].pull-one;\n\n            take $min + $kind if \"{$min + $kind}\".&is_prime;\n\n            if $min >= $add-one {\n                @iterators.push: ([|((2,4,8).map: * * $po3) … *]).iterator;\n                $add-one = @head[+@iterators - 1] = @iterators[+@iterators - 1].pull-one;\n                $po3 *= 3;\n            }\n        }\n    }\n}\n\nsay \"First 50 Pierpont primes of the first kind:\\n\" ~ pierpont[^50].rotor(10)».fmt('%8d').join: \"\\n\";\n\nsay \"\\nFirst 50 Pierpont primes of the second kind:\\n\" ~ pierpont(2)[^50].rotor(10)».fmt('%8d').join: \"\\n\";\n\nsay \"\\n250th Pierpont prime of the first kind: \" ~ pierpont[249];\n\nsay \"\\n250th Pierpont prime of the second kind: \" ~ pierpont(2)[249];\n\n```\n\nOutput:\n\n```\nFirst 50 Pierpont primes of the first kind:\n       2        3        5        7       13       17       19       37       73       97\n     109      163      193      257      433      487      577      769     1153     1297\n    1459     2593     2917     3457     3889    10369    12289    17497    18433    39367\n   52489    65537   139969   147457   209953   331777   472393   629857   746497   786433\n  839809   995329  1179649  1492993  1769473  1990657  2654209  5038849  5308417  8503057\n\nFirst 50 Pierpont primes of the second kind:\n       2        3        5        7       11       17       23       31       47       53\n      71      107      127      191      383      431      647      863      971     1151\n    2591     4373     6143     6911     8191     8747    13121    15551    23327    27647\n   62207    73727   131071   139967   165887   294911   314927   442367   472391   497663\n  524287   786431   995327  1062881  2519423 10616831 17915903 18874367 25509167 30233087\n\n250th Pierpont prime of the first kind: 62518864539857068333550694039553\n\n250th Pierpont prime of the second kind: 4111131172000956525894875083702271\n```\n\n### Generalized Pierpont iterator\n\nAlternately, a version that will generate generalized Pierpont numbers for any set of prime integers where at least one of the primes is 2.\n\n(Cut down output as it is exactly the same as the first version for {2,3} +1 and {2,3} -1; leaves room to demo some other options.)\n\n```\nsub smooth-numbers (*@list) {\n    cache my \\Smooth := gather {\n        my %i = (flat @list) Z=> (Smooth.iterator for ^@list);\n        my %n = (flat @list) Z=> 1 xx *;\n\n        loop {\n            take my $n := %n{*}.min;\n\n            for @list -> \\k {\n                %n{k} = %i{k}.pull-one * k if %n{k} == $n;\n            }\n        }\n    }\n}\n\n# Testing various smooth numbers\n\nfor   'OEIS: A092506 - 2 + Fermat primes:',        (2),        1,  6,\n    \"\\nOEIS: A000668 - Mersenne primes:\",          (2),       -1, 10,\n    \"\\nOEIS: A005109 - Pierpont primes 1st:\",      (2,3),      1, 20,\n    \"\\nOEIS: A005105 - Pierpont primes 2nd:\",      (2,3),     -1, 20,\n    \"\\nOEIS: A077497:\",                            (2,5),      1, 20,\n    \"\\nOEIS: A077313:\",                            (2,5),     -1, 20,\n    \"\\nOEIS: A002200 - (\\\"Hamming\\\" primes 1st):\", (2,3,5),    1, 20,\n    \"\\nOEIS: A293194 - (\\\"Hamming\\\" primes 2nd):\", (2,3,5),   -1, 20,\n    \"\\nOEIS: A077498:\",                            (2,7),      1, 20,\n    \"\\nOEIS: A077314:\",                            (2,7),     -1, 20,\n    \"\\nOEIS: A174144 - (\\\"Humble\\\" primes 1st):\",  (2,3,5,7),  1, 20,\n    \"\\nOEIS: A347977 - (\\\"Humble\\\" primes 2nd):\",  (2,3,5,7), -1, 20,\n    \"\\nOEIS: A077499:\",                            (2,11),     1, 20,\n    \"\\nOEIS: A077315:\",                            (2,11),    -1, 20,\n    \"\\nOEIS: A173236:\",                            (2,13),     1, 20,\n    \"\\nOEIS: A173062:\",                            (2,13),    -1, 20\n\n  -> $title, $primes, $add, $count {\n\n      say \"$title smooth \\{$primes\\} {$add > 0 ?? '+' !! '-'} 1 \";\n      put smooth-numbers(|$primes).map( * + $add ).grep( *.is-prime )[^$count]\n}\n\n```\n\nOutput:\n\n```\nOEIS: A092506 - 2 + Fermat primes: smooth {2} + 1 \n2 3 5 17 257 65537\n\nOEIS: A000668 - Mersenne primes: smooth {2} - 1 \n3 7 31 127 8191 131071 524287 2147483647 2305843009213693951 618970019642690137449562111\n\nOEIS: A005109 - Pierpont primes 1st: smooth {2 3} + 1 \n2 3 5 7 13 17 19 37 73 97 109 163 193 257 433 487 577 769 1153 1297\n\nOEIS: A005105 - Pierpont primes 2nd: smooth {2 3} - 1 \n2 3 5 7 11 17 23 31 47 53 71 107 127 191 383 431 647 863 971 1151\n\nOEIS: A077497: smooth {2 5} + 1 \n2 3 5 11 17 41 101 251 257 401 641 1601 4001 16001 25601 40961 62501 65537 160001 163841\n\nOEIS: A077313: smooth {2 5} - 1 \n3 7 19 31 79 127 199 499 1249 1279 1999 4999 5119 8191 12799 20479 31249 49999 51199 79999\n\nOEIS: A002200 - (\"Hamming\" primes 1st): smooth {2 3 5} + 1 \n2 3 5 7 11 13 17 19 31 37 41 61 73 97 101 109 151 163 181 193\n\nOEIS: A293194 - (\"Hamming\" primes 2nd): smooth {2 3 5} - 1 \n2 3 5 7 11 17 19 23 29 31 47 53 59 71 79 89 107 127 149 179\n\nOEIS: A077498: smooth {2 7} + 1 \n2 3 5 17 29 113 197 257 449 1373 3137 50177 65537 114689 268913 470597 614657 1075649 3294173 7340033\n\nOEIS: A077314: smooth {2 7} - 1 \n3 7 13 31 97 127 223 1567 3583 4801 6271 8191 19207 25087 33613 76831 131071 401407 524287 917503\n\nOEIS: A174144 - (\"Humble\" primes 1st): smooth {2 3 5 7} + 1 \n2 3 5 7 11 13 17 19 29 31 37 41 43 61 71 73 97 101 109 113\n\nOEIS: A299171 - (\"Humble\" primes 2nd): smooth {2 3 5 7} - 1 \n2 3 5 7 11 13 17 19 23 29 31 41 47 53 59 71 79 83 89 97\n\nOEIS: A077499: smooth {2 11} + 1 \n2 3 5 17 23 89 257 353 1409 2663 30977 65537 170369 495617 5767169 23068673 59969537 82458113 453519617 3429742097\n\nOEIS: A077315: smooth {2 11} - 1 \n3 7 31 43 127 241 967 5323 8191 117127 131071 524287 7496191 10307263 77948683 253755391 428717761 738197503 1714871047 2147483647\n\nOEIS: A173236: smooth {2 13} + 1 \n2 3 5 17 53 257 677 3329 13313 35153 65537 2768897 13631489 2303721473 3489660929 4942652417 11341398017 10859007357953 1594691292233729 31403151600910337\n\nOEIS: A173062: smooth {2 13} - 1 \n3 7 31 103 127 337 1663 5407 8191 131071 346111 524287 2970343 3655807 22151167 109051903 617831551 1631461441 2007952543 2147483647\n```"}]}
{"messages": [{"role": "user", "content": "The   game of Pig   is a multiplayer game played with a single six-sided die.   The\nobject of the game is to reach   **100**   points or more.  \nPlay is taken in turns.   On each person's turn that person has the option of either:\n\n:   1. **Rolling the dice**:   where a roll of two to six is added to their score for that turn and the player's turn continues as the player is given the same choice again;   or a roll of   **1**   loses the player's total points   *for that turn*   and their turn finishes with play passing to the next player.\n    2. **Holding**:   the player's score for that round is added to their total and becomes safe from the effects of throwing a   **1**   (one).   The player's turn finishes with play passing to the next player.\n\nTask\n\nCreate a program to score for, and simulate dice throws for, a two-person game.\n\nRelated task\n\n* Pig the dice game/Player"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-09-30\n\n```\nconstant DIE = 1..6;\n \nsub MAIN (Int :$players = 2, Int :$goal = 100) {\n    my @safe = 0 xx $players;\n    for |^$players xx * -> $player {\n\tsay \"\\nOK, player #$player is up now.\";\n\tmy $safe = @safe[$player];\n\tmy $ante = 0;\n\tuntil $safe + $ante >= $goal or\n\t    prompt(\"#$player, you have $safe + $ante = {$safe+$ante}. Roll? [Yn] \") ~~ /:i ^n/\n\t{\n\t    given DIE.roll {\n\t\tsay \"  You rolled a $_.\";\n\t\twhen 1 {\n\t\t    say \"  Bust!  You lose $ante but keep your previous $safe.\";\n\t\t    $ante = 0;\n\t\t    last;\n\t\t}\n\t\twhen 2..* {\n\t\t    $ante += $_;\n\t\t}\n\t    }\n\t}\n\t$safe += $ante;\n\tif $safe >= $goal {\n\t    say \"\\nPlayer #$player wins with a score of $safe!\";\n\t    last;\n\t}\n\t@safe[$player] = $safe;\n\tsay \"  Sticking with $safe.\" if $ante;\n    }\n}\n\n```\n\nThe game defaults to the specified task, but we'll play a shorter game with three players for our example:\n\nOutput:\n\n```\n> pig help\nUsage:\n  pig [--players=<Int>] [--goal=<Int>]\n> pig --players=3 --goal=20\n\nOK, player #0 is up now.\n#0, you have 0 + 0 = 0. Roll? [Yn] \n  You rolled a 6.\n#0, you have 0 + 6 = 6. Roll? [Yn] \n  You rolled a 6.\n#0, you have 0 + 12 = 12. Roll? [Yn] n\n  Sticking with 12.\n\nOK, player #1 is up now.\n#1, you have 0 + 0 = 0. Roll? [Yn] \n  You rolled a 4.\n#1, you have 0 + 4 = 4. Roll? [Yn] \n  You rolled a 6.\n#1, you have 0 + 10 = 10. Roll? [Yn] \n  You rolled a 6.\n#1, you have 0 + 16 = 16. Roll? [Yn] n\n  Sticking with 16.\n\nOK, player #2 is up now.\n#2, you have 0 + 0 = 0. Roll? [Yn] \n  You rolled a 5.\n#2, you have 0 + 5 = 5. Roll? [Yn] \n  You rolled a 1.\n  Bust!  You lose 5 but keep your previous 0.\n\nOK, player #0 is up now.\n#0, you have 12 + 0 = 12. Roll? [Yn] \n  You rolled a 1.\n  Bust!  You lose 0 but keep your previous 12.\n\nOK, player #1 is up now.\n#1, you have 16 + 0 = 16. Roll? [Yn] n\n\nOK, player #2 is up now.\n#2, you have 0 + 0 = 0. Roll? [Yn] \n  You rolled a 6.\n#2, you have 0 + 6 = 6. Roll? [Yn] \n  You rolled a 6.\n#2, you have 0 + 12 = 12. Roll? [Yn] \n  You rolled a 4.\n#2, you have 0 + 16 = 16. Roll? [Yn] \n  You rolled a 6.\n\nPlayer #2 wins with a score of 22!\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a dice simulator and scorer of Pig the dice game and add to it the ability to play the game to at least one strategy.\n\n* State here the play strategies involved.\n* Show play during a game here.\n\nAs a stretch goal:\n\n* Simulate playing the game a number of times with two players of given strategies and report here summary statistics such as, but not restricted to, the influence of going first or which strategy seems stronger.\n\nGame Rules\n\nThe game of Pig is a multiplayer game played with a single six-sided die. The\nobject of the game is to reach 100 points or more.\nPlay is taken in turns. On each person's turn that person has the option of either\n\n1. **Rolling the dice**: where a roll of two to six is added to their score for that turn and the player's turn continues as the player is given the same choice again; or a roll of 1 loses the player's total points *for that turn* and their turn finishes with play passing to the next player.\n2. **Holding**: The player's score for that round is added to their total and becomes safe from the effects of throwing a one. The player's turn finishes with play passing to the next player.\n\nReferences\n\n* Pig (dice)\n* The Math of Being a Pig and Pigs (extra) - Numberphile videos featuring Ben Sparks."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis implements a pig player class where you can customize the strategy it uses. Pass a strategy code reference in that will evaluate to a Boolean value. The player will roll the die then decide whether to roll again or lock in its winnings based on its strategy. It will continue to roll until it gets a 1 (bust) or the strategy code reference evaluates to True (finished turn).\n\nSet up as many players as you want, then run it. It will play 100 games (by default) then report the score for each game then the win totals for each player. If you want to play a different number of games, pass the number at the command line as a parameter.\n\nHere we have 5 players:\n\n```\n player 0 uses the default strategy, always roll if it can. \n player 1 will roll up to 5 times then lock in whatever it earned.\n player 2 will try to get at least 20 points per turn.\n player 3 randomly picks whether to roll again or not biased so that there is a 90% chance that it will.\n player 4 randomly chooses to roll again but gets more consrvative as its score get closer to the goal.\n\n```\n\n```\nmy $games = @*ARGS ?? (shift @*ARGS) !! 100;\n\nconstant DIE = 1 .. 6;\nconstant GOAL = 100;\n\nclass player {\n    has $.score    is rw = 0;\n    has $.ante     is rw;\n    has $.rolls    is rw;\n    has &.strategy is rw = sub { False }; # default, always roll again\n\n    method turn {\n        my $done_turn = False;\n        $.rolls = 0;\n        $.ante  = 0;\n        repeat {\n            given DIE.roll {\n                $.rolls++;\n                when 1 {\n                    $.ante = 0;\n                    $done_turn = True;\n                }\n                when 2..* {\n                    $.ante += $_;\n                }\n            }\n            $done_turn = True if $.score + $.ante >= GOAL or (&.strategy)();\n        } until $done_turn;\n        $.score += $.ante;\n    }\n}\n\nmy @players;\n\n# default, go-for-broke, always roll again\n@players[0] = player.new;\n\n# try to roll 5 times but no more per turn\n@players[1] = player.new( strategy => sub { @players[1].rolls >= 5 } );\n\n# try to accumulate at least 20 points per turn\n@players[2] = player.new( strategy => sub { @players[2].ante > 20 } );\n\n# random but 90% chance of rolling again\n@players[3] = player.new( strategy => sub { 1.rand < .1 } );\n\n# random but more conservative as approaches goal\n@players[4] = player.new( strategy => sub { 1.rand < ( GOAL - @players[4].score ) * .6 / GOAL } );\n\nmy @wins = 0 xx @players;\n\nfor ^ $games {\n    my $player = -1;\n    repeat {\n        $player++;\n        @players[$player % @players].turn;\n    } until @players[$player % @players].score >= GOAL;\n\n    @wins[$player % @players]++;\n\n    say join \"\\t\", @players>>.score;\n    @players[$_].score = 0 for ^@players; # reset scores for next game\n}\n\nsay \"\\nSCORES: for $games games\";\nsay join \"\\t\", @wins;\n\n```\n\n**Sample output for 10000 games**\n\n```\n0\t103\t46\t5\t40\n0\t100\t69\t0\t48\n0\t105\t22\t7\t44\n0\t75\t69\t19\t102\n105\t21\t23\t5\t17\n0\t101\t85\t12\t29\n0\t70\t66\t103\t23\n0\t0\t104\t69\t20\n0\t100\t44\t0\t20\n0\t102\t63\t75\t30\n0\t56\t101\t12\t40\n0\t103\t71\t2\t38\n0\t103\t91\t21\t32\n0\t18\t102\t47\t28\n...\n...\n...\n104\t0\t69\t14\t47\n0\t68\t101\t13\t22\n0\t99\t89\t102\t31\n\nSCORES: for 10000 games\n947\t3534\t3396\t1714\t409\n\n\n```"}]}
{"messages": [{"role": "user", "content": "Sample image\n\nThe task is to demonstrate the creation of a series of vertical pinstripes across **the entire width of the display**.\n\n* in the first quarter the pinstripes should alternate one pixel white, one pixel black = 1 pixel wide vertical pinestripes\n* Quarter of the way down the display, we can switch to a wider 2 pixel wide vertical pinstripe pattern, alternating two pixels white, two pixels black.\n* Half way down the display, we switch to 3 pixels wide,\n* for the lower quarter of the display we use 4 pixels.\n\nc.f. Colour\\_pinstripe/Display"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.10\n\n```\nmy ($x,$y) = 1280,720;\nmy @colors = 0, 1;\n\nspurt \"pinstripes.pgm\", qq:to/EOH/ orelse .die;\n    P5\n    # pinstripes.pgm\n    $x $y\n    1\n    EOH\n\nmy $img = open \"pinstripes.pgm\", :a, :bin orelse .die;\n\nmy $vzones = $y div 4;\nfor 1..4 -> $w {\n    my $stripes = ceiling $x / $w / +@colors;\n    my $line = Buf.new: (flat((@colors Xxx $w) xx $stripes).Array).splice(0,$x); # DH change 2015-12-20\n    $img.write: $line for ^$vzones;\n}\n\n$img.close;\n\n```"}]}
{"messages": [{"role": "user", "content": "The task is to demonstrate the creation of a series of 1 point wide vertical pinstripes with a sufficient number of pinstripes to span the entire width of the printed page (except for the last pinstripe). The pinstripes should alternate one point white, one point black. (Where the printer does not support producing graphics in terms of points, pixels may be substituted in this task.)\n\nAfter the first inch of printing, we switch to a wider 2 point wide vertical pinstripe pattern. alternating two points white, two points black. We then switch to 3 points wide for the next inch, and then 4 points wide, etc. This trend continues for the entire length of the page (or for 12 inches of run length in the case of a printer using continuous roll stationery). After printing the test pattern the page is ejected (or the test pattern is rolled clear of the printer enclosure, in the case of continuous roll printers).\n\nNote that it is an acceptable solution to use the smallest marks that the language provides, rather than working at native printer resolution, where this is not achievable from within the language.\n\nOptionally, on systems where the printer resolution cannot be determined, it is permissible to prompt the user for printer resolution, and to calculate point size based on user input, enabling fractional point sizes to be used."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.01\n\nNote that Raku does not attempt to be a printer driver. This example allows users to specify the dpi and paper size, then generates an image and passes it to the default printer. Defaults to 300 dpi and US letter paper.\n\n```\nunit sub MAIN ($dpi = 300, $size = 'letter');\n\nmy $filename = './Pinstripe-printer-perl6.png';\n\nmy %paper = (\n    'letter' => { :width(8.5),    :height(11.0) }\n    'A4'     => { :width(8.2677), :height(11.6929)}\n);\n\nmy ($w, $h) = %paper{$size}<width height> »*» $dpi;\n\n# Black. It's all black\nmy @color = (0,0,0),;\n\nmy $gap = floor $w % ($dpi * 8) / 2;\n\nmy $rows = (1, * * 2 … * > 8 * $dpi).elems;\n\nmy $height = $dpi * .8;\n\nuse Cairo;\n\nmy @colors = @color.map: { Cairo::Pattern::Solid.new.create(|$_) };\n\ngiven Cairo::Image.create(Cairo::FORMAT_ARGB32, $w, $h) -> $image {\n    given Cairo::Context.new($image) {\n        my Cairo::Pattern::Solid $bg .= create(1,1,1);\n        .rectangle(0, 0, $w, $h);\n        .pattern($bg);\n        .fill;\n        $bg.destroy;\n        my $y = $gap;\n        for ^$rows -> $row {\n            my $x = $gap;\n            my $width = 8 * $dpi / (2 ** $row);\n            for @colors -> $this {\n                my $v = 0;\n                while $x < ($dpi * 8) {\n                    given Cairo::Context.new($image) -> $block {\n                        $block.rectangle($x, $y, $width, $height);\n                        $block.pattern($this);\n                        $block.fill;\n                        $block.destroy;\n                    }\n                    $x += $width * 2;\n                }\n            }\n            $y += $height;\n        }\n    }\n    $image.write_png($filename);\n}\n\n# Uncomment next line if you actually want to print it\n#run('lp', $filename)\n\n```\n\nSee Pinstripe-printer-perl6.png (offsite png image)"}]}
{"messages": [{"role": "user", "content": "Task\n\npi(n), the number of primes <= n, where **pi(n) < 22**\n\nAlso see\n:   * Prime-counting\\_function.\n    * Tables and hints   by Tomás Oliveira e Silva.\n    * the OEIS entry:   A0000720 pi(n), the number of primes <= n. Sometimes called PrimePi(n)...."}, {"role": "assistant", "content": "```\nmy @pi = (1..*).map: { state $pi = 0; $pi += .is-prime };\n\nsay @pi[^(@pi.first: * >= 22, :k)].batch(10)».fmt('%2d').join: \"\\n\";\n\n```\n\nOutput:\n\n```\n 0  1  2  2  3  3  4  4  4  4\n 5  5  6  6  6  6  7  7  8  8\n 8  8  9  9  9  9  9  9 10 10\n11 11 11 11 11 11 12 12 12 12\n13 13 14 14 14 14 15 15 15 15\n15 15 16 16 16 16 16 16 17 17\n18 18 18 18 18 18 19 19 19 19\n20 20 21 21 21 21 21 21\n```"}]}
{"messages": [{"role": "user", "content": "The Fibonacci sequence taken modulo 2 is a periodic sequence of period 3 : 0, 1, 1, 0, 1, 1, ...\n\nFor any integer n, the Fibonacci sequence taken modulo n is periodic and the length of the periodic cycle is referred to as the Pisano period.\n\nPrime numbers are straightforward; the Pisano period of a prime number **p** is simply: **pisano(p)**. The Pisano period of a composite number **c** may be found in different ways. It may be calculated directly: **pisano(c)**, which works, but may be time consuming to find, especially for larger integers, or, it may be calculated by finding the least common multiple of the Pisano periods of each composite component.\n\nE.G.\n\nGiven a Pisano period function: pisano(x), and a least common multiple function lcm(x, y):\n\n```\n   pisano(m × n) is equivalent to lcm(pisano(m), pisano(n)) where  m  and  n  are coprime\n\n```\n\nA formulae to calculate the pisano period for integer powers   **k**   of prime numbers   **p**   is:\n\n```\n   pisano(pk) == p(k-1)pisano(p) \n\n```\n\nThe equation is conjectured, no exceptions have been seen.\n\nIf a positive integer   **i**   is split into its prime factors,   then the second and first equations above can be applied to generate the pisano period.\n\nTask\n\nWrite 2 functions: pisanoPrime(p,k) and pisano(m).\n\npisanoPrime(p,k) should return the Pisano period of pk where p is prime and k is a positive integer.\n\npisano(m) should use pisanoPrime to return the Pisano period of m where m is a positive integer.\n\nPrint pisanoPrime(p,2) for every prime lower than 15.\n\nPrint pisanoPrime(p,1) for every prime lower than 180.\n\nPrint pisano(m) for every integer from 1 to 180.\n\nRelated tasks\n\n* Fibonacci sequence\n* Prime decomposition\n* Least common multiple"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.02\n\nDidn't bother making two differently named routines, just made a multi that will auto dispatch to the correct candidate.\n\n```\nuse Prime::Factor;\n\nconstant @fib := 1,1,*+*…*;\n\nmy %cache;\n\nmulti pisano-period (Int $p where *.is-prime, Int $k where * > 0 = 1) {\n    return %cache{\"$p|$k\"} if %cache{\"$p|$k\"};\n    my $fibmod = @fib.map: * % $p**$k;\n    %cache{\"$p|$k\"} = (1..*).first: { !$fibmod[$_-1] and ($fibmod[$_] == 1) }\n}\n\nmulti pisano-period (Int $p where * > 0 ) {\n    [lcm] prime-factors($p).Bag.map: { samewith .key, .value }\n}\n\n\nput \"Pisano period (p, 2) for primes less than 50\";\nput (map { pisano-period($_, 2) }, ^50 .grep: *.is-prime )».fmt('%4d');\n\nput \"\\nPisano period (p, 1) for primes less than 180\";\n.put for (map { pisano-period($_, 1) }, ^180 .grep: *.is-prime )».fmt('%4d').batch(15);\n\nput \"\\nPisano period (p, 1) for integers 1 to 180\";\n.put for (1..180).map( { pisano-period($_) } )».fmt('%4d').batch(15);\n\n```\n\nOutput:\n\n```\nPisano period (p, 2) for primes less than 50\n   6   24  100  112  110  364  612  342 1104  406  930 2812 1640 3784 1504\n\nPisano period (p, 1) for primes less than 180\n   3    8   20   16   10   28   36   18   48   14   30   76   40   88   32\n 108   58   60  136   70  148   78  168   44  196   50  208   72  108   76\n 256  130  276   46  148   50  316  328  336  348  178\n\nPisano period (p, 1) for integers 1 to 180\n   1    3    8    6   20   24   16   12   24   60   10   24   28   48   40\n  24   36   24   18   60   16   30   48   24  100   84   72   48   14  120\n  30   48   40   36   80   24   76   18   56   60   40   48   88   30  120\n  48   32   24  112  300   72   84  108   72   20   48   72   42   58  120\n  60   30   48   96  140  120  136   36   48  240   70   24  148  228  200\n  18   80  168   78  120  216  120  168   48  180  264   56   60   44  120\n 112   48  120   96  180   48  196  336  120  300   50   72  208   84   80\n 108   72   72  108   60  152   48   76   72  240   42  168  174  144  120\n 110   60   40   30  500   48  256  192   88  420  130  120  144  408  360\n  36  276   48   46  240   32  210  140   24  140  444  112  228  148  600\n  50   36   72  240   60  168  316   78  216  240   48  216  328  120   40\n 168  336   48  364  180   72  264  348  168  400  120  232  132  178  120\n```"}]}
{"messages": [{"role": "user", "content": "The plasma effect is a visual effect created by applying various functions, notably sine and cosine, to the color values of screen pixels. When animated (not a task requirement) the effect may give the impression of a colorful flowing liquid.\n\nTask\n\nCreate a plasma effect.\n\nSee also\n\n* Computer Graphics Tutorial (lodev.org)\n* Plasma (bidouille.org)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\n```\nuse Image::PNG::Portable;\n\nmy ($w, $h) = 400, 400;\nmy $out = Image::PNG::Portable.new: :width($w), :height($h);\n\nplasma($out);\n\n$out.write: 'Plasma-perl6.png';\n\nsub plasma ($png) {\n    (^$w).race.map: -> $x {\n        for ^$h -> $y {\n            my $hue = 4 + sin($x / 19) + sin($y / 9) + sin(($x + $y) / 25) + sin(sqrt($x² + $y²) / 8);\n            $png.set: $x, $y, |hsv2rgb($hue/8, 1, 1);\n        }\n    }\n}\n\nsub hsv2rgb ( $h, $s, $v ){\n    my $c = $v * $s;\n    my $x = $c * (1 - abs( (($h*6) % 2) - 1 ) );\n    my $m = $v - $c;\n    (do given $h {\n        when   0..^1/6 { $c, $x, 0 }\n        when 1/6..^1/3 { $x, $c, 0 }\n        when 1/3..^1/2 { 0, $c, $x }\n        when 1/2..^2/3 { 0, $x, $c }\n        when 2/3..^5/6 { $x, 0, $c }\n        when 5/6..1    { $c, 0, $x }\n    } ).map: ((*+$m) * 255).Int\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a Playfair cipher for encryption and decryption.\n\nThe user must be able to choose   **J**  =  **I**     or   no   **Q**   in the alphabet.\n\nThe output of the encrypted and decrypted message must be in capitalized digraphs, separated by spaces.\n\nOutput example\n\n```\n                HI DE TH EG OL DI NT HE TR EX ES TU MP\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# Instantiate a specific encoder/decoder.\n\nsub playfair( $key,\n              $from = 'J',\n\t      $to = $from eq 'J' ?? 'I' !! ''\n) {\n\n    sub canon($str) { $str.subst(/<-alpha>/,'', :g).uc.subst(/$from/,$to,:g) }\n\n    # Build 5x5 matrix.\n    my @m = canon($key ~ ('A'..'Z').join).comb.unique.map: \n     -> $a,$b,$c,$d,$e { [$a,$b,$c,$d,$e] }\n\n    # Pregenerate all forward translations.\n    my %ENC = gather {\n\t# Map pairs in same row.\n\tfor @m -> @r {\n\t    for ^@r X ^@r -> (\\i,\\j) {\n\t\tnext if i == j;\n\t\ttake @r[i] ~ @r[j] => @r[(i+1)%5] ~ @r[(j+1)%5];\n\t    }\n\t}\n\n\t# Map pairs in same column.\n\tfor ^5 -> $c {\n\t    my @c = @m.map: *.[$c];\n\t    for ^@c X ^@c -> (\\i,\\j) {\n\t\tnext if i == j;\n\t\ttake @c[i] ~ @c[j] => @c[(i+1)%5] ~ @c[(j+1)%5];\n\t    }\n\t}\n\n\t# Map pairs with cross-connections.\n\tfor ^5 X ^5 X ^5 X ^5 -> (\\i1,\\j1,\\i2,\\j2) {\n\t    next if i1 == i2 or j1 == j2;\n\t    take @m[i1][j1] ~ @m[i2][j2] => @m[i1][j2] ~ @m[i2][j1];\n\t}\n    }\n\n    # Generate reverse translations.\n    my %DEC = %ENC.invert;\n\n    return\n        sub enc($red) {\n\t    my @list = canon($red).comb(/(.) (.?) <?{ $1 ne $0 }>/);\n\t    ~@list.map: { .chars == 1 ?? %ENC{$_~'X'} !! %ENC{$_} }\n\t},\n\tsub dec($black) {\n\t    my @list = canon($black).comb(/../);\n\t    ~@list.map: { %DEC{$_} }\n\t}\n}\n\nmy (&encode,&decode) = playfair 'Playfair example';\n\nmy $orig = \"Hide the gold in...the TREESTUMP!!!\";\nsay \" orig:\\t$orig\";\n\nmy $black = encode $orig;\nsay \"black:\\t$black\";\n\nmy $red = decode $black;\nsay \"  red:\\t$red\";\n\n```\n\nOutput:\n\n```\n orig:\tHide the gold in...the TREESTUMP!!!\nblack:\tBM OD ZB XD NA BE KU DM UI XM MO UV IF\n  red:\tHI DE TH EG OL DI NT HE TR EX ES TU MP\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a data structure and the associated methods to define and manipulate a deck of   playing cards.\n\nThe deck should contain 52 unique cards.\n\nThe methods must include the ability to:\n\n:   :   :   * make a new deck\n            * shuffle (randomize) the deck\n            * deal from the deck\n            * print the current contents of a deck\n\nEach card must have a pip value and a suit value which constitute the unique value of the card.\n\nRelated tasks:\n\n* Card shuffles\n* Deal cards\\_for\\_FreeCell\n* War Card\\_Game\n* Poker hand\\_analyser\n* Go Fish"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.08\n\n```\nenum Pip <A 2 3 4 5 6 7 8 9 10 J Q K>;\nenum Suit <♦ ♣ ♥ ♠>;\n \nclass Card {\n    has Pip $.pip;\n    has Suit $.suit;\n \n    method Str { $!pip ~ $!suit }\n}\n \nclass Deck {\n    has Card @.cards = pick *,\n            map { Card.new(:$^pip, :$^suit) }, flat (Pip.pick(*) X Suit.pick(*));\n \n    method shuffle { @!cards .= pick: * }\n \n    method deal { shift @!cards }\n \n    method Str  { ~@!cards }\n    method gist { ~@!cards }\n}\n\nmy Deck $d = Deck.new;\nsay \"Deck: $d\";\n\nmy $top = $d.deal;\nsay \"Top card: $top\";\n\n$d.shuffle;\nsay \"Deck, re-shuffled: \", $d;\n\n```\n\nOutput:\n\n```\nDeck: 3♦ J♦ 4♥ 7♠ 7♣ 7♥ 9♣ K♥ 6♠ 2♦ 3♠ Q♥ 8♥ 2♥ J♥ 5♥ 8♦ 8♣ 6♦ 7♦ 5♦ 2♣ 4♦ 8♠ 9♥ 4♣ 3♥ K♠ 2♠ 5♣ Q♣ Q♦ K♦ 4♠ 9♦ Q♠ 5♠ 6♥ J♣ J♠ K♣ 9♠ 3♣ 6♣\nTop card: 3♦\nDeck, re-shuffled: K♦ 4♣ J♠ 2♥ J♥ K♣ 6♣ 5♠ 3♥ 6♦ 5♦ 4♠ J♣ 4♦ 6♥ K♥ 7♥ 7♦ 2♦ 4♥ 6♠ 7♣ 9♦ 3♣ 3♠ 2♣ 2♠ 8♦ 5♣ 9♠ 5♥ J♦ 9♥ Q♦ Q♣ Q♥ Q♠ 8♥ 8♠ K♠ 9♣ 8♣ 7♠\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nPlot a function represented as     x,  y     numerical arrays.\n\nPost the resulting image for the following input arrays (taken from Python's Example section on Time a function):\n\n```\n      x = {0,   1,    2,    3,    4,    5,     6,     7,     8,     9};\n      y = {2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0};\n\n```\n\nThis task is intended as a subtask for Measure relative performance of sorting algorithms implementations."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nGenerate an SVG image file.\n\n```\nuse SVG;\nuse SVG::Plot;\n\nmy @x = 0..9;\nmy @y = (2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0);\n\nsay SVG.serialize: SVG::Plot.new(\n    width       => 512,\n    height      => 512,\n    x           => @x,\n    x-tick-step => { 1 },\n    min-y-axis  => 0,\n    values      => [@y,],\n    title  => 'Coordinate Pairs',\n).plot(:lines);\n\n```"}]}
{"messages": [{"role": "user", "content": "In this task, the goal is to demonstrate common operations on pointers and references. These examples show pointer operations on the stack, which can be dangerous and is rarely done. Pointers and references are commonly used along with Memory allocation on the heap."}, {"role": "assistant", "content": "(formerly Perl 6)\nIn Raku all non-native values are boxed and accessed via implicit references. (This is like Java or Python, but unlike C or Perl 5, which use explicit referencing and dereferencing.) Variables are references to containers that can contain references to other values. Basic binding (aliasing) of references to names is supported via the := operator, while assignment to mutable containers implies a dereference from the name to the container, followed by copying of values rather than by duplicating pointers. (Assignment of a bare object reference copies the reference as if it were a value, but the receiving container automatically dereferences as necessary, so to all appearances you are putting the object itself into the destination rather than its reference, and we just think the object can be in more than one place at the same time.)\n\n```\nmy $foo = 42;    # place a reference to 42 in $foo's item container\n$foo++;          # deref $foo name, then increment the container's contents to 43\n$foo.say;        # deref $foo name, then $foo's container, and call a method on 43.\n\n$foo := 42;      # bind a direct ref to 42\n$foo++;          # ERROR, cannot modify immutable value\n\nmy @bar = 1,2,3; # deref @bar name to array container, then set its values\n@bar»++;         # deref @bar name to array container, then increment each value with a hyper\n@bar.say;        # deref @bar name to array container, then call say on that, giving 2 3 4\n\n@bar := (1,2,3); # bind name directly to a List\n@bar»++;         # ERROR, parcels are not mutable\n```\n\nReferences to hashes and functions work more like arrays, insofar as a method call acts directly on the container, not on what the container contains. That is, they don't do the extra dereference implied by calling a method on a scalar variable.\n\nTo the first approximation, Raku programmers do not think about references much; since everything is a reference, and value semantics are emulated by assign and other mutating operators, the ubiquitous references are largely transparent to the Raku programmer most of the time."}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a program to parse a single five card poker hand and rank it according to this list of poker hands.\n\nA poker hand is specified as a space separated list of five playing cards.\n\nEach input card has two characters indicating face and suit.\n\nExample\n:   :   :   :   **2d**       (two of diamonds).\n\nFaces are:    **a**, **2**, **3**, **4**, **5**, **6**, **7**, **8**, **9**, **10**, **j**, **q**, **k**\n\nSuits are:    **h** (hearts),   **d** (diamonds),   **c** (clubs),   and   **s** (spades),   or\n  \nalternatively,   the unicode card-suit characters:     ♥ ♦ ♣ ♠\n\nDuplicate cards are illegal.\n\nThe program should analyze a single hand and produce one of the following outputs:\n\n```\n straight-flush\n four-of-a-kind\n full-house\n flush\n straight\n three-of-a-kind\n two-pair\n one-pair\n high-card\n invalid\n\n```\n\nExamples\n\n```\n   2♥ 2♦ 2♣ k♣ q♦:   three-of-a-kind\n   2♥ 5♥ 7♦ 8♣ 9♠:   high-card\n   a♥ 2♦ 3♣ 4♣ 5♦:   straight\n   2♥ 3♥ 2♦ 3♣ 3♦:   full-house\n   2♥ 7♥ 2♦ 3♣ 3♦:   two-pair\n   2♥ 7♥ 7♦ 7♣ 7♠:   four-of-a-kind \n   10♥ j♥ q♥ k♥ a♥:  straight-flush\n   4♥ 4♠ k♠ 5♦ 10♠:  one-pair\n   q♣ 10♣ 7♣ 6♣ q♣:  invalid\n\n```\n\nThe programs output for the above examples should be displayed here on this page.\n\nExtra credit\n\n1. use the playing card characters introduced with Unicode 6.0 (U+1F0A1 - U+1F0DE).\n2. allow two jokers\n\n:   :   * use the symbol   **joker**\n        * duplicates would be allowed (for jokers only)\n        * five-of-a-kind would then be the highest hand\n\nMore extra credit examples\n\n```\n   joker  2♦  2♠  k♠  q♦:     three-of-a-kind\n   joker  5♥  7♦  8♠  9♦:     straight\n   joker  2♦  3♠  4♠  5♠:     straight\n   joker  3♥  2♦  3♠  3♦:     four-of-a-kind\n   joker  7♥  2♦  3♠  3♦:     three-of-a-kind\n   joker  7♥  7♦  7♠  7♣:     five-of-a-kind\n   joker  j♥  q♥  k♥  A♥:     straight-flush\n   joker  4♣  k♣  5♦ 10♠:     one-pair\n   joker  k♣  7♣  6♣  4♣:     flush\n   joker  2♦  joker  4♠  5♠:  straight\n   joker  Q♦  joker  A♠ 10♠:  straight\n   joker  Q♦  joker  A♦ 10♦:  straight-flush\n   joker  2♦  2♠  joker  q♦:  four-of-a-kind\n\n```\n\nRelated tasks\n\n* Playing cards\n* Card shuffles\n* Deal cards\\_for\\_FreeCell\n* War Card\\_Game\n* Go Fish"}, {"role": "assistant", "content": "(formerly Perl 6)\nThis solution handles jokers. It has been written to use a Raku grammar.\n\n```\nuse v6;\n \ngrammar PokerHand {\n \n    # Raku Grammar to parse and rank 5-card poker hands\n    # E.g. PokerHand.parse(\"2♥ 3♥ 2♦ 3♣ 3♦\");\n    # 2013-12-21: handle 'joker' wildcards; maximum of two\n \n    rule TOP {\n         :my %*PLAYED;\n         { %*PLAYED = () }\n         [ <face-card> | <joker> ]**5\n    }\n \n    token face-card {<face><suit> <?{\n            my $card = ~$/.lc;\n            # disallow duplicates\n            ++%*PLAYED{$card} <= 1;\n       }>\n    }\n \n    token joker {:i 'joker' <?{\n            my $card = ~$/.lc;\n            # allow two jokers in a hand\n            ++%*PLAYED{$card} <= 2;\n        }>\n    }\n \n    token face {:i <[2..9 jqka]> | 10 }\n    token suit {<[♥ ♦ ♣ ♠]>}\n}\n\nclass PokerHand::Actions {\n    method TOP($/) {\n        my UInt @n    = n-of-a-kind($/);\n        my $flush     = 'flush' if flush($/);\n        my $straight  = 'straight' if straight($/);\n        make rank(@n[0], @n[1], $flush, $straight);\n    }\n    multi sub rank(5,*@)                    { 'five-of-a-kind' }\n    multi sub rank($,$,'flush','straight')  { 'straight-flush' }\n    multi sub rank(4,*@)                    { 'four-of-a-kind' }\n    multi sub rank($,$,'flush',$)           { 'flush' }\n    multi sub rank($,$,$,'straight')        { 'straight' }\n    multi sub rank(3,2,*@)                  { 'full-house' }\n    multi sub rank(3,*@)                    { 'three-of-a-kind' }\n    multi sub rank(2,2,*@)                  { 'two-pair' }\n    multi sub rank(2,*@)                    { 'one-pair' }\n    multi sub rank(*@)                      { 'high-card' }\n  \n    sub n-of-a-kind($/) {\n        my %faces := bag @<face-card>.map: -> $/ {~$<face>.lc};\n        my @counts = %faces.values.sort.reverse;\n        @counts[0] += @<joker>;\n        return @counts;\n    }\n \n    sub flush($/) {\n        my @suits = unique @<face-card>.map: -> $/ {~$<suit>};\n        return +@suits == 1;\n    }\n \n    sub straight($/) {\n        # allow both ace-low and ace-high straights\n        constant @Faces = [ \"a 2 3 4 5 6 7 8 9 10 j q k a\".split: ' ' ];\n        constant @Possible-Straights = [ (4 ..^ @Faces).map: { set @Faces[$_-4 .. $_] } ];\n\n        my $faces = set @<face-card>.map: -> $/ {~$<face>.lc};\n        my $jokers = +@<joker>;\n \n        return ?( @Possible-Straights.first: { +($faces ∩ $_) + $jokers == 5 } );\n    }\n}\n\nmy PokerHand::Actions $actions .= new;\n\nfor (\"2♥ 2♦ 2♣ k♣ q♦\",   # three-of-a-kind\n     \"2♥ 5♥ 7♦ 8♣ 9♠\",   # high-card\n     \"a♥ 2♦ 3♣ 4♣ 5♦\",   # straight\n     \"2♥ 3♥ 2♦ 3♣ 3♦\",   # full-house\n     \"2♥ 7♥ 2♦ 3♣ 3♦\",   # two-pair\n     \"2♥ 7♥ 7♦ 7♣ 7♠\",   # four-of-a-kind\n     \"10♥ j♥ q♥ k♥ a♥\",  # straight-flush\n     \"4♥ 4♠ k♠ 5♦ 10♠\",  # one-pair\n     \"q♣ 10♣ 7♣ 6♣ 4♣\",  # flush\n     \"a♥ a♥ 3♣ 4♣ 5♦\",   # invalid\n     ## EXTRA CREDIT ##\n     \"joker  2♦  2♠  k♠  q♦\",  # three-of-a-kind\n     \"joker  5♥  7♦  8♠  9♦\",  # straight\n     \"joker  2♦  3♠  4♠  5♠\",  # straight\n     \"joker  3♥  2♦  3♠  3♦\",  # four-of-a-kind\n     \"joker  7♥  2♦  3♠  3♦\",  # three-of-a-kind\n     \"joker  7♥  7♦  7♠  7♣\",  # five-of-a-kind\n     \"joker  j♥  q♥  k♥  A♥\",  # straight-flush\n     \"joker  4♣  k♣  5♦ 10♠\",  # one-pair\n     \"joker  k♣  7♣  6♣  4♣\",  # flush\n     \"joker  2♦ joker  4♠  5♠\",  # straight\n     \"joker  Q♦ joker  A♠ 10♠\",  # straight\n     \"joker  Q♦ joker  A♦ 10♦\",  # straight-flush\n     \"joker  2♦ 2♠  joker  q♦\",  # four of a kind\n    ) {\n    my $rank = do with PokerHand.parse($_, :$actions) {\n        .ast;\n    }\n    else {\n        'invalid';\n    }\n    say \"$_: $rank\";\n}\n\n```\n\nOutput:\n\n```\n2♥ 2♦ 2♣ k♣ q♦: three-of-a-kind\n2♥ 5♠ 7♦ 8♣ 9♠: high-card\na♠ 2♦ 3♣ 4♣ 5♦: straight\n2♥ 3♠ 2♦ 3♣ 3♦: full-house\n2♥ 7♠ 2♦ 3♣ 3♦: two-pair\n2♥ 7♥ 7♦ 7♣ 7♠: four-of-a-kind\n10♠ j♠ q♠ k♠ a♠: straight-flush\n4♥ 4♠ k♠ 5♦ 10♠: one-pair\nq♣ 10♣ 7♣ 6♣ 4♣: flush\na♥ a♥ 3♣ 4♣ 5♦: invalid\njoker  2♦  2♠  k♠  q♦: three-of-a-kind\njoker  5♠  7♦  8♠  9♦: straight\njoker  2♦  3♠  4♠  5♠: straight\njoker  3♥  2♦  3♠  3♦: four-of-a-kind\njoker  7♥  2♦  3♠  3♦: three-of-a-kind\njoker  7♥  7♦  7♠  7♣: five-of-a-kind\njoker  j♠  q♠  k♠  A♠: straight-flush\njoker  4♣  k♣  5♦ 10♠: one-pair\njoker  k♣  7♣  6♣  4♣: flush\njoker  2♦ joker  4♠  5♠: straight\njoker  Q♦ joker  A♠ 10♠: straight\njoker  Q♦ joker  A♦ 10♦: straight-flush\njoker  2♦ 2♠  joker  q♦: four-of-a-kind\n```"}]}
{"messages": [{"role": "user", "content": "In the area of number decomposition algorithms, **Pollard's rho algorithm** is a fast, yet fairly simple method to find factors of a number, using a pseudorandom number generator modulo the number.\n\nExcept for trivial factors like 2, 3, 5 etc., it is much faster than trial division, finding a factor quite often, but may terminate without a factor. Thus it cannot prove that a number is prime. If it is known that a number is not prime, the algorithm can be re-iterated with changed parameters to finally find a factor (not necessarily a prime factor) with quite high probability.\n\nTask\n\nWrite a function to demonstrate the algorithm (see pseudocode in Wikipedia). The intent is to show the principle as clear as possible in the respective language, but avoid an endless loop. Enhanced versions may be presented as extra examples.\n\nWarning\n\nThe variables 'x' and 'y' may be equal during an iteration, calling 'gcd()' with first argument 0,\nwhile the GCD is only defined for postitive numbers, so a library gdc() function might fail. If in this case, the other argument is returned, the algorithm reports failure, which is acceptable.\nThe gcd() functions supplied for AWK and C have this property.\n\nExample numbers, if supported:\n\n* 4294967213 = 75167 \\* 57139 (32 bits)\n* 9759463979 = 98779 \\* 98801 (34 bits)\n* 34225158206557151 = 130051349 \\* 263166499 (55 bits)\n* 763218146048580636353 = 25998278833 \\* 29356487441 (70 bits)\n\nRelated tasks\n\n* prime decomposition\n* AKS test for primes\n* factors of an integer\n* factors of a Mersenne number\n* trial factoring of a Mersenne number\n* partition an integer X into N primes\n* sequence of primes by Trial Division\n\nReferences\n\n* Wikipedia: Pollard's rho algorithm"}, {"role": "assistant", "content": "Copied verbatim (with different test values) from the Prime decomposition page. This finds all prime factors of an integer of any size. Very large integers, especially those with two or more factors larger than 40 bit may take a while, but it will find them eventually.\n\nRaku handles big integers seamlessly and transparently. No special handling required.\n\n```\nsub prime-factors ( Int $n where * > 0 ) {\n    return $n if $n.is-prime;\n    return () if $n == 1;\n    my $factor = find-factor( $n );\n    sort flat ( $factor, $n div $factor ).map: &prime-factors;\n}\n\nsub find-factor ( Int $n, $constant = 1 ) {\n    return 2 unless $n +& 1;\n    if (my $gcd = $n gcd 6541380665835015) > 1 { # magic number: [*] primes 3 .. 43\n        return $gcd if $gcd != $n\n    }\n    my $x      = 2;\n    my $rho    = 1;\n    my $factor = 1;\n    while $factor == 1 {\n        $rho = $rho +< 1;\n        my $fixed = $x;\n        my int $i = 0;\n        while $i < $rho {\n            $x = ( $x * $x + $constant ) % $n;\n            $factor = ( $x - $fixed ) gcd $n;\n            last if 1 < $factor;\n            $i = $i + 1;\n        }\n    }\n    $factor = find-factor( $n, $constant + 1 ) if $n == $factor;\n    $factor;\n}\n\n.put for (125, 217, 4294967213, 9759463979, 34225158206557151, 763218146048580636353,\n5465610891074107968111136514192945634873647594456118359804135903459867604844945580205745718497)\\\n.hyper(:1batch).map: -> $n {\n    my $start = now;\n   \"factors of $n: ({1+$n.msb} bits) \",\n    prime-factors($n).join(' × '), \" \\t in \", (now - $start).fmt(\"%0.3f\"), \" sec.\"\n}\n\n```\n\nOutput:\n\n```\nfactors of 125: (7 bits)  5 × 5 × 5  \t in  0.002  sec.\nfactors of 217: (8 bits)  7 × 31  \t in  0.001  sec.\nfactors of 4294967213: (32 bits)  57139 × 75167  \t in  0.001  sec.\nfactors of 9759463979: (34 bits)  98779 × 98801  \t in  0.001  sec.\nfactors of 34225158206557151: (55 bits)  130051349 × 263166499  \t in  0.021  sec.\nfactors of 763218146048580636353: (70 bits)  25998278833 × 29356487441  \t in  0.303  sec.\nfactors of 5465610891074107968111136514192945634873647594456118359804135903459867604844945580205745718497: (312 bits)  165901 × 10424087 × 18830281 × 53204737 × 56402249 × 59663291 × 91931221 × 95174413 × 305293727939 × 444161842339 × 790130065009  \t in  5.524  sec.\n```"}]}
{"messages": [{"role": "user", "content": "An object is polymorphic when its specific type may vary.\nThe types a specific value may take, is called *class*.\n\nIt is trivial to copy an object if its type is known:\n\n```\nint x;\nint y = x;\n\n```\n\nHere x is not polymorphic, so y is declared of same type (*int*) as x.\nBut if the specific type of x were unknown, then y could not be declared of any specific type.\n\nThe task: let a polymorphic object contain an instance of some specific type S derived from a type T.\nThe type T is known.\nThe type S is possibly unknown until run time.\nThe objective is to create an exact copy of such polymorphic object (not to create a reference, nor a pointer to).\nLet further the type T have a method overridden by S.\nThis method is to be called on the copy to demonstrate that the specific type of the copy is indeed S."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\n```\nmy Cool $x = 22/7 but role Fink { method brag { say \"I'm a cool {self.WHAT.raku}!\" }}\nmy Cool $y = $x.clone;\n$y.brag;\n\n```\n\nOutput:\n\n```\nI'm a cool Rat+{Fink}!\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate two classes   Point(x,y)   and   Circle(x,y,r)   with a polymorphic function print, accessors for (x,y,r), copy constructor, assignment and destructor and every possible default constructors"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\nAll appropriate constructors, initializers, accessors, and destructors are provided by default, but may be explicitly declared for flexibility.\nTo create only readonly accessors for better encapsulation, leave out all the \"is rw\" traits.\nHere we demonstrate that accessors can behave like variables and may be assigned.\n\n```\nclass Point {\n    has Real $.x is rw = 0;\n    has Real $.y is rw = 0;\n    method Str { $ }\n}\n\nclass Circle {\n    has Point $.p is rw = Point.new;\n    has Real $.r is rw = 0;\n    method Str { $ }\n}\n\nmy $c = Circle.new(p => Point.new(x => 1, y => 2), r => 3);\nsay $c;\n$c.p.x = (-10..10).pick;\n$c.p.y = (-10..10).pick;\n$c.r   = (0..10).pick;\nsay $c;\n\n```\n\nIn this case we define the Str coercion method polymorphically, which is used by say or print to format the contents of the object.\nWe could also have defined print methods directly.\nWe could have factored this method out to a common role and composed it into each class.\nWe could also have defined multi subs outside of the class, like this:\n\n```\nmulti print (Point $p) { $p.perl.print }\nmulti print (Circle $c) { $c.perl.print }\n\n```"}]}
{"messages": [{"role": "user", "content": "Given a polynomial, represented by an ordered list of its coefficients by increasing degree (e.g. [-1, 6, 5] represents 5x2+6x-1), calculate the polynomial representing the derivative. For example, the derivative of the aforementioned polynomial is 10x+6, represented by [6, 10]. Test cases: 5, -3x+4, 5x2+6x-1, x3-2x2+3x-4, -x4-x3+x+1\n\nRelated task\n:   * Polynomial long division"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers:ver<2.8+>;\n\nsub pretty (@poly) {\n    join( '+', (^@poly).reverse.map: { @poly[$_] ~ \"x{.&super}\" } )\\\n    .subst(/['+'|'-']'0x'<[⁰¹²³⁴⁵⁶⁷⁸⁹]>*/, '', :g).subst(/'x¹'<?before <-[⁰¹²³⁴⁵⁶⁷⁸⁹]>>/, 'x')\\\n    .subst(/'x⁰'$/, '').subst(/'+-'/, '-', :g).subst(/(['+'|'-'|^])'1x'/, {\"$0x\"}, :g) || 0\n}\n\nfor [5], [4,-3], [-1,3,-2,1], [-1,6,5], [1,1,0,-1,-1] -> $test {\n   say \"Polynomial: \" ~ \"[{$test.join: ','}] ➡ \" ~ pretty $test;\n   my @poly = |$test;\n   (^@poly).map: { @poly[$_] *= $_ };\n   shift @poly;\n   say \"Derivative: \" ~ \"[{@poly.join: ','}] ➡ \" ~ pretty @poly;\n   say '';\n}\n\n```\n\nOutput:\n\n```\nPolynomial: [5] ➡ 5\nDerivative: [] ➡ 0\n\nPolynomial: [4,-3] ➡ -3x+4\nDerivative: [-3] ➡ -3\n\nPolynomial: [-1,3,-2,1] ➡ x³-2x²+3x-1\nDerivative: [3,-4,3] ➡ 3x²-4x+3\n\nPolynomial: [-1,6,5] ➡ 5x²+6x-1\nDerivative: [6,10] ➡ 10x+6\n\nPolynomial: [1,1,0,-1,-1] ➡ -x⁴-x³+x+1\nDerivative: [1,0,-3,-4] ➡ -4x³-3x²+1\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Polynomial long division. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\n:   In algebra, polynomial long division is an algorithm for dividing a polynomial by another polynomial of the same or lower degree.\n\nLet us suppose a polynomial is represented by a vector, \n\nx\n{\\displaystyle {\\displaystyle x}}\n (i.e., an ordered collection of coefficients) so that the \n\ni\n{\\displaystyle {\\displaystyle i}}\nth element keeps the coefficient of \n\nx\n\ni\n{\\displaystyle {\\displaystyle x^{i}}}\n, and the multiplication by a monomial is a *shift* of the vector's elements \"towards right\" (injecting ones from left) followed by a multiplication of each element by the coefficient of the monomial.\n\nThen a pseudocode for the polynomial long division using the conventions described above could be:\n\n```\ndegree(P):\n  return the index of the last non-zero element of P;\n         if all elements are 0, return -∞\n\npolynomial_long_division(N, D) returns (q, r):\n  // N, D, q, r are vectors\n  if degree(D) < 0 then error\n  q ← 0\n  while degree(N) ≥ degree(D)\n    d ← D shifted right by (degree(N) - degree(D))\n    q(degree(N) - degree(D)) ← N(degree(N)) / d(degree(d))\n    // by construction, degree(d) = degree(N) of course\n    d ← d * q(degree(N) - degree(D))\n    N ← N - d\n  endwhile\n  r ← N\n  return (q, r)\n\n```\n\n**Note**: `vector * scalar` multiplies each element of the vector by the scalar; `vectorA - vectorB` subtracts each element of the vectorB from the element of the vectorA with \"the same index\". The vectors in the pseudocode are zero-based.\n\n* Error handling (for allocations or for wrong inputs) is not mandatory.\n* Conventions can be different; in particular, note that if the first coefficient in the vector is the highest power of x for the polynomial represented by the vector, then the algorithm becomes simpler.\n\n**Example for clarification**\n  \nThis example is from Wikipedia, but changed to show how the given pseudocode works.\n\n```\n      0    1    2    3\n   ----------------------\nN:  -42    0  -12    1        degree = 3\nD:   -3    1    0    0        degree = 1\n\n   d(N) - d(D) = 2, so let's shift D towards right by 2:\n\nN:  -42    0  -12    1\nd:    0    0   -3    1\n\n   N(3)/d(3) = 1, so d is unchanged. Now remember that \"shifting by 2\"\n   is like multiplying by x2, and the final multiplication\n   (here by 1) is the coefficient of this monomial. Let's store this\n   into q:\n                               0     1     2\n                              ---------------\n                          q:   0     0     1\n\n   now compute N - d, and let it be the \"new\" N, and let's loop\n\nN:  -42    0   -9    0        degree = 2\nD:   -3    1    0    0        degree = 1\n\n   d(N) - d(D) = 1, right shift D by 1 and let it be d\n\nN:  -42    0   -9    0\nd:    0   -3    1    0        * -9/1 = -9\n\n                          q:   0    -9     1\n\nd:    0   27   -9    0        \n\n   N ← N - d\n\nN:  -42  -27    0    0        degree = 1\nD:   -3    1    0    0        degree = 1\n\n   looping again... d(N)-d(D)=0, so no shift is needed; we\n   multiply D by -27 (= -27/1) storing the result in d, then\n\n                          q:  -27   -9     1\n\n   and\n\nN:  -42  -27    0    0        -\nd:   81  -27    0    0        =\nN: -123    0    0    0        (last N)\n\n    d(N) < d(D), so now r ← N, and the result is:\n\n       0   1  2\n   -------------\nq:   -27  -9  1   →  x2 - 9x - 27\nr:  -123   0  0   →          -123\n\n```\n\nRelated task\n:   * Polynomial derivative"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.10\n\n**Translation of**: Perl\n\nfor the core algorithm; original code for LaTeX pretty-printing.\n\n```\nsub poly_long_div ( @n is copy, @d ) {\n    return [0], |@n if +@n < +@d;\n\n    my @q = gather while +@n >= +@d {\n        @n = @n Z- flat ( ( @d X* take ( @n[0] / @d[0] ) ), 0 xx * );\n        @n.shift;\n    }\n\n    return @q, @n;\n}\n\nsub xP ( $power ) { $power>1 ?? \"x^$power\" !! $power==1 ?? 'x' !! '' }\nsub poly_print ( @c ) { join ' + ', @c.kv.map: { $^v ~ xP( @c.end - $^k ) } }\n\nmy @polys = [ [     1, -12, 0, -42 ], [    1, -3 ] ],\n            [ [     1, -12, 0, -42 ], [ 1, 1, -3 ] ],\n            [ [          1, 3,   2 ], [    1,  1 ] ],\n            [ [ 1, -4,   6, 5,   3 ], [ 1, 2,  1 ] ];\n\nsay '<math>\\begin{array}{rr}';\nfor @polys -> [ @a, @b ] {\n    printf Q\"%s , & %s \\\\\\\\\\n\", poly_long_div( @a, @b ).map: { poly_print($_) };\n}\nsay '\\end{array}</math>';\n\n```\n\nOutput:\n\n1\n\nx\n\n2\n+\n−\n9\nx\n+\n−\n27\n,\n\n−\n123\n\n\n1\nx\n+\n−\n13\n,\n\n16\nx\n+\n−\n81\n\n\n1\nx\n+\n2\n,\n\n0\n\n\n1\n\nx\n\n2\n+\n−\n6\nx\n+\n17\n,\n\n−\n23\nx\n+\n−\n14\n{\\displaystyle {\\displaystyle {\\begin{array}{rr}1x^{2}+-9x+-27,&-123\\\\1x+-13,&16x+-81\\\\1x+2,&0\\\\1x^{2}+-6x+17,&-23x+-14\\\\\\end{array}}}}"}]}
{"messages": [{"role": "user", "content": "Find an approximating polynomial of known degree for a given data.\n\nExample:\nFor input data:\n\n```\nx = {0,  1,  2,  3,  4,  5,  6,   7,   8,   9,   10};\ny = {1,  6,  17, 34, 57, 86, 121, 162, 209, 262, 321};\n\n```\n\nThe approximating polynomial is:\n\n```\n3 x2 + 2 x + 1\n\n```\n\nHere, the polynomial's coefficients are (3, 2, 1).\n\nThis task is intended as a subtask for Measure relative performance of sorting algorithms implementations."}, {"role": "assistant", "content": "(formerly Perl 6)\nWe'll use a Clifford algebra library. Very slow.\n\nRationale (in French for some reason):\n\nLe système d'équations peut s'écrire :\n\n(\n\na\n+\nb\n\nx\n\ni\n+\nc\n\nx\n\ni\n\n2\n=\n\ny\n\ni\n)\n\ni\n=\n1\n…\nN\n{\\displaystyle {\\displaystyle \\left(a+bx\\_{i}+cx\\_{i}^{2}=y\\_{i}\\right)\\_{i=1\\ldots N}}}\n, où on cherche \n\n(\na\n,\nb\n,\nc\n)\n∈\n\n\nR\n\n3\n{\\displaystyle {\\displaystyle (a,b,c)\\in \\mathbb {R} ^{3}}}\n. On considère \n\nR\n\nN\n{\\displaystyle {\\displaystyle \\mathbb {R} ^{N}}}\n et on répartit chaque équation sur chaque dimension:\n\n(\na\n+\nb\n\nx\n\ni\n+\nc\n\nx\n\ni\n\n2\n)\n\n\ne\n\ni\n=\n\ny\n\ni\n\n\ne\n\ni\n{\\displaystyle {\\displaystyle (a+bx\\_{i}+cx\\_{i}^{2})\\mathbf {e} \\_{i}=y\\_{i}\\mathbf {e} \\_{i}}}\n\nPosons alors :\n\nx\n\n0\n=\n\n∑\n\ni\n=\n1\n\nN\n\n\ne\n\ni\n,\n\nx\n\n1\n=\n\n∑\n\ni\n=\n1\n\nN\n\nx\n\ni\n\n\ne\n\ni\n,\n\nx\n\n2\n=\n\n∑\n\ni\n=\n1\n\nN\n\nx\n\ni\n\n2\n\n\ne\n\ni\n,\n\n\ny\n=\n\n∑\n\ni\n=\n1\n\nN\n\ny\n\ni\n\n\ne\n\ni\n{\\displaystyle {\\displaystyle \\mathbf {x} \\_{0}=\\sum \\_{i=1}^{N}\\mathbf {e} \\_{i},\\,\\mathbf {x} \\_{1}=\\sum \\_{i=1}^{N}x\\_{i}\\mathbf {e} \\_{i},\\,\\mathbf {x} \\_{2}=\\sum \\_{i=1}^{N}x\\_{i}^{2}\\mathbf {e} \\_{i},\\,\\mathbf {y} =\\sum \\_{i=1}^{N}y\\_{i}\\mathbf {e} \\_{i}}}\n\nLe système d'équations devient : \n\na\n\n\nx\n\n0\n+\nb\n\n\nx\n\n1\n+\nc\n\n\nx\n\n2\n=\n\ny\n{\\displaystyle {\\displaystyle a\\mathbf {x} \\_{0}+b\\mathbf {x} \\_{1}+c\\mathbf {x} \\_{2}=\\mathbf {y} }}\n.\n\nD'où :\n\na\n=\n\ny\n∧\n\n\nx\n\n1\n∧\n\n\nx\n\n2\n\n/\n(\n\n\nx\n\n0\n∧\n\n\nx\n\n1\n∧\n\n\nx\n\n2\n)\n\n\nb\n=\n\ny\n∧\n\n\nx\n\n2\n∧\n\n\nx\n\n0\n\n/\n(\n\n\nx\n\n1\n∧\n\n\nx\n\n2\n∧\n\n\nx\n\n0\n)\n\n\nc\n=\n\ny\n∧\n\n\nx\n\n0\n∧\n\n\nx\n\n1\n\n/\n(\n\n\nx\n\n2\n∧\n\n\nx\n\n0\n∧\n\n\nx\n\n1\n)\n{\\displaystyle {\\displaystyle {\\begin{aligned}a=\\mathbf {y} \\land \\mathbf {x} \\_{1}\\land \\mathbf {x} \\_{2}/(\\mathbf {x} \\_{0}\\land \\mathbf {x\\_{1}} \\land \\mathbf {x\\_{2}} )\\\\b=\\mathbf {y} \\land \\mathbf {x} \\_{2}\\land \\mathbf {x} \\_{0}/(\\mathbf {x} \\_{1}\\land \\mathbf {x\\_{2}} \\land \\mathbf {x\\_{0}} )\\\\c=\\mathbf {y} \\land \\mathbf {x} \\_{0}\\land \\mathbf {x} \\_{1}/(\\mathbf {x} \\_{2}\\land \\mathbf {x\\_{0}} \\land \\mathbf {x\\_{1}} )\\\\\\end{aligned}}}}\n\n```\nuse MultiVector;\n\nconstant @x1 = <0 1 2 3 4 5 6 7 8 9 10>;\nconstant @y = <1 6 17 34 57 86 121 162 209 262 321>;\n\nconstant $x0 = [+] @e[^@x1];\nconstant $x1 = [+] @x1 Z* @e;\nconstant $x2 = [+] @x1 »**» 2  Z* @e;\n\nconstant $y  = [+] @y Z* @e;\n\n.say for\n  $y∧$x1∧$x2/($x0∧$x1∧$x2),\n  $y∧$x2∧$x0/($x1∧$x2∧$x0),\n  $y∧$x0∧$x1/($x2∧$x0∧$x1);\n\n```\n\nOutput:\n\n```\n1\n2\n3\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Synthetic division. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\n:   In algebra, polynomial synthetic division is an algorithm for dividing a polynomial by another polynomial of the same or lower degree in an efficient way using a trick involving clever manipulations of coefficients, which results in a lower time complexity than polynomial long division."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n**Works with**: Rakudo version 2018.09\n\n```\nsub synthetic-division ( @numerator, @denominator ) {\n    my @result = @numerator;\n    my $end    = @denominator.end;\n\n    for ^(@numerator-$end) -> $i {\n        @result[$i]    /= @denominator[0];\n        @result[$i+$_] -= @denominator[$_] * @result[$i] for 1..$end;\n    }\n\n    'quotient' => @result[0 ..^ *-$end],\n    'remainder' => @result[*-$end .. *];\n}\n\nmy @tests =\n[1, -12, 0, -42], [1, -3],\n[1, 0, 0, 0, -2], [1, 1, 1, 1];\n\nfor @tests -> @n, @d {\n    my %result = synthetic-division( @n, @d );\n    say \"[{@n}] / [{@d}] = [%result<quotient>], remainder [%result<remainder>]\";\n}\n\n```\n\nOutput:\n\n```\n[1 -12 0 -42] / [1 -3] = [1 -9 -27], remainder [-123] \n[1 0 0 0 -2] / [1 1 1 1] = [1 -1], remainder [0 0 -1] \n\n```"}]}
{"messages": [{"role": "user", "content": "A Polyspiral is a spiral made of multiple line segments, whereby each segment is larger (or smaller) than the previous one by a given amount. Each segment also changes direction at a given angle.\n\nTask\n\nAnimate a series of polyspirals, by drawing a complete spiral then incrementing the angle, and (after clearing the background) drawing the next, and so on. Every spiral will be a frame of the animation. The animation may stop as it goes full circle or continue indefinitely. The given input values may be varied.\n\nIf animation is not practical in your programming environment, you may show a single frame instead.\n\nPseudo code\n\n```\n    set incr to 0.0\n\n    // animation loop\n    WHILE true \n\n        incr = (incr + 0.05) MOD 360\n        x = width / 2\n        y = height / 2\n        length = 5\n        angle = incr\n\n        // spiral loop\n        FOR 1 TO 150\n            drawline\n            change direction by angle\n            length = length + 3\n            angle = (angle + incr) MOD 360\n        ENDFOR\n    \n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\n### SVG \"pseudo-animation\"\n\nSort of an ersatz animation. Write updates to a svg file, most modern viewers will update as the content changes.\n\n```\nuse SVG;\nmy $w = 600;\nmy $h = 600;\n\nfor 3..33  -> $a {\n    my $angle = $a/τ;\n    my $x1 = $w/2;\n    my $y1 = $h/2;\n    my @lines;\n\n    for 1..144 {\n        my $length = 3 * $_;\n        my ($x2, $y2) = ($x1, $y1) «+« |cis($angle * $_).reals».round(.01) »*» $length ;\n        @lines.push: 'line' => [:x1($x1.clone), :y1($y1.clone), :x2($x2.clone), :y2($y2.clone),\n                                :style(\"stroke:rgb({hsv2rgb(($_*5 % 360)/360,1,1).join: ','})\")];\n        ($x1, $y1) = $x2, $y2;\n    }\n\n    my $fname = \"./polyspiral-perl6.svg\".IO.open(:w);\n    $fname.say( SVG.serialize(\n        svg => [\n            width => $w, height => $h, style => 'stroke:rgb(0,0,0)',\n            :rect[:width<100%>, :height<100%>, :fill<black>],\n            |@lines,\n        ],)\n    );\n    $fname.close;\n    sleep .15;\n}\n\nsub hsv2rgb ( $h, $s, $v ){ # inputs normalized 0-1\n    my $c = $v * $s;\n    my $x = $c * (1 - abs( (($h*6) % 2) - 1 ) );\n    my $m = $v - $c;\n    my ($r, $g, $b) = do given $h {\n        when   0..^(1/6) { $c, $x, 0 }\n        when 1/6..^(1/3) { $x, $c, 0 }\n        when 1/3..^(1/2) { 0, $c, $x }\n        when 1/2..^(2/3) { 0, $x, $c }\n        when 2/3..^(5/6) { $x, 0, $c }\n        when 5/6..1      { $c, 0, $x }\n    }\n    ( $r, $g, $b ).map: ((*+$m) * 255).Int\n}\n\n```\n\nOutput:\n\nSee polyspiral-perl6.gif (offsite animated gif image)\n\n### SDL full animation\n\nUses the same basic algorithm but fully animated. Use the up / down arrow keys to speed up / slow down the update speed. Use PgUp / PgDn keys to increment / decrement animation speed by large amounts. Use left / right arrow keys to reverse the \"direction\" of angle change. Press Space bar to toggle animation / reset to minimum speed. Left Control key to toggle stationary / rotating center. Use + / - keys to add remove line segments.\n\n```\nuse SDL2::Raw;\n\nmy $width  = 900;\nmy $height = 900;\n\nSDL_Init(VIDEO);\n\nmy $window = SDL_CreateWindow(\n    'Polyspiral',\n    SDL_WINDOWPOS_CENTERED_MASK,\n    SDL_WINDOWPOS_CENTERED_MASK,\n    $width, $height,\n    RESIZABLE\n);\n\nmy $render = SDL_CreateRenderer($window, -1, ACCELERATED +| PRESENTVSYNC);\n\nmy $event = SDL_Event.new;\n\nenum KEY_CODES (\n    K_UP     => 82,\n    K_DOWN   => 81,\n    K_LEFT   => 80,\n    K_RIGHT  => 79,\n    K_SPACE  => 44,\n    K_PGUP   => 75,\n    K_PGDN   => 78,\n    K_LCTRL  => 224,\n    K_PLUS   => 87,\n    K_MINUS  => 86,\n    K_SPLUS  => 46,\n    K_SMINUS => 45,\n);\n\nmy $angle = 0;\nmy $lines = 240;\nmy @rgb = palette($lines);\nmy ($x1, $y1);\nmy $dir = 1;\nmy $rot = 0;\nmy $incr = .0001/π;\nmy $step = $incr*70;\n\nmain: loop {\n    while SDL_PollEvent($event) {\n        my $casted_event = SDL_CastEvent($event);\n        given $casted_event {\n            when *.type == QUIT { last main }\n            when *.type == KEYDOWN {\n                if KEY_CODES(.scancode) -> $comm {\n                    given $comm {\n                        when 'K_LEFT'   { $dir = $rot ??  1 !! -1 }\n                        when 'K_RIGHT'  { $dir = $rot ?? -1 !!  1 }\n                        when 'K_UP'     { $step += $incr }\n                        when 'K_DOWN'   { $step -= $incr if $step > $incr }\n                        when 'K_PGUP'   { $step += $incr*50 }\n                        when 'K_PGDN'   { $step -= $incr*50; $step = $step < $incr ?? $incr !! $step }\n                        when 'K_SPACE'  { $step = $step ?? 0 !! $incr }\n                        when 'K_LCTRL'  { $rot  = $rot  ?? 0 !! -1; $dir *= -1 }\n                        when 'K_PLUS'   { $lines = ($lines + 5) min 360; @rgb = palette($lines) }\n                        when 'K_SPLUS'  { $lines = ($lines + 5) min 360; @rgb = palette($lines) }\n                        when 'K_MINUS'  { $lines = ($lines - 5) max 60;  @rgb = palette($lines) }\n                        when 'K_SMINUS' { $lines = ($lines - 5) max 60;  @rgb = palette($lines) }\n                    }\n                }\n                #say .scancode; # unknown key pressed\n            }\n            when *.type == WINDOWEVENT {\n                if .event == 5 {\n                    $width  = .data1;\n                    $height = .data2;\n                }\n            }\n        }\n    }\n\n    $angle = ($angle + $dir * $step) % τ;\n    ($x1, $y1) = $width div 2, $height div 2;\n    my $dim = $width min $height;\n    my $scale = (2 + .33 * abs(π - $angle)) * $dim / $lines;\n    $scale *= ($angle > π) ?? (1 - $angle/τ) !! $angle/τ;\n    $scale max= $dim/$lines/$lines;\n    for ^$lines {\n        my $length = $scale + $scale * $_;\n        my ($x2, $y2) = ($x1, $y1) «+« cis(($angle * $rot * $lines) + $angle * $_).reals »*» $length;\n        SDL_SetRenderDrawColor($render, |@rgb[$_], 255);\n        SDL_RenderDrawLine($render, |($x1, $y1, $x2, $y2)».round(1));\n        ($x1, $y1) = $x2, $y2;\n    }\n    @rgb.=rotate($lines/60);\n    SDL_RenderPresent($render);\n    SDL_SetRenderDrawColor($render, 0, 0, 0, 0);\n    SDL_RenderClear($render);\n}\n\nSDL_Quit();\n\nsub palette ($l) { (^$l).map: { hsv2rgb(($_ * 360/$l % 360)/360, 1, 1).list } };\n\nsub hsv2rgb ( $h, $s, $v ){ # inputs normalized 0-1\n    my $c = $v * $s;\n    my $x = $c * (1 - abs( (($h*6) % 2) - 1 ) );\n    my $m = $v - $c;\n    my ($r, $g, $b) = do given $h {\n        when   0..^(1/6) { $c, $x, 0 }\n        when 1/6..^(1/3) { $x, $c, 0 }\n        when 1/3..^(1/2) { 0, $c, $x }\n        when 1/2..^(2/3) { 0, $x, $c }\n        when 2/3..^(5/6) { $x, 0, $c }\n        when 5/6..1      { $c, 0, $x }\n    }\n    ( $r, $g, $b ).map: ((*+$m) * 255).Int\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "The   *population count*   is the number of   **1**s   (ones)   in the binary representation of a non-negative integer.\n\n*Population count*   is also known as:\n\n:   :   :   :   * *pop count*\n                * *popcount*\n                * *sideways sum*\n                * *bit summation*\n                * *Hamming weight*\n\nFor example,   **5**   (which is   **101**   in binary)   has a population count of   **2**.\n\n*Evil numbers*   are non-negative integers that have an   *even*   population count.\n\n*Odious numbers*     are  positive integers that have an    *odd*   population count.\n\nTask\n\n* write a function (or routine) to return the population count of a non-negative integer.\n* all computation of the lists below should start with   **0**   (zero indexed).\n\n:   * display the   *pop count*   of the   1st   thirty powers of   **3**       (**30**,   **31**,   **32**,   **33**,   **34**,   **∙∙∙**   **329**).\n    * display the   1st   thirty     *evil*     numbers.\n    * display the   1st   thirty   *odious*   numbers.\n\n* display each list of integers on one line   (which may or may not include a title),   each set of integers being shown should be properly identified.\n\nSee also\n\n* The On-Line Encyclopedia of Integer Sequences:   A000120 population count.\n* The On-Line Encyclopedia of Integer Sequences:   A000069 odious numbers.\n* The On-Line Encyclopedia of Integer Sequences:   A001969 evil numbers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub population-count(Int $n where * >= 0) { [+] $n.base(2).comb }\n\nsay map &population-count, 3 «**« ^30;\nsay \"Evil: \", (grep { population-count($_) %% 2 }, 0 .. *)[^30];\nsay \"Odious: \", (grep { population-count($_)  % 2 }, 0 .. *)[^30];\n\n```\n\nOutput:\n\n```\n1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25\nEvil: 0 3 5 6 9 10 12 15 17 18 20 23 24 27 29 30 33 34 36 39 40 43 45 46 48 51 53 54 57 58\nOdious: 1 2 4 7 8 11 13 14 16 19 21 22 25 26 28 31 32 35 37 38 41 42 44 47 49 50 52 55 56 59\n```\n\nThat's the convenient way to write it, but the following avoids string processing and is therefore about twice as fast:\n\n```\nsub population-count(Int $n is copy where * >= 0) { \n    loop (my $c = 0; $n; $n +>= 1) { \n        $c += $n +& 1; \n    } \n    $c;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "**Posit** is a quantization of the real projective line proposed by John Gustafson in 2015. It is claimed to be an improvement over IEEE 754.\n\nThe purpose of this task is to write a program capable of decoding a posit number. You will use the example provided by Gustafson in his paper : 0b0000110111011101, representing a 16-bit long real number with three bits for the exponent. Once decoded, you should obtain either the fraction 477/134217728 or the floating point value 3.55393E−6.\n\nJeff Johnson from Facebook research, described posit numbers as such:\n\n:   A more efficient representation for tapered floating points is the recent *posit* format by Gustafson. It has no explicit size field; the exponent is encoded using a Golomb-Rice prefix-free code, with the exponent \n\n    e\n    {\\displaystyle {\\displaystyle e}}\n     encoded as a Golomb-Rice quotient and remainder \n\n    (\n    q\n    ,\n    r\n    )\n    {\\displaystyle {\\displaystyle (q,r)}}\n     with \n\n    q\n    {\\displaystyle {\\displaystyle q}}\n     in unary and \n\n    r\n    {\\displaystyle {\\displaystyle r}}\n     in binary (in posit terminology, \n\n    q\n    {\\displaystyle {\\displaystyle q}}\n     is the *regime*). Remainder encoding size is defined by the *exponent scale* \n\n    s\n    {\\displaystyle {\\displaystyle s}}\n    , where \n\n    2\n\n    s\n    {\\displaystyle {\\displaystyle 2^{s}}}\n     is the Golomb-Rice divisor. Any space not used by the exponent encoding is used by the significand, which unlike IEEE 754 always has a leading 1; gradual underflow (and overflow) is handled by tapering. A posit number system is characterized by \n\n    (\n    N\n    ,\n    s\n    )\n    {\\displaystyle {\\displaystyle (N,s)}}\n    , where \n\n    N\n    {\\displaystyle {\\displaystyle N}}\n     is the word length in bits and \n\n    s\n    {\\displaystyle {\\displaystyle s}}\n     is the exponent scale. The minimum and maximum positive finite numbers in \n\n    (\n    N\n    ,\n    s\n    )\n    {\\displaystyle {\\displaystyle (N,s)}}\n     are **Failed to parse (syntax error): {\\displaystyle f\\_\\mathrm{min} = 2^{−(N−2)2^s}}**\n    and **Failed to parse (syntax error): {\\displaystyle f\\_\\mathrm{max} = 2^{(N−2)2^s}}**\n    . The number line is represented much as the projective reals, with a single point at \n\n    ±\n    ∞\n    {\\displaystyle {\\displaystyle \\pm \\infty }}\n     bounding **Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response (\"Math extension cannot connect to Restbase.\") from server \"https://wikimedia.org/api/rest\\_v1/\":): {\\displaystyle −f\\_\\mathrm{max}}**\n    and \n\n    f\n\n\n    m\n    a\n    x\n    {\\displaystyle {\\displaystyle f\\_{\\mathrm {max} }}}\n    . \n\n    ±\n    ∞\n    {\\displaystyle {\\displaystyle \\pm \\infty }}\n     and 0 have special encodings; there is no NaN. The number system allows any choice of \n\n    N\n    ≥\n    3\n    {\\displaystyle {\\displaystyle N\\geq 3}}\n     and **Failed to parse (syntax error): {\\displaystyle 0\\le s\\le N − 3}**\n    .\n:   s\n    {\\displaystyle {\\displaystyle s}}\n     controls the dynamic range achievable; e.g., 8-bit (8, 5)-posit \n\n    f\n\n\n    m\n    a\n    x\n    =\n\n    2\n\n    192\n    {\\displaystyle {\\displaystyle f\\_{\\mathrm {max} }=2^{192}}}\n     is larger than \n\n    f\n\n\n    m\n    a\n    x\n    {\\displaystyle {\\displaystyle f\\_{\\mathrm {max} }}}\n     in float32. (8, 0) and (8, 1) are more reasonable values to choose for 8-bit floating point representations, with \n\n    f\n\n\n    m\n    a\n    x\n    {\\displaystyle {\\displaystyle f\\_{\\mathrm {max} }}}\n     of 64 and 4096 accordingly. Precision is maximized in the range **Failed to parse (syntax error): {\\displaystyle \\pm\\left[2^{−(s+1)}, 2^{s+1}\\right)}**\n    with **Failed to parse (syntax error): {\\displaystyle N − 3 − s}**\n    significand fraction bits, tapering to no fraction bits at \n\n    ±\n\n    f\n\n\n    m\n    a\n    x\n    {\\displaystyle {\\displaystyle \\pm f\\_{\\mathrm {max} }}}\n    .\n:   — Jeff Johnson, *Rethinking floating point for deep learning*, Facebook research."}, {"role": "assistant", "content": "**Translation of**: Mathematica\n\n```\n=begin LICENSE\nCopyright © 2017 John L. Gustafson\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sub-license, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThis copyright and permission notice shall be included in all copies or substantial portions of the software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT\nLIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\nNO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY,\nWHETHER IN AN ACTION OR CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n=end LICENSE\n\nconstant nbits = 16;\nconstant es    = 3;\nconstant npat  = 2**nbits;\nconstant useed = 2**2**es;\nconstant minpos = useed**(-nbits + 2);\nconstant maxpos = useed**(+nbits - 2);\nconstant qsize  = 2**((nbits-2)*2**(es+2)+5).log2.ceiling;\nconstant qextra = qsize - (nbits - 2)*2**(es+2);\n\nconstant posit-range = 0..^2**nbits;\n\nsub twoscomp($sign, $p) { ($sign > 0 ?? $p !! npat - $p) mod npat } \n\nsub sign-bit(UInt $p where posit-range) { +$p.polymod(2 xx nbits - 1).tail }\nsub regime-bits(UInt $p where posit-range) {\n  my $q = twoscomp(1 - sign-bit($p), $p);\n  my @bits = $q.polymod(2 xx nbits - 1).reverse;\n  my $bit2 = @bits[1];\n  my @temp-bits = flat @bits[1..*], 1 - $bit2;\n  my $npower = @temp-bits.first(1 - $bit2, :k) - 1;\n  @bits[1..($npower+1)];\n}\nsub regime-value(@bits) { @bits.head ?? @bits.elems - 1 !! -@bits; }\nsub exponent-bits(UInt $p where posit-range) {\n  my $q = twoscomp(1 - sign-bit($p), $p);\n  my $startbit = regime-bits($q).elems + 3;\n  my @bits = $q.polymod(2 xx nbits - 1).reverse;\n  @bits[$startbit-1 .. $startbit-1 + es - 1]\n}\nsub fraction-bits(UInt $p where posit-range) {\n  my $q = twoscomp(1 - sign-bit($p), $p);\n  my $startbit = regime-bits($q).elems + 3 + es;\n  my @bits = $q.polymod(2 xx nbits - 1).reverse;\n  @bits[$startbit-1 .. *];\n}\n\nsub p2x(UInt $p where posit-range) {\n  my $s = (-1)**sign-bit($p);\n  my $k = regime-value regime-bits $p;\n  my @e = exponent-bits $p;\n  my @f = fraction-bits $p;\n  @e.push: 0 until @e == es;\n  my $e = @e.reduce: 2 * * + *;\n  my $f = @f == 0 ?? 1 !! 1.FatRat + @f.reduce(2 * * + *)/2**@f;\n  given $p {\n    when 0          { 0   }\n    when npat div 2 { Inf }\n    default         { $s * useed**$k * 2**$e * $f }\n  }\n}\n\ndd p2x 0b0000110111011101;\n\n```\n\nOutput:\n\n```\nFatRat.new(477, 134217728)\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Encode pi as a 8-bit posit with a 2-bit exponent.\n\nAs an unsigned integer, the result should be 77."}, {"role": "assistant", "content": "**Translation of**: Mathematica\n\n```\n=begin LICENSE\nCopyright © 2017 John L . Gustafson\n\nPermission is hereby granted, free of charge to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction including without limitation the rights to use copy, modify, merge, publish, distribute, sub - license, and/or sell copies of the Software and to permit persons to whom the Software is furnished to do so, subject to the following conditions :\n   \nThis copyright and permission notice shall be included in all copies or substantial portions of the software .\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT . IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OR CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE .\n=end LICENSE\n\n# L<https://posithub.org/docs/Posits4.pdf>\nconstant nbits = 8;\nconstant es    = 2;\nconstant npat  = 2**nbits;\nconstant useed = 2**2**es;\nconstant minpos = useed**(-nbits + 2);\nconstant maxpos = useed**(+nbits - 2);\nconstant qsize  = 2**((nbits-2)*2**(es+2)+5).log2.ceiling;\nconstant qextra = qsize - (nbits - 2)*2**(es+2);\n\nconstant posit-range = ^npat;\nsubset posit of UInt where posit-range;\n\nsub x2p(Real $x --> posit) {\n\n  # first, take care of the two exceptional values\n  return 0 if $x == 0;\n  return npat div 2 if $x == Inf;\n\n  # working variables\n  my ($i, $p, $e, $y) = $, $, 2**(es - 1), $x.abs;\n\n\n  if $y ≥ 1 { # north-east quadrant\n    ($p, $i) = 1, 2;\n    # Shift in 1s from the right and scale down.\n    ($p, $y, $i) = 2*$p+1, $y/useed, $i+1 while $y ≥ useed && $i ≤ nbits; \n    $p *= 2; $i++;\n  } else { # south-east quadrant\n    ($p, $i) = 0, 1;\n    # Shift in 0 s from the right and scale up.\n    ($y, $i) = $y*useed, $i+1 while $y < 1 && $i ≤ nbits;\n    if $i ≥ nbits {\n      $p = 2; $i = nbits + 1;\n    } else { $p = 1; $i++; }\n  }\n  # Extract exponent bits:\n  while $e > 1/2 and $i ≤ nbits {\n    $p *= 2;\n    if $y ≥ 2**$e { $y /= 2**$e; $p++ }\n    $e /= 2;\n    $i++;\n  }\n  $y--;\n  # Fraction bits; substract the hidden bit\n  while $y > 0 and $i ≤ nbits {\n    $y *= 2;\n    $p = 2*$p + $y.floor;\n    $y -= $y.floor;\n    $i++\n  }\n  $p *= 2**(nbits+1-$i);\n  $i++;\n\n  # Round to nearest; tie goes to even\n  $i = $p +& 1;\n  $p = ($p/2).floor;\n  $p = $i == 0 ?? $p !!\n       $y == 0|1 ?? $p + $p+&1 !!\n       $p + 1;\n\n  # Simulate 2's complement\n  ($x < 0 ?? npat - $p !! $p) mod npat;\n\n}\n\nsay x2p pi;\n\n```\n\nOutput:\n\n```\n77\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind positive decimal integers   **n**   in which the digit   **1**   occurs exactly twice,   where   **n   <   1,000**."}, {"role": "assistant", "content": "```\nsay display 10, '%3d', ^1000 .grep: { .comb.Bag{'1'} == 2 };\n\nsub display {\n    cache $^c;\n    \"{+$c} matching:\\n\" ~ $c.batch($^a)».fmt($^b).join: \"\\n\"\n}\n\n```\n\nYields:\n\n```\n27 matching:\n 11 101 110 112 113 114 115 116 117 118\n119 121 131 141 151 161 171 181 191 211\n311 411 511 611 711 811 911\n```"}]}
{"messages": [{"role": "user", "content": "A   set   is a collection (container) of certain values,\nwithout any particular order, and no repeated values.\n\nIt corresponds with a finite set in mathematics.\n\nA set can be implemented as an associative array (partial mapping)\nin which the value of each key-value pair is ignored.\n\nGiven a set S, the power set (or powerset) of S, written P(S), or 2S, is the set of all subsets of S.\n\nTask\n\nBy using a library or built-in set type, or by defining a set type with necessary operations, write a function with a set S as input that yields the power set 2S of S.\n\nFor example, the power set of     {1,2,3,4}     is\n\n:   :   :   {{}, {1}, {2}, {1,2}, {3}, {1,3}, {2,3}, {1,2,3}, {4}, {1,4}, {2,4}, {1,2,4}, {3,4}, {1,3,4}, {2,3,4}, {1,2,3,4}}.\n\nFor a set which contains n elements, the corresponding power set has 2n elements, including the edge cases of empty set.\n\nThe power set of the empty set is the set which contains itself (20 = 1):\n\n:   :   :   P\n            {\\displaystyle {\\displaystyle {\\mathcal {P}}}}\n            (\n\n            ∅\n            {\\displaystyle {\\displaystyle \\varnothing }}\n            ) = { \n\n            ∅\n            {\\displaystyle {\\displaystyle \\varnothing }}\n             }\n\nAnd the power set of the set which contains only the empty set, has two subsets, the empty set and the set which contains the empty set (21 = 2):\n\n:   :   :   P\n            {\\displaystyle {\\displaystyle {\\mathcal {P}}}}\n            ({\n\n            ∅\n            {\\displaystyle {\\displaystyle \\varnothing }}\n            }) = { \n\n            ∅\n            {\\displaystyle {\\displaystyle \\varnothing }}\n            , { \n\n            ∅\n            {\\displaystyle {\\displaystyle \\varnothing }}\n             } }\n\n**Extra credit:**  Demonstrate that your language supports these last two powersets."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2014-02-25\n\n```\nsub powerset(Set $s) { $s.combinations.map(*.Set).Set }\nsay powerset set <a b c d>;\n```\n\nOutput:\n\n```\nset(set(), set(a), set(b), set(c), set(d), set(a, b), set(a, c), set(a, d), set(b, c), set(b, d), set(c, d), set(a, b, c), set(a, b, d), set(a, c, d), set(b, c, d), set(a, b, c, d))\n```\n\nIf you don't care about the actual Set type, the .combinations method by itself may be good enough for you:\n\n```\n.say for <a b c d>.combinations\n```\n\nOutput:\n\n```\n \na\nb\nc\nd\na b\na c\na d\nb c\nb d\nc d\na b c\na b d\na c d\nb c d\na b c d\n```"}]}
{"messages": [{"role": "user", "content": "A **k**-powerful (or **k**-full) number is a positive integer **n** such that for every prime number **p** dividing **n**, **p^k** also divides **n**.\n\nThese are numbers of the form:\n\n```\n  2-powerful = a^2 * b^3,             for a,b >= 1\n  3-powerful = a^3 * b^4 * c^5,       for a,b,c >= 1\n  4-powerful = a^4 * b^5 * c^6 * d^7, for a,b,c,d >= 1\n  ...\n  k-powerful = a^k * b^(k+1) * c^(k+2) *...* ω^(2*k-1), for a,b,c,...,ω >= 1\n\n```\n\nTask\n\nWrite a function that generates all the **k**-powerful numbers less than or equal to **n**.\n\n* For **k = 2..10**, generate the set of **k**-powerful numbers **<= 10^k** and show the first **5** and the last **5** terms, along with the length of the set.\n\nWrite a function that counts the number of **k**-powerful numbers less than or equal to **n**. (optional)\n\n* For **k = 2..10**, show the number of **k**-powerful numbers less than or equal to **10^j**, for **0 <= j < k+10**.\n\nSee also\n\n* Wikipedia, Powerful number\n\n* OEIS A001694: 2-powerful numbers\n\n* OEIS A036966: 3-powerful numbers\n\n* OEIS A036967: 4-powerful numbers\n\n* OEIS A069492: 5-powerful numbers\n\n* OEIS A069493: 6-powerful numbers\n\n* OEIS A062762: number of powerful numbers <= 2^n\n\n* OEIS A118896: number of powerful numbers <= 10^n"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.01\n\n**Translation of**: Perl\n\nRaku has no handy pre-made nth integer root routine so has the same problem as Go with needing a slight \"fudge factor\" in the nth root calculation.\n\n```\nsub super (\\x) { x.trans([<0123456789>.comb] => [<⁰¹²³⁴⁵⁶⁷⁸⁹>.comb]) }\n\nsub is-square-free (Int \\n) {\n    constant @p = ^100 .map: { next unless .is-prime; .² };\n    for @p -> \\p { return False if n %% p }\n    True\n}\n\nsub powerfuls (\\n, \\k, \\enumerate = False) {\n    my @powerful;\n    p(1, 2*k - 1);\n    sub p (\\m, \\r) {\n        if r < k {\n            enumerate ?? @powerful.push(m) !! ++@powerful[m - 1  ?? (m - 1).chars !! 0];\n            return\n        }\n        for 1 .. ((n / m) ** (1/r) + .0001).Int -> \\v {\n            if r > k {\n                next unless is-square-free(v);\n                next unless m gcd v == 1;\n            }\n            p(m * v ** r, r - 1)\n        }\n    }\n    @powerful;\n}\n\nput \"Count and first and last five enumerated n-powerful numbers in 10ⁿ:\";\nfor 2..10 -> \\k {\n    my @powerful = sort powerfuls(10**k, k, True);\n    printf \"%2d %2s-powerful numbers <= 10%-2s: %s ... %s\\n\", +@powerful, k, super(k),\n           @powerful.head(5).join(\", \"), @powerful.tail(5).join(\", \");\n}\n\nput \"\\nCounts in each order of magnitude:\";\nmy $top = 9;\nfor 2..10 -> \\k {\n    printf \"%2s-powerful numbers <= 10ⁿ (where 0 <= n <= %d): \", k, $top+k;\n    quietly say join ', ', [\\+] powerfuls(10**($top + k), k);\n}\n\n```\n\nOutput:\n\n```\nCount and first and last five enumerated n-powerful numbers in 10ⁿ:\n14  2-powerful numbers <= 10² : 1, 4, 8, 9, 16 ... 49, 64, 72, 81, 100\n20  3-powerful numbers <= 10³ : 1, 8, 16, 27, 32 ... 625, 648, 729, 864, 1000\n25  4-powerful numbers <= 10⁴ : 1, 16, 32, 64, 81 ... 5184, 6561, 7776, 8192, 10000\n32  5-powerful numbers <= 10⁵ : 1, 32, 64, 128, 243 ... 65536, 69984, 78125, 93312, 100000\n38  6-powerful numbers <= 10⁶ : 1, 64, 128, 256, 512 ... 559872, 746496, 823543, 839808, 1000000\n46  7-powerful numbers <= 10⁷ : 1, 128, 256, 512, 1024 ... 7558272, 8388608, 8957952, 9765625, 10000000\n52  8-powerful numbers <= 10⁸ : 1, 256, 512, 1024, 2048 ... 60466176, 67108864, 80621568, 90699264, 100000000\n59  9-powerful numbers <= 10⁹ : 1, 512, 1024, 2048, 4096 ... 644972544, 725594112, 816293376, 967458816, 1000000000\n68 10-powerful numbers <= 10¹⁰: 1, 1024, 2048, 4096, 8192 ... 7739670528, 8589934592, 8707129344, 9795520512, 10000000000\n\nCounts in each order of magnitude:\n 2-powerful numbers <= 10ⁿ (where 0 <= n <= 11): 1, 4, 14, 54, 185, 619, 2027, 6553, 21044, 67231, 214122, 680330\n 3-powerful numbers <= 10ⁿ (where 0 <= n <= 12): 1, 2, 7, 20, 51, 129, 307, 713, 1645, 3721, 8348, 18589, 41136\n 4-powerful numbers <= 10ⁿ (where 0 <= n <= 13): 1, 1, 5, 11, 25, 57, 117, 235, 464, 906, 1741, 3312, 6236, 11654\n 5-powerful numbers <= 10ⁿ (where 0 <= n <= 14): 1, 1, 3, 8, 16, 32, 63, 117, 211, 375, 659, 1153, 2000, 3402, 5770\n 6-powerful numbers <= 10ⁿ (where 0 <= n <= 15): 1, 1, 2, 6, 12, 21, 38, 70, 121, 206, 335, 551, 900, 1451, 2326, 3706\n 7-powerful numbers <= 10ⁿ (where 0 <= n <= 16): 1, 1, 1, 4, 10, 16, 26, 46, 77, 129, 204, 318, 495, 761, 1172, 1799, 2740\n 8-powerful numbers <= 10ⁿ (where 0 <= n <= 17): 1, 1, 1, 3, 8, 13, 19, 32, 52, 85, 135, 211, 315, 467, 689, 1016, 1496, 2191\n 9-powerful numbers <= 10ⁿ (where 0 <= n <= 18): 1, 1, 1, 2, 6, 11, 16, 24, 38, 59, 94, 145, 217, 317, 453, 644, 919, 1308, 1868\n10-powerful numbers <= 10ⁿ (where 0 <= n <= 19): 1, 1, 1, 1, 5, 9, 14, 21, 28, 43, 68, 104, 155, 227, 322, 447, 621, 858, 1192, 1651\n```"}]}
{"messages": [{"role": "user", "content": "A Practical number P has some selection of its proper divisors, (other than\nitself), that can be selected to sum to every integer less than itself.\n\nCompute all the proper divisors/factors of an input number X, then, using all selections from\nthe factors compute all possible sums of factors and see if all numbers from 1\nto X-1 can be created from it.\n\nTask\n\nWrite a function that given X returns a boolean value of whether X *is* a\nPractical number, (using the above method).\n\n* Show how many Practical numbers there are in the range 1..333, inclusive.\n* Show that the Practical numbers in the above range start and end in:\n\n:   1, 2, 4, 6, 8, 12, 16, 18, 20, 24 ... 288, 294, 300, 304, 306, 308, 312, 320, 324, 330\n\nStretch Goal\n\n* Show if 666 is a Practical number"}, {"role": "assistant", "content": "```\nuse Prime::Factor:ver<0.3.0+>;\n\nsub is-practical ($n) {\n   return True  if $n == 1;\n   return False if $n % 2;\n   my @proper = $n.&proper-divisors :sort;\n   return True if all( @proper.rotor(2 => -1).map: { .[0] / .[1] >= .5 } );\n   my @proper-sums = @proper.combinations».sum.unique.sort;\n   +@proper-sums < $n-1 ?? False !! @proper-sums[^$n] eqv (^$n).list ?? True !! False\n}\n\nsay \"{+$_} matching numbers:\\n{.batch(10)».fmt('%3d').join: \"\\n\"}\\n\"\n    given [ (1..333).hyper(:32batch).grep: { is-practical($_) } ];\n\nprintf \"%5s is practical? %s\\n\", $_, .&is-practical for 666, 6666, 66666, 672, 720;\n\n```\n\nOutput:\n\n```\n77 matching numbers:\n  1   2   4   6   8  12  16  18  20  24\n 28  30  32  36  40  42  48  54  56  60\n 64  66  72  78  80  84  88  90  96 100\n104 108 112 120 126 128 132 140 144 150\n156 160 162 168 176 180 192 196 198 200\n204 208 210 216 220 224 228 234 240 252\n256 260 264 270 272 276 280 288 294 300\n304 306 308 312 320 324 330\n\n  666 is practical? True\n 6666 is practical? True\n66666 is practical? False\n  672 is practical? True\n  720 is practical? True\n```"}]}
{"messages": [{"role": "user", "content": "Pragmatic directives cause the language to operate in a specific manner,   allowing support for operational variances within the program code   (possibly by the loading of specific or alternative modules).\n\nTask\n\nList any pragmatic directives supported by the language,   and demonstrate how to activate and deactivate the pragmatic directives and to describe or demonstrate the scope of effect that the pragmatic directives have within a program."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-10-20\n\nThe Perl 6 pragma mechanism is nearly identical to Perl 5's, piggybacking on the notation for importing modules (pragmas are distinguished by case from normal modules, which are generally of mixed case). By convention pragmas are lowercase, unless they are indicating the use of an unsafe feature, in which case they are in all caps.\n\n```\nuse MONKEY-TYPING;\naugment class Int {\n    method times (&what) { what() xx self }  # pretend like we're Ruby\n}\n\n```\n\nUnlike Perl 5, there is no use strict; pragma, however, since Perl 6 is strict by default. Importation of a pragma is lexically scoped as in Perl 5, but note that unlike in Perl 5, *all* importation is lexical in Perl 6, so pragmas are not special that way."}]}
{"messages": [{"role": "user", "content": "A friend of mine runs a pharmacy.   He has a specialized function in his Dispensary application which receives a decimal value of currency and replaces it to a standard value.   This value is regulated by a government department.\n\nTask\n\nGiven a floating point value between   0.00   and   1.00,   rescale according to the following table:\n\n```\n>=  0.00  <  0.06  :=  0.10\n>=  0.06  <  0.11  :=  0.18\n>=  0.11  <  0.16  :=  0.26\n>=  0.16  <  0.21  :=  0.32\n>=  0.21  <  0.26  :=  0.38\n>=  0.26  <  0.31  :=  0.44\n>=  0.31  <  0.36  :=  0.50\n>=  0.36  <  0.41  :=  0.54\n>=  0.41  <  0.46  :=  0.58\n>=  0.46  <  0.51  :=  0.62\n>=  0.51  <  0.56  :=  0.66\n>=  0.56  <  0.61  :=  0.70\n>=  0.61  <  0.66  :=  0.74\n>=  0.66  <  0.71  :=  0.78\n>=  0.71  <  0.76  :=  0.82\n>=  0.76  <  0.81  :=  0.86\n>=  0.81  <  0.86  :=  0.90\n>=  0.86  <  0.91  :=  0.94\n>=  0.91  <  0.96  :=  0.98\n>=  0.96  <  1.01  :=  1.00\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nSimple solution, doing a linear search.  \nNote that in Raku we don't have to worry about floating-point misrepresentations of decimals, because decimal fractions are stored as rationals.\n\n**Works with**: rakudo version 2016.07\n\n```\nsub price-fraction ($n where 0..1) {\n    when $n < 0.06 { 0.10 }\n    when $n < 0.11 { 0.18 }\n    when $n < 0.16 { 0.26 }\n    when $n < 0.21 { 0.32 }\n    when $n < 0.26 { 0.38 }\n    when $n < 0.31 { 0.44 }\n    when $n < 0.36 { 0.50 }\n    when $n < 0.41 { 0.54 }\n    when $n < 0.46 { 0.58 }\n    when $n < 0.51 { 0.62 }\n    when $n < 0.56 { 0.66 }\n    when $n < 0.61 { 0.70 }\n    when $n < 0.66 { 0.74 }\n    when $n < 0.71 { 0.78 }\n    when $n < 0.76 { 0.82 }\n    when $n < 0.81 { 0.86 }\n    when $n < 0.86 { 0.90 }\n    when $n < 0.91 { 0.94 }\n    when $n < 0.96 { 0.98 }\n    default        { 1.00 }\n}\n\nwhile prompt(\"value: \") -> $value {\n    say price-fraction(+$value);\n}\n\n```\n\nIf we expect to rescale many prices, a better approach would be to build a look-up array of 101 entries.\nMemory is cheap, and array indexing is blazing fast.\n\n```\nmy @price = map *.value, flat\n    ( 0 ..^ 6  X=> 0.10),\n    ( 6 ..^ 11 X=> 0.18),\n    (11 ..^ 16 X=> 0.26),\n    (16 ..^ 21 X=> 0.32),\n    (21 ..^ 26 X=> 0.38),\n    (26 ..^ 31 X=> 0.44),\n    (31 ..^ 36 X=> 0.50),\n    (36 ..^ 41 X=> 0.54),\n    (41 ..^ 46 X=> 0.58),\n    (46 ..^ 51 X=> 0.62),\n    (51 ..^ 56 X=> 0.66),\n    (56 ..^ 61 X=> 0.70),\n    (61 ..^ 66 X=> 0.74),\n    (66 ..^ 71 X=> 0.78),\n    (71 ..^ 76 X=> 0.82),\n    (76 ..^ 81 X=> 0.86),\n    (81 ..^ 86 X=> 0.90),\n    (86 ..^ 91 X=> 0.94),\n    (91 ..^ 96 X=> 0.98),\n    (96 ..^101 X=> 1.00),\n;\n\nwhile prompt(\"value: \") -> $value {\n    say @price[$value * 100] // \"Out of range\";\n}\n\n```\n\nWe can also build this same look-up array by parsing the table as formatted in the task description:\n\n**Works with**: rakudo version 2016.07\n\n```\nmy $table = q:to/END/;\n>=  0.00  <  0.06  :=  0.10\n>=  0.06  <  0.11  :=  0.18\n>=  0.11  <  0.16  :=  0.26\n>=  0.16  <  0.21  :=  0.32\n>=  0.21  <  0.26  :=  0.38\n>=  0.26  <  0.31  :=  0.44\n>=  0.31  <  0.36  :=  0.50\n>=  0.36  <  0.41  :=  0.54\n>=  0.41  <  0.46  :=  0.58\n>=  0.46  <  0.51  :=  0.62\n>=  0.51  <  0.56  :=  0.66\n>=  0.56  <  0.61  :=  0.70\n>=  0.61  <  0.66  :=  0.74\n>=  0.66  <  0.71  :=  0.78\n>=  0.71  <  0.76  :=  0.82\n>=  0.76  <  0.81  :=  0.86\n>=  0.81  <  0.86  :=  0.90\n>=  0.86  <  0.91  :=  0.94\n>=  0.91  <  0.96  :=  0.98\n>=  0.96  <  1.01  :=  1.00\nEND\n\nmy @price;\n\nfor $table.lines {\n    /:s '>='  (\\S+)  '<'  (\\S+)  ':='  (\\S+)/;\n    @price[$0*100 ..^ $1*100] »=» +$2;\n}\n\nwhile prompt(\"value: \") -> $value {\n    say @price[$value * 100] // \"Out of range\";\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "There is a list of around 100\\_000 prices in the range £0 to £100\\_000, expressed\nin whole £, (no pence); and prices *may* be duplicated.   \nThe API allows access to the maximum item price via\nfunction `get_max_price()`; and the number of items equal-to and between two\ngiven price points via function `get_prange_count(pricemin, pricemax)`.  \nAssume that for the purposes of testing, you have access to the actual number of priced items to split.\n\nTask\n\n1. Write functions to randomly generate around 100K prices and provide the `get_prange_count` and `get_max_price` API calls.\n2. Write functions to provide non-overlapping min and max price ranges that provide product counts where most are close to, but no more than, 5\\_000.\n3. Ensure that all priced items are covered by all the ranges of prices shown\n4. Show ascending price ranges and the number of items covered by each range.\n5. Show output from a sample run here."}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20210208 Raku programming solution\n\nmy \\minDelta = 1;\n \nsub getMaxPrice { @_.max }\n\nsub getPRangeCount(@prices,\\min,\\max) { +@prices.grep: min ≤ * ≤ max }\n\nsub get5000(@prices, $min, $max is copy, \\n) {\n   my $count = getPRangeCount(@prices, $min, $max);\n   my $delta = ($max - $min) / 2;\n   while $count != n && $delta ≥ minDelta/2 {\n      $count > n ?? ($max -= $delta) !! ($max += $delta);\n      $count = getPRangeCount(@prices, $min, $max); \n      $delta /= 2;\n   }\n   $max, $count\n}\n\nsub getAll5000(@prices, \\min, \\max, \\n) {\n   my ( $pmax, $pcount ) = get5000(@prices, min, max, n);\n   my @res = [ min, $pmax, $pcount ] , ;\n   while $pmax < max {\n      my $pmin = $pmax + 1;\n      ( $pmax, $pcount ) = get5000(@prices, $pmin, max, n);\n      $pcount == 0 and note \"Price list from $pmin has too many duplicates.\";\n      @res.push: [ $pmin, $pmax, $pcount ];\n   } \n   @res\n} \n\nmy $numPrices = (99000..101001).roll;\nmy \\maxPrice  = 1e5;\nmy @prices    = (1..$numPrices+1).roll xx $numPrices ;\n\nmy $actualMax = getMaxPrice(@prices);\nsay \"Using $numPrices items with prices from 0 to $actualMax:\";\n\nmy @res = getAll5000(@prices, 0, $actualMax, 5000);\nsay \"Split into \", +@res, \" bins of approx 5000 elements:\";\n\nfor @res -> @row {\n   my ($min,$max,$subtotal) = @row;\n   $max = $actualMax if $max > $actualMax ;\n   printf \"  From %6d to %6d with %4d items\\n\", $min, $max, $subtotal \n}\n\n```\n\nOutput:\n\n```\nUsing 99506 items with prices from 0 to 99507:\nSplit into 20 bins of approx 5000 elements:\n  From      0 to   4983 with 5000 items\n  From   4984 to  10034 with 5003 items\n  From  10035 to  15043 with 4998 items\n  From  15044 to  20043 with 5001 items\n  From  20044 to  24987 with 5001 items\n  From  24988 to  30000 with 4998 items\n  From  30001 to  34954 with 5000 items\n  From  34955 to  40018 with 5000 items\n  From  40019 to  45016 with 5000 items\n  From  45017 to  49950 with 5000 items\n  From  49951 to  54877 with 4999 items\n  From  54878 to  59880 with 5002 items\n  From  59881 to  64807 with 5001 items\n  From  64808 to  69800 with 5000 items\n  From  69801 to  74897 with 5000 items\n  From  74898 to  79956 with 5002 items\n  From  79957 to  85037 with 5000 items\n  From  85038 to  90118 with 5001 items\n  From  90119 to  95169 with 5001 items\n  From  95170 to  99507 with 4470 items\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a boolean function that tells whether a given integer is prime.\n\nRemember that   **1**   and all non-positive numbers are not prime.\n\nUse trial division.\n\nEven numbers greater than   **2**   may be eliminated right away.\n\nA loop from   **3**   to   **√ n** will suffice,   but other loops are allowed.\n\nRelated tasks\n\n* count in factors\n* prime decomposition\n* AKS test for primes\n* factors of an integer\n* Sieve of Eratosthenes\n* factors of a Mersenne number\n* trial factoring of a Mersenne number\n* partition an integer X into N primes\n* sequence of primes by Trial Division"}, {"role": "assistant", "content": "(formerly Perl 6)\nHere we use a \"none\" junction which will autothread through the %% \"is divisible by\" operator to assert that $i is not divisible by 2 or any of the numbers up to its square root. Read it just as you would English: \"Integer $i is prime if it is greater than one and is divisible by none of 2, 3, up to the square root of $i.\"\n\n```\nsub prime (Int $i --> Bool) {\n    $i > 1 and so $i %% none 2..$i.sqrt;\n}\n```\n\nThis can easily be improved in two ways. First, we generate the primes so we only divide by those, instead of all odd numbers. Second, we memoize the result using the //= idiom of Perl, which does the right-hand calculation and assigns it only if the left side is undefined. We avoid recalculating the square root each time. Note the mutual recursion that depends on the implicit laziness of list evaluation:\n\n```\nmy @primes = 2, 3, 5, -> $p { ($p+2, $p+4 ... &prime)[*-1] } ... *;\nmy @isprime = False,False;   # 0 and 1 are not prime by definition\nsub prime($i) {\n    my \\limit = $i.sqrt.floor;\n    @isprime[$i] //= so ($i %% none @primes ...^ { $_ > limit })\n}\n\nsay \"$_ is{ \"n't\" x !prime($_) } prime.\" for 1 .. 100;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a boolean function that tells whether a given integer is prime using Wilson's theorem.\n\nBy Wilson's theorem, a number **p** is prime if and only if **p** divides `(p - 1)! + 1`.\n\nRemember that **1** and all non-positive integers are not prime.\n\nSee also\n\n* Cut-the-knot: Wilson's theorem.\n* Wikipedia: Wilson's theorem"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\nNot a particularly recommended way to test for primality, especially for larger numbers. It *works*, but is slow and memory intensive.\n\n```\nsub postfix:<!> (Int $n) { (constant f = 1, |[\\*] 1..*)[$n] }\n\nsub is-wilson-prime (Int $p where * > 1) { (($p - 1)! + 1) %% $p }\n\n# Pre initialize factorial routine (not thread safe)\n9000!;\n\n# Testing\nput '   p  prime?';\nprintf(\"%4d  %s\\n\", $_, .&is-wilson-prime) for 2, 3, 9, 15, 29, 37, 47, 57, 67, 77, 87, 97, 237, 409, 659;\n\nmy $wilsons = (2,3,*+2…*).hyper.grep: &is-wilson-prime;\n\nput \"\\nFirst 120 primes:\";\nput $wilsons[^120].rotor(20)».fmt('%3d').join: \"\\n\";\n\nput \"\\n1000th through 1015th primes:\";\nput $wilsons[999..1014];\n\n```\n\nOutput:\n\n```\n   p  prime?\n   2  True\n   3  True\n   9  False\n  15  False\n  29  True\n  37  True\n  47  True\n  57  False\n  67  True\n  77  False\n  87  False\n  97  True\n 237  False\n 409  True\n 659  True\n\nFirst 120 primes:\n  2   3   5   7  11  13  17  19  23  29  31  37  41  43  47  53  59  61  67  71\n 73  79  83  89  97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173\n179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281\n283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409\n419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541\n547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659\n\n1000th through 1015th primes:\n7919 7927 7933 7937 7949 7951 7963 7993 8009 8011 8017 8039 8053 8059 8069 8081\n```"}]}
{"messages": [{"role": "user", "content": "A recent discovery, quoted from   Quantamagazine   (March 13, 2016):\n\n```\n     Two mathematicians have uncovered a simple, previously unnoticed property of \n     prime numbers — those numbers that are divisible only by 1 and themselves.     \n     Prime numbers, it seems, have decided preferences about the final digits of    \n     the primes that immediately follow them.  \n\n```\n\nand\n\n```\n     This conspiracy among prime numbers seems, at first glance, to violate a     \n     longstanding assumption in number theory:  that prime numbers behave much    \n     like random numbers. \n\n                            ─── (original authors from Stanford University):      \n                            ─── Kannan Soundararajan  and  Robert Lemke Oliver    \n\n```\n\nThe task is to check this assertion, modulo 10.\n\nLets call   `i -> j`    a transition if   `i`    is the last decimal digit of a prime, and   `j`    the last decimal digit of the following prime.\n\nTask\n\nConsidering the first one million primes.   Count, for any pair of successive primes, the number of transitions   `i -> j`    and print them along with their relative frequency, sorted by   `i` .\n\nYou can see that, for a given   `i` ,   frequencies are not evenly distributed.\n\nObservation\n\n(Modulo 10),   primes whose last digit is   **9**   \"prefer\"   the digit   **1**   to the digit   **9**,   as its following prime.\n\nExtra credit\n\nDo the same for one hundred million primes.\n\nExample for 10,000 primes\n\n```\n10000 first primes. Transitions prime % 10 → next-prime % 10.\n1 → 1 count:        365 frequency: 3.65 %\n1 → 3 count:        833 frequency: 8.33 %\n1 → 7 count:        889 frequency: 8.89 %\n1 → 9 count:        397 frequency: 3.97 %\n2 → 3 count:          1 frequency: 0.01 %\n3 → 1 count:        529 frequency: 5.29 %\n3 → 3 count:        324 frequency: 3.24 %\n3 → 5 count:          1 frequency: 0.01 %\n3 → 7 count:        754 frequency: 7.54 %\n3 → 9 count:        907 frequency: 9.07 %\n5 → 7 count:          1 frequency: 0.01 %\n7 → 1 count:        655 frequency: 6.55 %\n7 → 3 count:        722 frequency: 7.22 %\n7 → 7 count:        323 frequency: 3.23 %\n7 → 9 count:        808 frequency: 8.08 %\n9 → 1 count:        935 frequency: 9.35 %\n9 → 3 count:        635 frequency: 6.35 %\n9 → 7 count:        541 frequency: 5.41 %\n9 → 9 count:        379 frequency: 3.79 % \n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.9\n\nUsing module `Math::Primesieve` to generate primes, as much faster than the built-in (but extra credit still very slow).\n\n```\nuse Math::Primesieve;\n\nmy %conspiracy;\nmy $upto = 1_000_000;\nmy $sieve = Math::Primesieve.new;\nmy @primes = $sieve.n-primes($upto+1);\n\n@primes[^($upto+1)].reduce: -> $a, $b {\n    my $d = $b % 10;\n    %conspiracy{\"$a → $d count:\"}++;\n    $d;\n}\n\nsay \"$_ \\tfrequency: {($_.value/$upto*100).round(.01)} %\" for %conspiracy.sort;\n\n```\n\nOutput:\n\n```\n1 → 1 count:\t42853 \tfrequency: 4.29 %\n1 → 3 count:\t77475 \tfrequency: 7.75 %\n1 → 7 count:\t79453 \tfrequency: 7.95 %\n1 → 9 count:\t50153 \tfrequency: 5.02 %\n2 → 3 count:\t1 \tfrequency: 0 %\n3 → 1 count:\t58255 \tfrequency: 5.83 %\n3 → 3 count:\t39668 \tfrequency: 3.97 %\n3 → 5 count:\t1 \tfrequency: 0 %\n3 → 7 count:\t72828 \tfrequency: 7.28 %\n3 → 9 count:\t79358 \tfrequency: 7.94 %\n5 → 7 count:\t1 \tfrequency: 0 %\n7 → 1 count:\t64230 \tfrequency: 6.42 %\n7 → 3 count:\t68595 \tfrequency: 6.86 %\n7 → 7 count:\t39603 \tfrequency: 3.96 %\n7 → 9 count:\t77586 \tfrequency: 7.76 %\n9 → 1 count:\t84596 \tfrequency: 8.46 %\n9 → 3 count:\t64371 \tfrequency: 6.44 %\n9 → 7 count:\t58130 \tfrequency: 5.81 %\n9 → 9 count:\t42843 \tfrequency: 4.28 %\n```"}]}
{"messages": [{"role": "user", "content": "The prime decomposition of a number is defined as a list of prime numbers\nwhich when all multiplied together, are equal to that number.\n\nExample\n\n```\n 12 = 2 × 2 × 3,  so its prime decomposition is  {2, 2, 3}\n\n```\n\nTask\n\nWrite a function which returns an array or collection which contains the prime decomposition of a given number   \n\nn\n{\\displaystyle {\\displaystyle n}}\n   greater than   **1**.\n\nIf your language does not have an isPrime-like function available,\nyou may assume that you have a function which determines\nwhether a number is prime (note its name before your code).\n\nIf you would like to test code from this task, you may use code from trial division or the Sieve of Eratosthenes.\n\nNote: The program must not be limited by the word size of your computer or some other artificial limit; it should work for any number regardless of size (ignoring the physical limits of RAM etc).\n\nRelated tasks\n\n* count in factors\n* factors of an integer\n* Sieve of Eratosthenes\n* primality by trial division\n* factors of a Mersenne number\n* trial factoring of a Mersenne number\n* partition an integer X into N primes\n* sequence of primes by Trial Division"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Pure Raku\n\nThis is a pure Raku version that uses no outside libraries. It uses a variant of Pollard's rho factoring algorithm and is fairly performent when factoring numbers < 2⁸⁰; typically taking well under a second on an i7. It starts to slow down with larger numbers, but really bogs down factoring numbers that have more than 1 factor larger than about 2⁴⁰.\n\n```\nsub prime-factors ( Int $n where * > 0 ) {\n    return $n if $n.is-prime;\n    return () if $n == 1;\n    my $factor = find-factor( $n );\n    sort flat ( $factor, $n div $factor ).map: &prime-factors;\n}\n\nsub find-factor ( Int $n, $constant = 1 ) {\n    return 2 unless $n +& 1;\n    if (my $gcd = $n gcd 6541380665835015) > 1 { # magic number: [*] primes 3 .. 43\n        return $gcd if $gcd != $n\n    }\n    my $x      = 2;\n    my $rho    = 1;\n    my $factor = 1;\n    while $factor == 1 {\n        $rho = $rho +< 1;\n        my $fixed = $x;\n        my int $i = 0;\n        while $i < $rho {\n            $x = ( $x * $x + $constant ) % $n;\n            $factor = ( $x - $fixed ) gcd $n;\n            last if 1 < $factor;\n            $i = $i + 1;\n        }\n    }\n    $factor = find-factor( $n, $constant + 1 ) if $n == $factor;\n    $factor;\n}\n\n.put for (2²⁹-1, 2⁴¹-1, 2⁵⁹-1, 2⁷¹-1, 2⁷⁹-1, 2⁹⁷-1, 2¹¹⁷-1, 2²⁴¹-1,\n5465610891074107968111136514192945634873647594456118359804135903459867604844945580205745718497)\\\n.hyper(:1batch).map: -> $n {\n    my $start = now;\n   \"factors of $n: \",\n    prime-factors($n).join(' × '), \" \\t in \", (now - $start).fmt(\"%0.3f\"), \" sec.\"\n}\n```\n\nOutput:\n\n```\nfactors of 536870911:  233 × 1103 × 2089    in  0.004  sec.\nfactors of 2199023255551:  13367 × 164511353     in  0.011  sec.\nfactors of 576460752303423487:  179951 × 3203431780337       in  0.023  sec.\nfactors of 2361183241434822606847:  228479 × 48544121 × 212885833    in  0.190  sec.\nfactors of 604462909807314587353087:  2687 × 202029703 × 1113491139767       in  0.294  sec.\nfactors of 158456325028528675187087900671:  11447 × 13842607235828485645766393       in  0.005  sec.\nfactors of 166153499473114484112975882535043071:  7 × 73 × 79 × 937 × 6553 × 8191 × 86113 × 121369 × 7830118297      in  0.022  sec.\nfactors of 3533694129556768659166595001485837031654967793751237916243212402585239551:  22000409 × 160619474372352289412737508720216839225805656328990879953332340439     in  0.085  sec.\nfactors of 5465610891074107968111136514192945634873647594456118359804135903459867604844945580205745718497:  165901 × 10424087 × 18830281 × 53204737 × 56402249 × 59663291 × 91931221 × 95174413 × 305293727939 × 444161842339 × 790130065009     in  28.427  sec.\n```\n\nThere is a Raku module available: Prime::Factor, that uses essentially this algorithm with some minor performance tweaks.\n\n### External library\n\nIf you really need a speed boost, load the highly optimized Perl 5 ntheory module. It needs a little extra plumbing to deal with the lack of built-in big integer support, but for large number factoring the interface overhead is worth it.\n\n```\nuse Inline::Perl5;\nmy $p5 = Inline::Perl5.new();\n$p5.use( 'ntheory' );\n\nsub prime-factors ($i) {\n    my &primes = $p5.run('sub { map { ntheory::todigitstring $_ } sort {$a <=> $b} ntheory::factor $_[0] }');\n    primes(\"$i\");\n}\n\nfor 2²⁹-1, 2⁴¹-1, 2⁵⁹-1, 2⁷¹-1, 2⁷⁹-1, 2⁹⁷-1, 2¹¹⁷-1,\n5465610891074107968111136514192945634873647594456118359804135903459867604844945580205745718497\n ->  $n {\n    my $start = now;\n    say \"factors of $n: \",\n    prime-factors($n).join(' × '), \" \\t in \", (now - $start).fmt(\"%0.3f\"), \" sec.\"\n}\n```\n\nOutput:\n\n```\nfactors of 536870911: 233 × 1103 × 2089     in 0.001 sec.\nfactors of 2199023255551: 13367 × 164511353      in 0.001 sec.\nfactors of 576460752303423487: 179951 × 3203431780337    in 0.001 sec.\nfactors of 2361183241434822606847: 228479 × 48544121 × 212885833     in 0.012 sec.\nfactors of 604462909807314587353087: 2687 × 202029703 × 1113491139767    in 0.003 sec.\nfactors of 158456325028528675187087900671: 11447 × 13842607235828485645766393    in 0.001 sec.\nfactors of 166153499473114484112975882535043071: 7 × 73 × 79 × 937 × 6553 × 8191 × 86113 × 121369 × 7830118297   in 0.001 sec.\nfactors of 5465610891074107968111136514192945634873647594456118359804135903459867604844945580205745718497: 165901 × 10424087 × 18830281 × 53204737 × 56402249 × 59663291 × 91931221 × 95174413 × 305293727939 × 444161842339 × 790130065009      in 0.064 sec.\n\n```"}]}
{"messages": [{"role": "user", "content": "Suppose you had an infinite length ruler with which you wanted to be able to measure any positive integer unit length, but which has no extraneous tic marks or repeated intervals. Assume the ruler has a boundary at zero, but extends toward positive infinity to remove any issues of mirrored intervals. Assume there is a tic mark at zero.\n\n* :   To measure a **1** unit length, you need a tic mark at 1 unit in. Whenever you add a tick to the ruler, you need to add that interval to the sequence. (**Sequence: 1**)\n\n* :   To measure a **2** unit length, you need to have tics two units apart. If you add one two units in, you will have two 1 unit intervals, which is not allowed. Instead you need to put a tic mark 2 units from the 1. This will allow measuring both 1 unit lengths and 2 unit lengths with no repeated lengths or extraneous tics. (**Sequence: 1, 2**)\n\n* :   To measure a **3** unit length, you have a 1 unit interval and 2 unit interval directly next to one another. You can measure a 3 unit length by utilizing the 1 and 2 contiguous intervals. There is no need to have a dedicated 3 unit interval. No added tic. (**Sequence: 1, 2**)\n\n* :   To measure a **4** unit interval; there is no way to combine the 1 and 2 unit intervals to yield 4, so you need to add another tic, 4 units from the previous (2). (**Sequence: 1, 2, 4**)\n\n* :   **5** units; There is no way to form a 5 unit contiguous interval, so add a tic at 5. (**Sequence: 1, 2, 4, 5**)\n\n* :   **6** units; The contiguous units 2 and 4 make a 6 unit interval; no tic needed. (**Sequence: 1, 2, 4, 5**)\n\n* :   **7** units; The contiguous units 1, 2 and 4 make a 7 unit interval; no tic needed. (**Sequence: 1, 2, 4, 5**)\n\n* :   **8** units; The units 1, 2 and 5 make 8 but they are not contiguous; There is no contiguous group that sums to 8. Add a tic at 8 (**Sequence: 1, 2, 4, 5, 8**)\n\n* :   *and so on...*\n\nThe numbers in this sequence, the numbers whose length can not be formed by any contiguous combination of prior elements in the sequence, are known as **Prime numbers of measurement** or sometimes **segmented numbers**. They are often referred to as **MacMahon's prime numbers of measurement** after P. A. MacMahon who was first to publish work studying them. They are not (necessarily) prime in the traditional sense, rather, there is no way to arrive at one by summing previous contiguous elements.\n\nTask\n\n* :   Find and display the first 100 elements of this sequence.\n\nStretch\n\n* :   Find and display the 1000th element of this sequence.\n\nSee also\n\n* OEIS A002048 - Segmented numbers, or prime numbers of measurement"}, {"role": "assistant", "content": "```\nmy atomicint $index = 0;\nmy @prime-measure = 1;\n\nfor 2..* -> $next {\n    my atomicint $last;\n    (0..$index-1).hyper(:10batch).map: -> $start {\n        for 1..$index -> $end {\n            next if $start == $end;\n            last if $next < my $sum = @prime-measure[$start..$end].sum;\n            ++⚛$last and last if $sum == $next;\n        }\n        last if $last\n    }\n    next if $last;\n    @prime-measure.push: $next;\n    ++⚛$index;\n    last if $index >= 999;\n}\n\nput \"First 100:\\n\", @prime-measure[^100]».fmt('%3d').batch(10).join: \"\\n\";\n\nput \"\\nOne Thousandth: \", @prime-measure.tail;\n\n```\n\nOutput:\n\n```\nFirst 100:\n  1   2   4   5   8  10  14  15  16  21\n 22  25  26  28  33  34  35  36  38  40\n 42  46  48  49  50  53  57  60  62  64\n 65  70  77  80  81  83  85  86  90  91\n 92 100 104 107 108 116 119 124 127 132\n133 137 141 144 145 148 150 151 154 158\n159 163 165 172 173 174 175 178 180 182\n184 187 188 195 198 201 206 207 208 213\n219 221 222 226 228 231 233 236 241 242\n245 247 248 253 256 262 266 268 272 274\n\nOne Thousandth: 3165\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind primes   **p**   for which the sum of primes less than or equal to   **p**   is prime,   where   **p  <  1,000**."}, {"role": "assistant", "content": "Trivial variation of Summarize primes task. Modified to do double duty.\n\n```\nuse Lingua::EN::Numbers;\n\nmy @primes    = grep *.is-prime, ^Inf;\nmy @primesums = [\\+] @primes;\nsay \"{.elems} cumulative prime sums:\\n\",\n    .map( -> $p {\n        sprintf \"The sum of the first %3d (up to {@primes[$p]}) is prime: %s\",\n        1 + $p, comma @primesums[$p]\n      }\n    ).join(\"\\n\")\n    given grep { @primesums[$_].is-prime }, ^1000;\n\n```\n\nOutput:\n\n```\n76 cumulative prime sums:\nThe sum of the first   1 (up to 2) is prime: 2\nThe sum of the first   2 (up to 3) is prime: 5\nThe sum of the first   4 (up to 7) is prime: 17\nThe sum of the first   6 (up to 13) is prime: 41\nThe sum of the first  12 (up to 37) is prime: 197\nThe sum of the first  14 (up to 43) is prime: 281\nThe sum of the first  60 (up to 281) is prime: 7,699\nThe sum of the first  64 (up to 311) is prime: 8,893\nThe sum of the first  96 (up to 503) is prime: 22,039\nThe sum of the first 100 (up to 541) is prime: 24,133\nThe sum of the first 102 (up to 557) is prime: 25,237\nThe sum of the first 108 (up to 593) is prime: 28,697\nThe sum of the first 114 (up to 619) is prime: 32,353\nThe sum of the first 122 (up to 673) is prime: 37,561\nThe sum of the first 124 (up to 683) is prime: 38,921\nThe sum of the first 130 (up to 733) is prime: 43,201\nThe sum of the first 132 (up to 743) is prime: 44,683\nThe sum of the first 146 (up to 839) is prime: 55,837\nThe sum of the first 152 (up to 881) is prime: 61,027\nThe sum of the first 158 (up to 929) is prime: 66,463\nThe sum of the first 162 (up to 953) is prime: 70,241\nThe sum of the first 178 (up to 1061) is prime: 86,453\nThe sum of the first 192 (up to 1163) is prime: 102,001\nThe sum of the first 198 (up to 1213) is prime: 109,147\nThe sum of the first 204 (up to 1249) is prime: 116,533\nThe sum of the first 206 (up to 1277) is prime: 119,069\nThe sum of the first 208 (up to 1283) is prime: 121,631\nThe sum of the first 214 (up to 1307) is prime: 129,419\nThe sum of the first 216 (up to 1321) is prime: 132,059\nThe sum of the first 296 (up to 1949) is prime: 263,171\nThe sum of the first 308 (up to 2029) is prime: 287,137\nThe sum of the first 326 (up to 2161) is prime: 325,019\nThe sum of the first 328 (up to 2203) is prime: 329,401\nThe sum of the first 330 (up to 2213) is prime: 333,821\nThe sum of the first 332 (up to 2237) is prime: 338,279\nThe sum of the first 334 (up to 2243) is prime: 342,761\nThe sum of the first 342 (up to 2297) is prime: 360,979\nThe sum of the first 350 (up to 2357) is prime: 379,667\nThe sum of the first 356 (up to 2393) is prime: 393,961\nThe sum of the first 358 (up to 2411) is prime: 398,771\nThe sum of the first 426 (up to 2957) is prime: 581,921\nThe sum of the first 446 (up to 3137) is prime: 642,869\nThe sum of the first 458 (up to 3251) is prime: 681,257\nThe sum of the first 460 (up to 3257) is prime: 687,767\nThe sum of the first 464 (up to 3301) is prime: 700,897\nThe sum of the first 480 (up to 3413) is prime: 754,573\nThe sum of the first 484 (up to 3461) is prime: 768,373\nThe sum of the first 488 (up to 3491) is prime: 782,263\nThe sum of the first 512 (up to 3671) is prime: 868,151\nThe sum of the first 530 (up to 3821) is prime: 935,507\nThe sum of the first 536 (up to 3863) is prime: 958,577\nThe sum of the first 548 (up to 3947) is prime: 1,005,551\nThe sum of the first 568 (up to 4129) is prime: 1,086,557\nThe sum of the first 620 (up to 4583) is prime: 1,313,041\nThe sum of the first 630 (up to 4657) is prime: 1,359,329\nThe sum of the first 676 (up to 5051) is prime: 1,583,293\nThe sum of the first 680 (up to 5087) is prime: 1,603,597\nThe sum of the first 696 (up to 5233) is prime: 1,686,239\nThe sum of the first 708 (up to 5351) is prime: 1,749,833\nThe sum of the first 734 (up to 5563) is prime: 1,891,889\nThe sum of the first 762 (up to 5807) is prime: 2,051,167\nThe sum of the first 768 (up to 5849) is prime: 2,086,159\nThe sum of the first 776 (up to 5897) is prime: 2,133,121\nThe sum of the first 780 (up to 5939) is prime: 2,156,813\nThe sum of the first 784 (up to 6007) is prime: 2,180,741\nThe sum of the first 808 (up to 6211) is prime: 2,327,399\nThe sum of the first 814 (up to 6263) is prime: 2,364,833\nThe sum of the first 820 (up to 6301) is prime: 2,402,537\nThe sum of the first 836 (up to 6427) is prime: 2,504,323\nThe sum of the first 844 (up to 6529) is prime: 2,556,187\nThe sum of the first 848 (up to 6563) is prime: 2,582,401\nThe sum of the first 852 (up to 6581) is prime: 2,608,699\nThe sum of the first 926 (up to 7243) is prime: 3,120,833\nThe sum of the first 942 (up to 7433) is prime: 3,238,237\nThe sum of the first 984 (up to 7757) is prime: 3,557,303\nThe sum of the first 992 (up to 7853) is prime: 3,619,807\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind those primes   **n**   whose decimal representation contains the consecutive digits   **123**,   where   **n   <   100,000**.\n\nStretch goal\n\nAs above, but only show the count of those primes   **n**   that contain the (above) string,   where   **n   <   1,000,000**."}, {"role": "assistant", "content": "```\nmy @p123 = ^∞ .grep: { (.contains: 123) && .is-prime };\n\nput display @p123[^(@p123.first: * > 1e5, :k)];\n\nput \"\\nCount up to 1e6: \", ~ +@p123[^(@p123.first: * > 1e6, :k)];\n\nsub display ($list, :$cols = 10, :$fmt = '%6d', :$title = \"{+$list} matching:\\n\" )   {\n    cache $list;\n    $title ~ $list.batch($cols)».fmt($fmt).join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\n46 matching:\n  1123   1231   1237   8123  11239  12301  12323  12329  12343  12347\n 12373  12377  12379  12391  17123  20123  22123  28123  29123  31123\n 31231  31237  34123  37123  40123  41231  41233  44123  47123  49123\n 50123  51239  56123  59123  61231  64123  65123  70123  71233  71237\n 76123  81233  81239  89123  91237  98123\n\nCount up to 1e6: 451\n\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nThe following definitions are needed for this task.\n\nA **tetraprime** is a positive integer which is the product of four distinct primes. For example, 1155 is a tetraprime because 1155 = 3 x 5 x 7 x 11.\n\nThe **neighboring pairs** of a prime are the two consecutive numbers immediately preceding or immediately following that prime. For example, (5, 6) and (8, 9) are the neighboring pairs of the prime 7.\n\nTask\n\n1. Find and show here all primes less than **100,000** whose **preceding** neighboring pair are both tetraprimes.\n\n2. Find and show here all primes less than **100,000** whose **following** neighboring pair are both tetraprimes.\n\n3. Of the primes in 1 and 2 above how many have a neighboring pair one of whose members has a prime factor of 7?\n\n4. For the primes in 1 and 2 above, consider the gaps between consecutive primes. What are the minimum, median and maximum gaps?\n\n5. Repeat these calculations for all primes less than **1 million** but for 1 and 2 just show the number of primes - don't print them out individually.\n\nIf it is difficult for your language to meet all of these requirements, then just do what you reasonably can.\n\nStretch\n\nRepeat the calculations for all primes less than **10 million**.\n\nReferences\n\n* OEIS sequence A361796: Prime numbers preceded by two consecutive numbers which are products of four distinct primes (or tetraprimes).\n* OEIS sequence A362578: Prime numbers followed by two consecutive numbers which are products of four distinct primes (or tetraprimes)."}, {"role": "assistant", "content": "**Translation of**: Wren\n\n```\n# 20230721 Raku programming solution\n\nmy @primes = (2..1e7).grep: *.is-prime; # cannot do lazy here \n\nsub median { # based on https://rosettacode.org/wiki/Averages/Median#Raku\n   return { ( .[(*-1) div 2] + .[* div 2] ) / 2 }(@_) # for already sorted\n}\n\nsub isTetraPrime ($n is copy) { # is cached {\n   my ($count,$prevFact) = 0, 1;\n   for @primes -> \\p {\n      my $limit = p * p;\n      if $count == 0 {\n         $limit = $limit * $limit\n      } elsif $count == 1 {\n         $limit *= p\n      }\n      if $limit <= $n {\n         while $n %% p {\n            return False if ( $count == 4 or p == $prevFact );\n            $count++;\n            $n div= p;\n            $prevFact = p\n         }\n      } else {\n         last      \n      }\n   }\n   if $n > 1 {\n      return False if ( $count == 4 or $n == $prevFact );\n      $count++\n   }\n   return $count == 4\n}\n\nmy ( $j, @tetras1, @tetras2, $sevens1, $sevens2 ) = 1e5;\n\nmy \\highest7 = @primes.[*-1];\nmy \\highest6 = @primes.first: * < 1e6, :end;\nmy \\highest5 = @primes.first: * < 1e5, :end; \n\nfor @primes -> \\p {\n   if isTetraPrime p-1 and isTetraPrime p-2 {\n      @tetras1.push: p;\n      $sevens1++ if ( (p-1) %% 7 or (p-2) %% 7 );\n   }\n   if isTetraPrime p+1 and isTetraPrime p+2 {\n      @tetras2.push: p;\n      $sevens2++ if ( (p+1) %% 7 or (p+2) %% 7 ); \n   }\n   if p == highest5 | highest6 | highest7 {\n      for 0,1 -> \\i {\n         my (\\sevens, \\t, @tetras) := i == 0 \n            ?? ( $sevens1, \"preceding\", @tetras1 )\n            !! ( $sevens2, \"following\", @tetras2 ); \n         my \\c = @tetras.elems;\n\n         say \"Found {c} primes under $j whose {t} neighboring pair are tetraprimes:\";\n         if p == highest5 {\n            say [~] $_>>.fmt('%6s') for @tetras.rotor(10,:partial);       \n         }\n         say \"of which {sevens} have a neighboring pair one of whose factors is 7.\\n\";\n         my \\gaps = ( @tetras.rotor(2=>-1).map: { .[1] - .[0] } ).sort;\n         \n         my (\\Min,\\Max,\\Med) = gaps[0], gaps[*-1], median(gaps);\n         say \"Minimum gap between those {c} primes : {Min}\";\n         say \"Median  gap between those {c} primes : {Med}\";\n         say \"Maximum gap between those {c} primes : {Max}\"; \n         say()\n      }\n      $j *= 10\n   } \n}\n\n```\n\nOutput:\n\nSame as Wren"}]}
{"messages": [{"role": "user", "content": "Generate the sequence of primes where each term is the smallest prime whose reciprocal can be added to the cumulative sum and remain smaller than **1**.\n\nE.G.\n:   The cumulative reciprocal sum with zero terms is **0**. The smallest prime whose reciprocal can be added to the sum without reaching or exceeding **1** is **2**, so the first term is **2** and the new cumulative reciprocal sum is **1/2**.\n\n:   The smallest prime whose reciprocal can be added to the sum without reaching or exceeding **1** is **3**. *(**2** would cause the cumulative reciprocal sum to reach **1**.)* So the next term is **3**, and the new cumulative sum is **5/6**.\n\n:   *and so on...*\n\nTask\n\n* Find and display the first **10** terms of the sequence. (Or as many as reasonably supported by your language if it is less.) For any values with more than 40 digits, show the first and last 20 digits and the overall digit count.\n\nIf any of the tests for primality used in\nyour program are probabilistic please so indicate.\n\nStretch\n\n* Find and display the next **5** terms of the sequence. (Or as many as you have the patience for.) Show only the first and last 20 digits and the overall digit count.\n\nSee also\n\n* OEIS:A075442 - Slowest-growing sequence of primes whose reciprocals sum to 1"}, {"role": "assistant", "content": "The sixteenth is very slow to emerge. Didn't bother trying for the seventeenth. OEIS only lists the first fourteen values.\n\n```\nsub abbr ($_) { .chars < 41 ?? $_ !! .substr(0,20) ~ '..' ~ .substr(*-20) ~ \" ({.chars} digits)\" }\n\nsub next-prime {\n    state $sum = 0;\n    my $next = ((1 / (1 - $sum)).ceiling+1..*).hyper(:2batch).grep(&is-prime)[0];\n    $sum += FatRat.new(1,$next);\n    $next;\n}\n\nprintf \"%2d: %s\\n\", $_, abbr next-prime for 1..15;\n\n```\n\nOutput:\n\n```\n 1: 2\n 2: 3\n 3: 7\n 4: 43\n 5: 1811\n 6: 654149\n 7: 27082315109\n 8: 153694141992520880899\n 9: 337110658273917297268061074384231117039\n10: 84241975970641143191..13803869133407474043 (76 digits)\n11: 20300753813848234767..91313959045797597991 (150 digits)\n12: 20323705381471272842..21649394434192763213 (297 digits)\n13: 12748246592672078196..20708715953110886963 (592 digits)\n14: 46749025165138838243..65355869250350888941 (1180 digits)\n15: 11390125639471674628..31060548964273180103 (2358 digits)\n16: 36961763505630520555..02467094377885929191 (4711 digits)\n```"}]}
{"messages": [{"role": "user", "content": "You will require a function f which when given an integer S will return a list of the arrangements of the integers 1 to S such that g1=1 gS=S and generally for n=1 to n=S-1 gn+gn+1 is prime. S=1 is undefined. For S=2 to S=20 print f(S) to form a triangle. Then again for S=2 to S=20 print the number of possible arrangements of 1 to S meeting these requirements.\n\nSee also\n:   * OEIS:A036440"}, {"role": "assistant", "content": "Limit the upper threshold a bit to avoid multiple hours of pointless calculations. Even just up to 17 takes over 20 minutes.\n\n```\nmy @count = 0, 0, 1;\nmy $lock = Lock.new;\nput (1,2);\n\nfor 3..17 -> $n {\n    my @even = (2..^$n).grep: * %% 2;\n    my @odd  = (3..^$n).grep: so * % 2;\n    @even.permutations.race.map: -> @e {\n        quietly next if @e[0] == 8|14;\n        my $nope = 0;\n        for @odd.permutations -> @o {\n            quietly next unless (@e[0] + @o[0]).is-prime;\n            my @list;\n            for (@list = (flat (roundrobin(@e, @o)), $n)).rotor(2 => -1) {\n                $nope++ and last unless .sum.is-prime;\n            }\n            unless $nope {\n                put '1 ', @list unless @count[$n];\n                $lock.protect({ @count[$n]++ });\n            }\n            $nope = 0;\n        }\n    }\n}\nput \"\\n\", @count[2..*];\n\n```\n\nOutput:\n\n```\n1 2\n1 2 3\n1 2 3 4\n1 4 3 2 5\n1 4 3 2 5 6\n1 4 3 2 5 6 7\n1 2 3 4 7 6 5 8\n1 2 3 4 7 6 5 8 9\n1 2 3 4 7 6 5 8 9 10\n1 6 5 8 3 10 7 4 9 2 11\n1 6 5 8 3 10 7 4 9 2 11 12\n1 4 3 2 5 8 9 10 7 12 11 6 13\n1 4 3 2 11 8 9 10 13 6 7 12 5 14\n1 2 3 8 5 12 11 6 7 10 13 4 9 14 15\n1 2 3 8 5 12 11 6 7 10 13 4 9 14 15 16\n1 2 9 4 7 10 13 6 5 14 3 16 15 8 11 12 17\n\n1 1 1 1 1 2 4 7 24 80 216 648 1304 3392 13808 59448\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show members of prime triples (p, p+2, p+6), where **p < 5500**\n\nSee also\n:   * The OEIS entry:   A022004 - Initial members of prime triples (p, p+2, p+6)\n    * The Wikipedia entry:   Prime triplet\n    * The MathWorld entry:   Prime Triplet\n    * The RosettaCode task for just (p,p+4):   Cousin primes\n    * The RosettaCode task for other patterns of primes:   Successive prime differences"}, {"role": "assistant", "content": "Adapted from Cousin primes\n\n### Filter\n\nFavoring brevity over efficiency due to the small range of n, the most concise solution is:\n\n```\nsay grep *.all.is-prime, map { $_, $_+2, $_+6 }, 2..5500;\n\n```\n\nOutput:\n\n```\n((5 7 11) (11 13 17) (17 19 23) (41 43 47) (101 103 107) (107 109 113) (191 193 197) (227 229 233) (311 313 317) (347 349 353) (461 463 467) (641 643 647) (821 823 827) (857 859 863) (881 883 887) (1091 1093 1097) (1277 1279 1283) (1301 1303 1307) (1427 1429 1433) (1481 1483 1487) (1487 1489 1493) (1607 1609 1613) (1871 1873 1877) (1997 1999 2003) (2081 2083 2087) (2237 2239 2243) (2267 2269 2273) (2657 2659 2663) (2687 2689 2693) (3251 3253 3257) (3461 3463 3467) (3527 3529 3533) (3671 3673 3677) (3917 3919 3923) (4001 4003 4007) (4127 4129 4133) (4517 4519 4523) (4637 4639 4643) (4787 4789 4793) (4931 4933 4937) (4967 4969 4973) (5231 5233 5237) (5477 5479 5483))\n\n```\n\n### Infinite List\n\nA more efficient and versatile approach is to generate an infinite list of triple primes, using this info from https://oeis.org/A022004 :\n\n:   All terms are congruent to 5 (mod 6).\n\n```\nconstant @triples = (5, *+6 … *).map: -> \\n { $_ if .all.is-prime given (n, n+2, n+6) }\n\nmy $count = @triples.first: :k, *.[0] >= 5500;\n\nsay .fmt('%4d') for @triples.head($count);\n\n```\n\nOutput:\n\n```\n   5    7   11\n  11   13   17\n  17   19   23\n  41   43   47\n 101  103  107\n 107  109  113\n 191  193  197\n 227  229  233\n 311  313  317\n 347  349  353\n 461  463  467\n 641  643  647\n 821  823  827\n 857  859  863\n 881  883  887\n1091 1093 1097\n1277 1279 1283\n1301 1303 1307\n1427 1429 1433\n1481 1483 1487\n1487 1489 1493\n1607 1609 1613\n1871 1873 1877\n1997 1999 2003\n2081 2083 2087\n2237 2239 2243\n2267 2269 2273\n2657 2659 2663\n2687 2689 2693\n3251 3253 3257\n3461 3463 3467\n3527 3529 3533\n3671 3673 3677\n3917 3919 3923\n4001 4003 4007\n4127 4129 4133\n4517 4519 4523\n4637 4639 4643\n4787 4789 4793\n4931 4933 4937\n4967 4969 4973\n5231 5233 5237\n5477 5479 5483\n```"}]}
{"messages": [{"role": "user", "content": "A word is a   *prime word*   if all its individual letters   (expressed as an ASCII decimal code)   are primes.\n\n```\n        A   ASCII decimal code is:   65 \n        B   ASCII decimal code is:   66 \n        C   ASCII decimal code is:   67 \n                 \n        X   ASCII decimal code is:   88 \n        Y   ASCII decimal code is:   89 \n        Z   ASCII decimal code is:   90 \n                 \n        a   ASCII decimal code is:   97 \n        b   ASCII decimal code is:   98 \n        c   ASCII decimal code is:   99 \n                 \n        x   ASCII decimal code is:   120 \n        y   ASCII decimal code is:   121 \n        z   ASCII decimal code is:   122 \n\n```\n\nTask\n\nShow here on this page every   *prime word*   in unixdict.txt."}, {"role": "assistant", "content": "Another in a continuing series of tasks that are a minimal variation of previous ones. This is essentially Smarandache prime-digital sequence using ords instead of numerical digits.\nSigh.\n\nIn an effort to anticipate / head-off a rash of tiny variant tasks, a series of one-liners:\n\n```\nmy @words = 'unixdict.txt'.IO.words».fc;\n\nsub display ($n, @n, $s = \"First 20: \") {\"$n;\\n{$s}{@n.join: ', '}\"}\n\n# The task\nsay 'Number of words whose ords are all prime: ',\n    @words.hyper.grep({ .ords.all.is-prime }).&{display +$_, $_, ''};\n\n# Twelve other minor variants\nsay \"\\nNumber of words whose ordinal sum is prime: \",\n    @words.grep({ .ords.sum.is-prime }).&{display +$_, .head(20)};\n\nsay \"\\nNumber of words whose ords are all prime, and whose ordinal sum is prime: \",\n    @words.hyper.grep({ .ords.all.is-prime && .ords.sum.is-prime }).&{display +$_, $_, ''};\n\nsay \"\\n\\nInterpreting the words as if they were base 36 numbers:\";\n\nsay \"\\nNumber of words whose 'digits' are all prime in base 36: \",\n    @words.hyper.grep({ !.contains(/\\W/) && all(.comb».parse-base(36)).is-prime }).&{display +$_, $_, ''};\n\nsay \"\\nNumber of words that are prime in base 36: \",\n    @words.grep({ !.contains(/\\W/) && :36($_).is-prime }).&{display +$_, .head(20)};\n\nsay \"\\nNumber of words whose base 36 digital sum is prime: \",\n    @words.grep({ !.contains(/\\W/) && .comb».parse-base(36).sum.is-prime }).&{display +$_, .head(20)};\n\nsay \"\\nNumber of words that are prime in base 36, and whose digital sum is prime: \",\n    @words.grep({ !.contains(/\\W/) && :36($_).is-prime && .comb».parse-base(36).sum.is-prime }).&{display +$_, .head(20)};\n\nsay \"\\nNumber of words that are prime in base 36, whose digits are all prime, and whose digital sum is prime: \",\n    @words.hyper.grep({ !.contains(/\\W/) && all(.comb».parse-base(36)).is-prime && :36($_).is-prime && .comb».parse-base(36).sum.is-prime }).&{display +$_, $_, ''};\n\nuse Base::Any:ver<0.1.2+>;\nset-digits('a'..'z');\n\nsay \"\\n\\nTests using a custom base 26 where 'a' through 'z' is 0 through 25 and words are case folded:\";\n\nsay \"\\nNumber of words whose 'digits' are all prime using a custom base 26: \",\n    @words.hyper.grep({ !.contains(/<-alpha>/) && all(.comb».&from-base(26)).is-prime }).&{display +$_, $_, ''};\n\nsay \"\\nNumber of words that are prime using a custom base 26: \",\n    @words.grep({ !.contains(/<-alpha>/) && .&from-base(26).is-prime }).&{display +$_, .head(20)};\n\nsay \"\\nNumber of words whose digital sum is prime using a custom base 26: \",\n    @words.grep({ !.contains(/<-alpha>/) && .comb».&from-base(26).sum.is-prime }).&{display +$_, .head(20)};\n\nsay \"\\nNumber of words that are prime in a custom base 26 and whose digital sum is prime in that base: \",\n    @words.grep({ !.contains(/<-alpha>/) && .&from-base(26).is-prime && .comb».&from-base(26).sum.is-prime }).&{display +$_, .head(20)};\n\nsay \"\\nNumber of words that are prime in custom base 26, whose digits are all prime, and whose digital sum is prime: \",\n    @words.hyper.grep({ !.contains(/<-alpha>/) && all(.comb».&from-base(26)).is-prime && .&from-base(26).is-prime && .comb».&from-base(26).sum.is-prime }).&{display +$_, $_, ''};\n\n```\n\nOutput:\n\n```\nNumber of words whose ords are all prime: 36;\na, aaa, age, agee, ak, am, ama, e, egg, eke, em, emma, g, ga, gag, gage, gam, game, gamma, ge, gee, gem, gemma, gm, k, keg, m, ma, mae, magma, make, mamma, me, meek, meg, q\n\nNumber of words whose ordinal sum is prime: 3778;\nFirst 20: 10th, 9th, a, a's, aau, ababa, abate, abhorred, abject, ablate, aboard, abrade, abroad, absentee, absentia, absolute, absorptive, absurd, abusive, accelerate\n\nNumber of words whose ords are all prime, and whose ordinal sum is prime: 12;\na, e, egg, g, gem, k, keg, m, mae, mamma, meg, q\n\n\nInterpreting the words as if they were base 36 numbers:\n\nNumber of words whose 'digits' are all prime in base 36: 18;\n2nd, 5th, 7th, b, d, h, j, n, nd, nh, nj, nv, t, tn, tnt, tv, v, vt\n\nNumber of words that are prime in base 36: 1106;\nFirst 20: 10th, 1st, 2nd, 5th, 6th, 7th, abandon, abbott, abdomen, ablution, abolish, abort, abrupt, absorb, abstention, abstract, abutted, accept, accident, acid\n\nNumber of words whose base 36 digital sum is prime: 4740;\nFirst 20: 10th, 3rd, 7th, aba, abacus, abalone, abase, abater, abelian, abelson, aberrant, abeyant, ablaze, abort, aboveground, abraham, abrasion, abrasive, abreact, abridge\n\nNumber of words that are prime in base 36, and whose digital sum is prime: 300;\nFirst 20: 10th, 7th, abort, accident, acid, ad, adorn, adulthood, afterthought, albeit, alvin, armload, around, arragon, arraign, assassin, asteroid, astound, augean, avocation\n\nNumber of words that are prime in base 36, whose digits are all prime, and whose digital sum is prime: 8;\n7th, b, d, h, j, n, t, v\n\n\nTests using a custom base 26 where 'a' through 'z' is 0 through 25 and words are case folded:\n\nNumber of words whose 'digits' are all prime using a custom base 26: 30;\nc, cdc, cf, crt, ct, d, dc, dr, f, fcc, fl, ft, ftc, h, l, ltd, n, nc, ncr, nd, nh, nrc, r, rd, t, tn, tnt, ttl, tx, x\n\nNumber of words that are prime using a custom base 26: 987;\nFirst 20: abhorrent, abolish, abreact, absurd, ac, act, actual, actuarial, ad, adjutant, adult, advisor, aerosol, aft, agent, agricultural, ah, aid, ajar, al\n\nNumber of words whose digital sum is prime using a custom base 26: 5473;\nFirst 20: ababa, aback, abacus, abalone, abase, abater, abc, abdicate, abdomen, abe, abelian, abelson, aberrant, abeyant, ablaze, abolish, abominate, aborigine, aboveground, abraham\n\nNumber of words that are prime in a custom base 26 and whose digital sum is prime in that base: 292;\nFirst 20: abolish, abreact, absurd, ac, ad, adjutant, adult, agricultural, ah, aid, al, allah, allied, altar, an, annal, ar, arclength, argonaut, asocial\n\nNumber of words that are prime in custom base 26, whose digits are all prime, and whose digital sum is prime: 9;\nc, d, f, h, l, n, r, t, x\n```"}]}
{"messages": [{"role": "user", "content": "The concept, is to add the decomposition into prime factors of a number to get its 'ancestors'.\n\nThe objective is to demonstrate that the choice of the algorithm can be crucial in term of performance.\nThis solution could be compared to the solution that would use the decomposition into primes for all the numbers between 1 and 333.\n\nThe problem is to list, for a delimited set of ancestors (from 1 to 99) :\n\n- the total of their own ancestors (LEVEL),\n\n- their own ancestors (ANCESTORS),\n\n- the total of the direct descendants (DESCENDANTS),\n\n- all the direct descendants.\n\nYou only have to consider the prime factors < 100.\n\nA grand total of the descendants has to be printed at the end of the list.\n\nThe task should be accomplished in a reasonable time-frame.\n\nExample :\n\n```\n46 = 2*23 --> 2+23 = 25, is the parent of 46.\n25 = 5*5  --> 5+5  = 10, is the parent of 25.\n10 = 2*5  --> 2+5  = 7,  is the parent of 10.\n7 is a prime factor and, as such, has no parent.\n\n46 has 3 ancestors (7, 10 and 25).\n\n129 = 3x43 is a descendant, because 3+43 = 46.\n888 = 2x2x2x3x37 also, because 2+2+2+3+37 = 46.\n\n46 has 557 descendants.\n```\n\nThe list layout and the output for Parent [46] :\n\n```\n[46] Level: 3\nAncestors: 7, 10, 25\nDescendants: 557\n129, 205, 246, 493, 518, 529, 740, 806, 888, 999, 1364, 1508, 1748, 2552, 2871, 3128, 3255, 3472, 3519, 3875, 3906, 4263, 4650, 4960, 5075, 5415, 5580, 5776, 5952, 6090, 6279, 6496, 6498, 6696, 6783, 7250, 7308, 7475, 7533, 8075, 8151, 8619, 8700, 8855, 8970, 9280, 9568, 9690, 10115, 10336, 10440, 10626, 10764, 11136, 11495, 11628, 11745, 12103, 12138, 12155, 12528, 12650, 13794, 14094, 14399, 14450, 14586, 15180, 15379, 15778, 16192, 17290, 17303, 17340, 18216, 18496, 20482, 20493, 20570, 20748, 20808, 21658, 21970, 22540, 23409, 24684, 24700, 26026, 26364, 27048, 29260, 29282, 29640, 30429, 30940, 31616, 32200, 33345, 35112, 35568, 36225, 36652, 37128, 37180, 38640, 39501, 40014, 41216, 41769, 41800, 43125, 43470, 44044, 44200, 44616, 46000, 46368, 47025, 49725, 50160, 50193, 51750, 52136, 52164, 52360, 53040, 53504, 55200, 56430, 56576, 58653, 58880, 58905, 59670, 60192, 62100, 62832, 62920, 63648, 66240, 66248, 67716, 69825, 70125, 70656, 70686, 70785, 71604, 74480, 74520, 74529, 74536, 74800, 75504, 79488, 83125, 83790, 83835, 83853, 84150, 84942, 87465, 88725, 89376, 89424, 89760, 93296, 94640, 95744, 99750, 99825, 100548, 100602, 100980, 104125, 104958, 105105, 105625, 106400, 106470, 106480, 107712, 112112, 113568, 118750, 119700, 119790, 121176, 124509, 124950, 125125, 126126, 126750, 127680, 127764, 127776, 133280, 135200, 136192, 136323, 142500, 143640, 143748, 148225, 148750, 149940, 150150, 152000, 152100, 153216, 156065, 159936, 160160, 161595, 162240, 171000, 172368, 173056, 177870, 178500, 178750, 179928, 180180, 182400, 182520, 184877, 187278, 189728, 190400, 192192, 192375, 193914, 194560, 194688, 202419, 205200, 205335, 211750, 212500, 213444, 214200, 214500, 216216, 218880, 219024, 222950, 228480, 228800, 230850, 233472, 240975, 243243, 243712, 246240, 246402, 254100, 255000, 257040, 257400, 262656, 264110, 267540, 271040, 272000, 274176, 274560, 277020, 285376, 286875, 289170, 289575, 292864, 295488, 302500, 304920, 306000, 308448, 308880, 316932, 318500, 321048, 325248, 326400, 329472, 332424, 343035, 344250, 347004, 347490, 348160, 361179, 363000, 365904, 367200, 370656, 373977, 377300, 382200, 387200, 391680, 407680, 408375, 411642, 413100, 416988, 417792, 429975, 435600, 440640, 452760, 455000, 458640, 464640, 470016, 470596, 482944, 489216, 490050, 495616, 495720, 509355, 511875, 515970, 522720, 528768, 539000, 543312, 546000, 550368, 557568, 557685, 582400, 588060, 594864, 606375, 609375, 611226, 614250, 619164, 627264, 646800, 650000, 655200, 669222, 672280, 689920, 698880, 705672, 721875, 727650, 731250, 737100, 745472, 756315, 770000, 776160, 780000, 786240, 793881, 806736, 827904, 832000, 838656, 859375, 866250, 873180, 877500, 884520, 900375, 907578, 924000, 931392, 936000, 943488, 960400, 985600, 995085, 998400, 1031250, 1039500, 1047816, 1053000, 1061424, 1064960, 1071875, 1080450, 1100000, 1108800, 1123200, 1152480, 1178793, 1182720, 1184625, 1194102, 1198080, 1229312, 1237500, 1247400, 1261568, 1263600, 1277952, 1286250, 1296540, 1320000, 1330560, 1347840, 1372000, 1382976, 1403325, 1408000, 1419264, 1421550, 1437696, 1485000, 1496880, 1516320, 1531250, 1543500, 1555848, 1584000, 1596672, 1617408, 1646400, 1670625, 1683990, 1689600, 1705860, 1750329, 1756160, 1782000, 1796256, 1802240, 1819584, 1837500, 1852200, 1900800, 1960000, 1975680, 2004750, 2020788, 2027520, 2047032, 2083725, 2107392, 2138400, 2162688, 2187500, 2205000, 2222640, 2280960, 2302911, 2352000, 2370816, 2405700, 2433024, 2480625, 2500470, 2508800, 2566080, 2625000, 2646000, 2667168, 2737152, 2800000, 2822400, 2886840, 2953125, 2976750, 3000564, 3010560, 3079296, 3125000, 3150000, 3175200, 3211264, 3247695, 3360000, 3386880, 3464208, 3515625, 3543750, 3572100, 3584000, 3612672, 3750000, 3780000, 3810240, 3897234, 4000000, 4032000, 4064256, 4218750, 4252500, 4286520, 4300800, 4500000, 4536000, 4572288, 4587520, 4800000, 4822335, 4838400, 5062500, 5103000, 5120000, 5143824, 5160960, 5400000, 5443200, 5505024, 5740875, 5760000, 5786802, 5806080, 6075000, 6123600, 6144000, 6193152, 6480000, 6531840, 6553600, 6834375, 6889050, 6912000, 6967296, 7290000, 7348320, 7372800, 7776000, 7838208, 7864320, 8201250, 8266860, 8294400, 8388608, 8748000, 8817984, 8847360, 9331200, 9437184, 9841500, 9920232, 9953280, 10497600, 10616832, 11160261, 11197440, 11809800, 11943936, 12597120, 13286025, 13436928, 14171760, 15116544, 15943230, 17006112, 19131876\n```\n\nSome figures :\n\n```\nThe biggest descendant number : 3^33 = 5.559.060.566.555.523 (parent 99)\n\nTotal Descendants 546.986\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.11\n\n```\nmy $max = 99;\nmy @primes = (2 .. $max).grep: *.is-prime;\nmy %tree;\n(1..$max).map: {\n    %tree{$_}<ancestor> = ();\n    %tree{$_}<descendants> = {};\n};\n\n\nsub allocate ($n, $i = 0, $sum = 0, $prod = 1) {\n    return if $n < 4;\n    for @primes.kv -> $k, $p {\n        next if $k < $i;\n        if ($sum + $p) <= $n {\n            allocate($n, $k, $sum + $p, $prod * $p);\n        } else {\n            last if $sum == $prod;\n            %tree{$sum}<descendants>{$prod} = True;\n            last if $prod > $max;\n            %tree{$prod}<ancestor> = %tree{$sum}<ancestor> (|) $sum;\n            last;\n        }\n    }\n}\n\n# abbreviate long lists to first and last 5 elements\nsub abbrev (@d) { @d < 11 ?? @d !! ( @d.head(5), '...', @d.tail(5) ) }\n\nmy @print = flat 1 .. 15, 46, 74, $max;\n\n(1 .. $max).map: -> $term {\n    allocate($term);\n\n    if $term == any( @print )  # print some representative lines\n    {\n        my $dn = +%tree{$term}<descendants> // 0;\n        my $dl = abbrev(%tree{$term}<descendants>.keys.sort( +*) // ());\n        printf \"%2d, %2d Ancestors: %-14s %5d Descendants: %s\\n\",\n          $term, %tree{$term}<ancestor>,\n          \"[{ %tree{$term}<ancestor>.keys.sort: +* }],\", $dn, \"[$dl]\";\n    }\n}\n\nsay \"\\nTotal descendants: \",\n  sum (1..$max).map({ +%tree{$_}<descendants> });\n\n```\n\nOutput:\n\n```\n 1,  0 Ancestors: [],                0 Descendants: []\n 2,  0 Ancestors: [],                0 Descendants: []\n 3,  0 Ancestors: [],                0 Descendants: []\n 4,  0 Ancestors: [],                0 Descendants: []\n 5,  0 Ancestors: [],                1 Descendants: [6]\n 6,  1 Ancestors: [5],               2 Descendants: [8 9]\n 7,  0 Ancestors: [],                2 Descendants: [10 12]\n 8,  2 Ancestors: [5 6],             3 Descendants: [15 16 18]\n 9,  2 Ancestors: [5 6],             4 Descendants: [14 20 24 27]\n10,  1 Ancestors: [7],               5 Descendants: [21 25 30 32 36]\n11,  0 Ancestors: [],                5 Descendants: [28 40 45 48 54]\n12,  1 Ancestors: [7],               7 Descendants: [35 42 50 60 64 72 81]\n13,  0 Ancestors: [],                8 Descendants: [22 56 63 75 80 90 96 108]\n14,  3 Ancestors: [5 6 9],          10 Descendants: [33 49 70 84 100 120 128 135 144 162]\n15,  3 Ancestors: [5 6 8],          12 Descendants: [26 44 105 112 125 ... 160 180 192 216 243]\n46,  3 Ancestors: [7 10 25],       557 Descendants: [129 205 246 493 518 ... 14171760 15116544 15943230 17006112 19131876]\n74,  5 Ancestors: [5 6 8 16 39],  6336 Descendants: [213 469 670 793 804 ... 418414128120 446308403328 470715894135 502096953744 564859072962]\n99,  1 Ancestors: [17],          38257 Descendants: [194 1869 2225 2670 2848 ... 3904305912313344 4117822641892980 4392344151352512 4941387170271576 5559060566555523]\n\nTotal descendants: 546986\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow on this page those primes under   **1,000**   which when expressed in decimal contain only one odd digit.\n\nStretch goal\n\nShow on this page only the   count   of those primes under   **1,000,000**   which when expressed in decimal contain only one odd digit."}, {"role": "assistant", "content": "```\nput display ^1000 .grep: { ($_ % 2) && .is-prime && (.comb[^(*-1)].all %% 2) }\n\nsub display ($list, :$cols = 10, :$fmt = '%6d', :$title = \"{+$list} matching:\\n\" )   {\n    cache $list;\n    $title ~ $list.batch($cols)».fmt($fmt).join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\n45 matching:\n     3      5      7     23     29     41     43     47     61     67\n    83     89    223    227    229    241    263    269    281    283\n   401    409    421    443    449    461    463    467    487    601\n   607    641    643    647    661    683    809    821    823    827\n   829    863    881    883    887\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind primes   **n**   (in base ten)   whose first and last decimal digit is   **3**,   and where   **n   <   4,000**.\n\nShow all output here on this page.\n\nStretch goal\n\nFind and show only the   *number*   of these types of primes   that are   **<   1,000,000**."}, {"role": "assistant", "content": "```\nmy $upto = 1e4;\n\nfor 1,3,5,7,9 -> $bracket {\n    print \"\\nPrimes up to $upto bracketed by $bracket - \";\n    say display ^$upto .grep: { .starts-with($bracket) && .ends-with($bracket) && .is-prime }\n}\n\nsub display ($list, :$cols = 10, :$fmt = '%6d', :$title = \"{+$list} matching:\\n\" )   {\n    cache $list;\n    $title ~ $list.batch($cols)».fmt($fmt).join: \"\\n\"\n}\n\n```\n\nOutput:\n\n```\nPrimes up to 10000 bracketed by 1 - 39 matching:\n    11    101    131    151    181    191   1021   1031   1051   1061\n  1091   1151   1171   1181   1201   1231   1291   1301   1321   1361\n  1381   1451   1471   1481   1511   1531   1571   1601   1621   1721\n  1741   1801   1811   1831   1861   1871   1901   1931   1951\n\nPrimes up to 10000 bracketed by 3 - 33 matching:\n     3    313    353    373    383   3023   3083   3163   3203   3253\n  3313   3323   3343   3373   3413   3433   3463   3533   3583   3593\n  3613   3623   3643   3673   3733   3793   3803   3823   3833   3853\n  3863   3923   3943\n\nPrimes up to 10000 bracketed by 5 - 1 matching:\n     5\n\nPrimes up to 10000 bracketed by 7 - 35 matching:\n     7    727    757    787    797   7027   7057   7127   7177   7187\n  7207   7237   7247   7297   7307   7417   7457   7477   7487   7507\n  7517   7537   7547   7577   7607   7687   7717   7727   7757   7817\n  7867   7877   7907   7927   7937\n\nPrimes up to 10000 bracketed by 9 - 29 matching:\n   919    929   9029   9049   9059   9109   9199   9209   9239   9319\n  9349   9419   9439   9479   9539   9619   9629   9649   9679   9689\n  9719   9739   9749   9769   9829   9839   9859   9929   9949\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow primes which sum of its decimal digits is   **25**\n\nFind primes      **n**      such that      **n  <  5000**\n\nStretch goal\n\nShow the count of all such primes that do not contain any zeroes in the range:\n\n:   :   :   (997   ≤   **n**   ≤   1,111,111,111,111,111,111,111,111)."}, {"role": "assistant", "content": "```\nunit sub MAIN ($limit = 5000);\nsay \"{+$_} primes < $limit with digital sum 25:\\n{$_».fmt(\"%\" ~ $limit.chars ~ \"d\").batch(10).join(\"\\n\")}\",\n    with ^$limit .grep: { .is-prime and .comb.sum == 25 }\n\n```\n\nOutput:\n\n```\n17 primes < 5000 with digital sum 25:\n 997 1699 1789 1879 1987 2689 2797 2887 3499 3697\n3769 3877 3967 4597 4759 4957 4993\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind all primes   (**n**)   with their decimal digits in non-decreasing order,   where   **n   <   1,000**"}, {"role": "assistant", "content": "```\nmy $range = ^1000;\n\nfor flat 2..10, 17, 27, 31 -> $base {\n   say \"\\nBase $base: {+$_} non-decending primes between $range.minmax.map( *.base: $base ).join(' and '):\\n{\n      .batch(20)».fmt(\"%{.tail.chars}s\").join: \"\\n\" }\"\n       given $range.grep( *.is-prime ).map( *.base: $base ).grep: { [le] .comb }\n}\n\n```\n\nOutput:\n\n```\nBase 2: 4 non-decending primes between 0 and 1111100111:\n     11     111   11111 1111111\n\nBase 3: 6 non-decending primes between 0 and 1101000:\n   2   12  111  122 1112 1222\n\nBase 4: 17 non-decending primes between 0 and 33213:\n    2     3    11    13    23   113   133   223   233  1223  1333  2333 11123 11233 11333 12233 22223\n\nBase 5: 17 non-decending primes between 0 and 12444:\n    2     3    12    23    34   111   122   133  1112  1123  1233  1244  2223  2344  3444 11122 12222\n\nBase 6: 37 non-decending primes between 0 and 4343:\n   2    3    5   11   15   25   35   45  111  115  125  135  155  225  245  255  335  345  445  455\n1115 1125 1145 1235 1245 1335 1345 1355 1445 1555 2225 2335 2345 2555 3445 3455 3555\n\nBase 7: 38 non-decending primes between 0 and 2625:\n   2    3    5   14   16   23   25   56  113  115  124  133  146  155  166  245  256  335  344  346\n 445  566 1112 1123 1136 1156 1222 1226 1235 1345 1444 1466 2234 2236 2333 2335 2366 2555\n\nBase 8: 47 non-decending primes between 0 and 1747:\n   2    3    5    7   13   15   23   27   35   37   45   57  111  117  123  145  147  155  177  225\n 227  235  247  255  277  337  345  357  445  467  557  577  667 1113 1127 1137 1145 1167 1223 1225\n1245 1335 1347 1357 1467 1555 1567\n\nBase 9: 45 non-decending primes between 0 and 1330:\n   2    3    5    7   12   14   18   25   34   45   47   58   67   78  117  122  124  128  135  155\n 177  234  238  267  278  337  344  355  377  447  557  568  667  678  788 1112 1114 1118 1147 1158\n1178 1222 1255 1268 1288\n\nBase 10: 50 non-decending primes between 0 and 999:\n  2   3   5   7  11  13  17  19  23  29  37  47  59  67  79  89 113 127 137 139\n149 157 167 179 199 223 227 229 233 239 257 269 277 337 347 349 359 367 379 389\n449 457 467 479 499 557 569 577 599 677\n\nBase 17: 82 non-decending primes between 0 and 37D:\n  2   3   5   7   B   D  12  16  1C  1E  23  27  29  2D  38  3A  3G  45  4B  4F\n 5C  5G  67  6B  78  7C  8D  8F  9A  9E  AB  BC  FG 111 115 117 11B 128 12E 137\n139 13D 14A 14G 155 159 15F 166 16A 17B 17D 188 18E 19F 1BB 1BF 1CG 1DD 1EE 1GG\n225 227 23C 23E 247 24D 24F 25A 25E 26B 27C 28D 29C 2AD 2CF 33B 346 34C 35F 368\n36E 37B\n\nBase 27: 103 non-decending primes between 0 and 1A0:\n  2   3   5   7   B   D   H   J   N  12  14  1A  1E  1G  1K  1Q  25  27  2D  2H\n 2J  2P  38  3G  3K  3M  3Q  45  4J  4N  5E  5G  5M  6B  6H  6J  78  7A  7M  8B\n 8D  8H  8N  8P  9E  9K  9Q  AB  AD  AN  BE  BG  BK  CD  CN  CP  DG  DM  EJ  EN\n FG  FQ  GH  GP  HK  IN  KN  LQ  MN  MP  NQ  OP  PQ 111 115 11D 11H 124 12E 12Q\n13B 13D 13H 13J 14G 14K 14M 14Q 15D 15H 15J 15N 16G 16K 17B 17J 17N 188 18M 18Q\n19B 19J 19P\n\nBase 31: 94 non-decending primes between 0 and 117:\n  2   3   5   7   B   D   H   J   N   T  16  1A  1C  1G  1M  1S  1U  25  29  2B\n 2H  2L  2R  34  38  3A  3E  3G  3K  47  4D  4F  4P  4R  58  5C  5I  5O  5Q  67\n 6B  6D  6P  7A  7C  7G  7M  7O  89  8F  8L  8N  8T  9E  9S  AL  AR  BC  BI  BQ\n CH  CP  CT  DG  DI  DS  DU  EF  EN  ER  ET  FM  FQ  GP  GR  HK  HU  IJ  IT  JO\n JS  JU  KL  KN  KR  LM  LQ  MR  NQ  NU  OP  OT  TU 115\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n* Find and display the first 45 (**n**) primes of the form **n × 2m + 1** where **m** is the smallest valid non-negative integer.\n\nStretch\n\n* Find and display the first 50 (**n**) primes of the form **n × 2m + 1** where **m** is the smallest valid non-negative integer.\n\nStretch harder\n\n* Find and display the first 400 (**n**) primes of the form **n × 2m + 1** where **m** is the smallest valid non-negative integer. *Specifically term 383.*\n\nSee also\n\nA050921 - Smallest prime of form n\\*2^m+1"}, {"role": "assistant", "content": "First 382 in less than a second. 383 pushes the total accumulated time over 25 seconds.\n\n```\n-> $n { (^∞).map: -> $m { if (my $p = $n × 2 ** $m + 1).is-prime { printf \"%3d %4d: %d\\n\",$n,$m,$p; last } } } for 1..400\n\n```\n\nOutput:\n\n```\n  1    0: 2\n  2    0: 3\n  3    1: 7\n  4    0: 5\n  5    1: 11\n  6    0: 7\n  7    2: 29\n  8    1: 17\n  9    1: 19\n 10    0: 11\n 11    1: 23\n 12    0: 13\n 13    2: 53\n 14    1: 29\n 15    1: 31\n 16    0: 17\n 17    3: 137\n 18    0: 19\n 19    6: 1217\n 20    1: 41\n 21    1: 43\n 22    0: 23\n 23    1: 47\n 24    2: 97\n 25    2: 101\n 26    1: 53\n 27    2: 109\n 28    0: 29\n 29    1: 59\n 30    0: 31\n 31    8: 7937\n 32    3: 257\n 33    1: 67\n 34    2: 137\n 35    1: 71\n 36    0: 37\n 37    2: 149\n 38    5: 1217\n 39    1: 79\n 40    0: 41\n 41    1: 83\n 42    0: 43\n 43    2: 173\n 44    1: 89\n 45    2: 181\n 46    0: 47\n 47  583: 1487939695262196876907983166454197495251350196192890428923003345454869706240895712896623468784438158657419591298913094265537812046389415279164757669092989298186306341246574002177\n 48    1: 97\n 49    2: 197\n 50    1: 101\n 51    1: 103\n 52    0: 53\n 53    1: 107\n 54    1: 109\n 55    4: 881\n 56    1: 113\n 57    2: 229\n 58    0: 59\n 59    5: 1889\n 60    0: 61\n 61    4: 977\n 62    7: 7937\n 63    1: 127\n 64    2: 257\n 65    1: 131\n 66    0: 67\n 67    2: 269\n 68    1: 137\n 69    1: 139\n 70    0: 71\n 71    3: 569\n 72    0: 73\n 73    2: 293\n 74    1: 149\n 75    1: 151\n 76    4: 1217\n 77    3: 617\n 78    0: 79\n 79    2: 317\n 80    3: 641\n 81    1: 163\n 82    0: 83\n 83    1: 167\n 84    2: 337\n 85    4: 1361\n 86    1: 173\n 87    2: 349\n 88    0: 89\n 89    1: 179\n 90    1: 181\n 91    8: 23297\n 92    7: 11777\n 93    2: 373\n 94  582: 1487939695262196876907983166454197495251350196192890428923003345454869706240895712896623468784438158657419591298913094265537812046389415279164757669092989298186306341246574002177\n 95    1: 191\n 96    0: 97\n 97    2: 389\n 98    1: 197\n 99    1: 199\n100    0: 101\n101    3: 809\n102    0: 103\n103   16: 6750209\n104    5: 3329\n105    1: 211\n106    0: 107\n107    3: 857\n108    0: 109\n109    6: 6977\n110    3: 881\n111    1: 223\n112    0: 113\n113    1: 227\n114    1: 229\n115    2: 461\n116    1: 233\n117    3: 937\n118    4: 1889\n119    1: 239\n120    1: 241\n121    8: 30977\n122    3: 977\n123    6: 7873\n124    6: 7937\n125    1: 251\n126    0: 127\n127    2: 509\n128    1: 257\n129    3: 1033\n130    0: 131\n131    1: 263\n132    4: 2113\n133    4: 2129\n134    1: 269\n135    1: 271\n136    0: 137\n137    3: 1097\n138    0: 139\n139    2: 557\n140    1: 281\n141    1: 283\n142    2: 569\n143   53: 1288029493427961857\n144    2: 577\n145    6: 9281\n146    1: 293\n147    8: 37633\n148    0: 149\n149    3: 1193\n150    0: 151\n151    4: 2417\n152    3: 1217\n153    1: 307\n154    2: 617\n155    1: 311\n156    0: 157\n157    8: 40193\n158    1: 317\n159    6: 10177\n160    2: 641\n161    3: 1289\n162    0: 163\n163    2: 653\n164    9: 83969\n165    1: 331\n166    0: 167\n167    7: 21377\n168    1: 337\n169    2: 677\n170    3: 1361\n171    8: 43777\n172    0: 173\n173    1: 347\n174    1: 349\n175    2: 701\n176    1: 353\n177    2: 709\n178    0: 179\n179    1: 359\n180    0: 181\n181    4: 2897\n182    7: 23297\n183    1: 367\n184    6: 11777\n185    3: 1481\n186    1: 373\n187    6: 11969\n188  581: 1487939695262196876907983166454197495251350196192890428923003345454869706240895712896623468784438158657419591298913094265537812046389415279164757669092989298186306341246574002177\n189    1: 379\n190    0: 191\n191    1: 383\n192    0: 193\n193    2: 773\n194    1: 389\n195    4: 3121\n196    0: 197\n197   15: 6455297\n198    0: 199\n199    2: 797\n200    1: 401\n201    3: 1609\n202    2: 809\n203   13: 1662977\n204    1: 409\n205    2: 821\n206   15: 6750209\n207    2: 829\n208    4: 3329\n209    1: 419\n210    0: 211\n211   20: 221249537\n212    3: 1697\n213    2: 853\n214    2: 857\n215    1: 431\n216    1: 433\n217   66: 16011773855979890802689\n218    5: 6977\n219    1: 439\n220    2: 881\n221    1: 443\n222    0: 223\n223    8: 57089\n224    1: 449\n225    3: 1801\n226    0: 227\n227   11: 464897\n228    0: 229\n229    6: 14657\n230    1: 461\n231    1: 463\n232    0: 233\n233    1: 467\n234    2: 937\n235    2: 941\n236    3: 1889\n237    4: 3793\n238    0: 239\n239    1: 479\n240    0: 241\n241   36: 16561393893377\n242    7: 30977\n243    1: 487\n244    2: 977\n245    1: 491\n246    5: 7873\n247    6: 15809\n248    5: 7937\n249    1: 499\n250    0: 251\n251    1: 503\n252    2: 1009\n253    2: 1013\n254    1: 509\n255    2: 1021\n256    0: 257\n257  279: 249632952651006185613150855026822179503549278818199928480857894651449200648869292015617\n258    2: 1033\n259   38: 71193377898497\n260    1: 521\n261    1: 523\n262    0: 263\n263   29: 141197049857\n264    3: 2113\n265    2: 1061\n266    3: 2129\n267    2: 1069\n268    0: 269\n269    3: 2153\n270    0: 271\n271    4: 4337\n272   11: 557057\n273    1: 547\n274    2: 1097\n275    7: 35201\n276    0: 277\n277    2: 1109\n278    1: 557\n279    2: 1117\n280    0: 281\n281    1: 563\n282    0: 283\n283   30: 303868936193\n284    1: 569\n285    1: 571\n286   52: 1288029493427961857\n287    3: 2297\n288    1: 577\n289   10: 295937\n290    5: 9281\n291    4: 4657\n292    0: 293\n293    1: 587\n294    7: 37633\n295    2: 1181\n296    1: 593\n297    3: 2377\n298    2: 1193\n299    1: 599\n300    1: 601\n301    4: 4817\n302    3: 2417\n303    1: 607\n304    2: 1217\n305    3: 2441\n306    0: 307\n307    2: 1229\n308    1: 617\n309    1: 619\n310    0: 311\n311    9: 159233\n312    0: 313\n313    4: 5009\n314    7: 40193\n315    1: 631\n316    0: 317\n317    7: 40577\n318    5: 10177\n319    2: 1277\n320    1: 641\n321    1: 643\n322    2: 1289\n323    1: 647\n324    2: 1297\n325    2: 1301\n326    1: 653\n327    3: 2617\n328    8: 83969\n329    1: 659\n330    0: 331\n331    4: 5297\n332    3: 2657\n333    5: 10657\n334    6: 21377\n335   19: 175636481\n336    0: 337\n337    4: 5393\n338    1: 677\n339    3: 2713\n340    2: 1361\n341    1: 683\n342    7: 43777\n343    2: 1373\n344    3: 2753\n345    1: 691\n346    0: 347\n347    3: 2777\n348    0: 349\n349   10: 357377\n350    1: 701\n351   12: 1437697\n352    0: 353\n353   21: 740294657\n354    1: 709\n355    6: 22721\n356    5: 11393\n357    2: 1429\n358    0: 359\n359    1: 719\n360    6: 23041\n361   28: 96905199617\n362    3: 2897\n363    1: 727\n364    6: 23297\n365    5: 11681\n366    0: 367\n367   12: 1503233\n368    5: 11777\n369    1: 739\n370    2: 1481\n371    1: 743\n372    0: 373\n373    2: 1493\n374    5: 11969\n375    1: 751\n376  580: 1487939695262196876907983166454197495251350196192890428923003345454869706240895712896623468784438158657419591298913094265537812046389415279164757669092989298186306341246574002177\n377   11: 772097\n378    0: 379\n379   14: 6209537\n380    1: 761\n381    3: 3049\n382    0: 383\n383 6393: 11693945185971565896920916176753769281418376445302724140914106576604960252116205468905429628661873192664799900323401294531072465400997845029722990758855393414014415817179228695517839305455702961095094596926622802342799137107509767542153683280899327558274011281588755909890607960835140712630830933978801393590855371457894042968287926562847826310125559303901351824980311279986492793008248059208985097459095049075732193161126922389950080848742183055141518931962329796357335158955758486061360294773463111842316561192036096585088267052290025273980611139612478214293303564141730470933187279751846912161098280963960686648202780382930927114525552446602357404550468641236474238897222372272898562140228039886991631673186995098587756569010989657598363351856992206826342175536967926902668804937341514786382018872919876784539436965319822540039220122728568129762675989071883516915894567537630751801497223803135172643203770169327233350522822938630733126833423559124391441973547309619943019237705312515304113424366223388373606440335025932390399945086075175009569272136997988977568262327875607690344516747889133920438003737328060362069562108376086129279385800262195985974144460914705464874882401864174074796383557151951711000378565395148939760434428093058777242253682181813425273399277638142811972296863003382484684788329148214958434057306251885787781329925372401240556666727438408378656900945061970219566055969587385482421092779185798692904507774583223151161566406541599486350580593707153172641891804260963429951215526999443852964537303345106153870841180251403751871193132336680841124129779119999935597712685839886558769823834654994044516702436738265181698869580022472787153167463772595005393815295009535991557511340157179280662197799109181549751673455040271529561595718940092424231253150263268513067972937042222806102175350331146290864120703025608712817763221723427454002746818270565050919821097445991953785331131470462682015972815241620750337\n384    1: 769\n385    8: 98561\n386    1: 773\n387    2: 1549\n388    0: 389\n389   11: 796673\n390    3: 3121\n391    4: 6257\n392    3: 3137\n393    1: 787\n394   14: 6455297\n395    5: 12641\n396    0: 397\n397    4: 6353\n398    1: 797\n399    2: 1597\n400    0: 401\n```"}]}
{"messages": [{"role": "user", "content": "Primorial numbers are those formed by multiplying successive prime numbers.\n\nThe primorial number series is:\n\n:   :   * primorial(0) =         1       (by definition)\n        * primorial(1) =         2       (2)\n        * primorial(2) =         6       (2×3)\n        * primorial(3) =       30       (2×3×5)\n        * primorial(4) =     210       (2×3×5×7)\n        * primorial(5) =   2310       (2×3×5×7×11)\n        * primorial(6) = 30030       (2×3×5×7×11×13)\n        * **∙ ∙ ∙**\n\nTo express this mathematically,   **primorial*n***   is  \nthe product of the first   *n*   (successive) primes:\n\n:   p\n    r\n    i\n    m\n    o\n    r\n    i\n    a\n\n    l\n\n    n\n    =\n\n    ∏\n\n    k\n    =\n    1\n\n    n\n    p\n    r\n    i\n    m\n\n    e\n\n    k\n    {\\displaystyle {\\displaystyle primorial\\_{n}=\\prod \\_{k=1}^{n}prime\\_{k}}}\n\n:   :   :   :   :   :   ─── where   \n\n                        p\n                        r\n                        i\n                        m\n\n                        e\n\n                        k\n                        {\\displaystyle {\\displaystyle prime\\_{k}}}\n                           is the   *k**th* *prime number.*\n\nIn some sense, generating primorial numbers is similar to factorials.\n\nAs with factorials, primorial numbers get large quickly.\n\nTask\n\n* Show the first ten primorial numbers   (0 ──► 9,   inclusive).\n* Show the length of primorial numbers whose index is:   10   100   1,000   10,000   and   100,000.\n* Show the length of the one millionth primorial number   (optional).\n* Use exact integers, not approximations.\n\nBy   *length*   (above), it is meant the number of decimal digits in the numbers.\n\nRelated tasks\n\n* Sequence of primorial primes\n* Factorial\n* Fortunate\\_numbers\n\nSee also\n\n* the MathWorld webpage:   primorial\n* the Wikipedia   webpage:   primorial.\n* the   OEIS   webpage:   A002110."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Native Raku\n\nWith the module `Math::Primesieve`, this runs in about 1/3 the time vs the built in prime generator.\n\n**Works with**: Rakudo version 2018.09\n\n```\nuse Math::Primesieve;\n\nmy $sieve = Math::Primesieve.new;\nmy @primes = $sieve.primes(10_000_000);\n\nsub primorial($n) { [*] @primes[^$n] }\n\nsay \"First ten primorials: {(primorial $_ for ^10)}\";\nsay \"primorial(10^$_) has {primorial(10**$_).chars} digits\" for 1..5;\n\n```\n\nOutput:\n\n```\nFirst ten primorials: 1 2 6 30 210 2310 30030 510510 9699690 223092870\nprimorial(10^1) has 10 digits\nprimorial(10^2) has 220 digits\nprimorial(10^3) has 3393 digits\nprimorial(10^4) has 45337 digits\nprimorial(10^5) has 563921 digits\n```\n\n### Imported library\n\nFor a real speed boost, load the Perl 5 ntheory library.\n\n**Library:** ntheory\n\n```\nuse Lingua::EN::Numbers;\nuse ntheory:from<Perl5> <pn_primorial>;\n\nsay \"First ten primorials: \", ^10 .map( { pn_primorial($_) } ).join: ', ';\n\n for 1..8 {\n    my $now = now;\n    printf \"primorial(10^%d) has %-11s digits - %s\\n\", $_,\n        comma(pn_primorial(10**$_).Str.chars),\n        \"Elapsed seconds: {(now - $now).round: .001}\";\n}\n\n```\n\n```\nFirst ten primorials: 1, 2, 6, 30, 210, 2310, 30030, 510510, 9699690, 223092870\nprimorial(10^1) has 10          digits - Elapsed seconds: 0.002\nprimorial(10^2) has 220         digits - Elapsed seconds: 0.015\nprimorial(10^3) has 3,393       digits - Elapsed seconds: 0.001\nprimorial(10^4) has 45,337      digits - Elapsed seconds: 0.005\nprimorial(10^5) has 563,921     digits - Elapsed seconds: 0.139\nprimorial(10^6) has 6,722,809   digits - Elapsed seconds: 3.015\nprimorial(10^7) has 77,919,922  digits - Elapsed seconds: 56.483\nprimorial(10^8) has 885,105,237 digits - Elapsed seconds: 981.71\n```"}]}
{"messages": [{"role": "user", "content": "From Wikipedia:\n\n> Print debugging (or tracing) is the act of watching (live or recorded) trace statements, or print statements, that indicate the flow of execution of a process. This is sometimes called printf debugging, due to the use of the printf function in C.\n\nTask\n\n* Show the print debugging statements in the language.\n* Demonstrate their ability to track provenance by displaying information about source code (e.g., code fragment, line and column number)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nThere isn't anything built-in to do this in Rakudo/Raku, though it's pretty easy to cobble something together piggybacking off of the exception system. It would probably be better to instantiate a specific \"DEBUG\" exception to avoid interfering with other user instantiated ad-hoc exceptions, but for a quick-and-dirty demo, this should suffice.\n\nThis example will report any payload contents passed to the exception. If you want specific information, it will need to be passed in, though some of it may be determinable through introspection. Reports the file name and line number where the \"debug\" call originated and unwinds the call stack to trace through the subroutine calls leading up to it. Will follow the call chain into included files and modules, though calls to the CORE setting and dispatcher are filtered out here to reduce noise.\n\nComments with the files line numbers are added here to make it easier to match up the debug output with the file. Typically you would be editing the file in an editor that provides line numbering so that wouldn't be necessary/helpful.\n\n```\nmy &pdb = &die;\n\nCATCH {\n    when X::AdHoc {\n        my @frames = .backtrace[*];\n        say .payload;\n        for @frames {\n            # Filter out exception handing and dispatcher frames\n            next if .file.contains: 'SETTING' or .subname.chars < 1;\n            printf \"%sfrom file: %s,%s line: %s\\n\",\n              (' ' x $++), .file,\n              (my $s = .subname) eq '<unit>' ?? '' !! \" sub: $s,\", .line;\n        }\n        say '';\n        .resume;\n    }\n    default {}\n}\n\n## Testing / demonstration\n\n# helper subs                #line 22\nsub alpha ($a) {             #line 23\n    pdb ('a =>', $a + 3);    #line 24\n    pdb 'string';            #line 25\n    beta(7);                 #line 26\n}                            #line 27\nsub beta  ($b) { pdb $b    } #line 28\nsub gamma ($c) { beta $c   } #line 29\nsub delta ($d) { gamma $d  } #line 30\n                             #line 31\nmy $a = 10;                  #line 32\npdb (.VAR.name, $_) with $a; #line 33\nalpha($a);                   #line 34\ndelta(\"Δ\");                  #line 35\n.&beta for ^3;               #line 36\n\n```\n\nOutput:\n\n```\n($a 10)\nfrom file: debug.p6, line: 33\n\n(a => 13)\nfrom file: debug.p6, sub: alpha, line: 24\n from file: debug.p6, line: 34\n\nstring\nfrom file: debug.p6, sub: alpha, line: 25\n from file: debug.p6, line: 34\n\n7\nfrom file: debug.p6, sub: beta, line: 28\n from file: debug.p6, sub: alpha, line: 26\n  from file: debug.p6, line: 34\n\nΔ\nfrom file: debug.p6, sub: beta, line: 28\n from file: debug.p6, sub: gamma, line: 29\n  from file: debug.p6, sub: delta, line: 30\n   from file: debug.p6, line: 35\n\n0\nfrom file: debug.p6, sub: beta, line: 28\n from file: debug.p6, line: 36\n\n1\nfrom file: debug.p6, sub: beta, line: 28\n from file: debug.p6, line: 36\n\n2\nfrom file: debug.p6, sub: beta, line: 28\n from file: debug.p6, line: 36\n```"}]}
{"messages": [{"role": "user", "content": "Create a program, which prints its source code to the stdout!\n\nRelated tasks\n:   * Quine.\n    * Entropy/Narcissist."}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.05\n\nNot really sure what the point of this task is.\n\nIs it supposed to be a quine?\n\n```\nmy &f = {say $^s, $^s.raku;}; f \"my \\&f = \\{say \\$^s, \\$^s.raku;}; f \"\n\n```\n\nOr just a program that when executed echoes its source to STDOUT? (Here's probably the simplest valid program that when executed, echoes its source to STDOUT. It is exceptionally short: zero bytes; and when executed echoes zero bytes to STDOUT.)\n\nOr are we supposed to demonstrate how to locate the currently executing source code file and incidentally, print it.\n\n```\nprint $*PROGRAM.slurp\n\n```\n\nWhatever. Any of these satisfy the rather vague specifications."}]}
{"messages": [{"role": "user", "content": "A priority queue is somewhat similar to a queue, with an important distinction: each item is added to a priority queue with a priority level, and will be later removed from the queue with the highest priority element first. That is, the items are (conceptually) stored in the queue in priority order instead of in insertion order.\n\nTask\n\nCreate a priority queue.   The queue must support at least two operations:\n\n:   1. Insertion.   An element is added to the queue with a priority (a numeric value).\n    2. Top item removal.   Deletes the element or one of the elements with the current top priority and return it.\n\nOptionally, other operations may be defined, such as peeking (find what current top priority/top element is), merging (combining two priority queues into one), etc.\n\nTo test your implementation, insert a number of elements into the queue, each with some random priority.\n\nThen dequeue them sequentially; now the elements should be sorted by priority.\n\nYou can use the following task/priority items as input data:\n\n```\n        Priority         Task\n       ══════════   ════════════════\n           3         Clear drains\n           4         Feed cat\n           5         Make tea\n           1         Solve RC tasks\n           2         Tax return\n\n```\n\nThe implementation should try to be efficient.   A typical implementation has   **O(log n)**   insertion and extraction time,   where   **n**   is the number of items in the queue.\n\nYou may choose to impose certain limits such as small range of allowed priority levels, limited capacity, etc.   If so, discuss the reasons behind it."}, {"role": "assistant", "content": "(formerly Perl 6)\nThis is a rather simple implementation. It requires the priority to be a positive integer value, with lower values being higher priority. There isn't a hard limit on how many priority levels you can have, though more than a few dozen is probably not practical.\n\nThe tasks are stored internally as an array of FIFO buffers, so multiple tasks of the same priority level will be returned in the order they were stored.\n\n```\nclass PriorityQueue {\n    has @!tasks;\n\n    method insert (Int $priority where * >= 0, $task) {\n        @!tasks[$priority].push: $task;\n    }\n\n    method get { @!tasks.first(?*).shift }\n\n    method is-empty { ?none @!tasks }\n}\n\nmy $pq = PriorityQueue.new;\n \nfor (\n    3, 'Clear drains',\n    4, 'Feed cat',\n    5, 'Make tea',\n    9, 'Sleep',\n    3, 'Check email',\n    1, 'Solve RC tasks',\n    9, 'Exercise',\n    2, 'Do taxes'\n) -> $priority, $task {\n    $pq.insert( $priority, $task );\n}\n \nsay $pq.get until $pq.is-empty;\n\n```\n\nOutput:\n\n```\nSolve RC tasks\nDo taxes\nClear drains\nCheck email\nFeed cat\nMake tea\nSleep\nExercise\n```"}]}
{"messages": [{"role": "user", "content": "Given a mapping between items and their required probability of occurrence, generate a million items *randomly* subject to the given probabilities and compare the target probability of occurrence versus the generated values.\n\nThe total of all the probabilities should equal one. (Because floating point arithmetic is involved, this is subject to rounding errors).\n\nUse the following mapping to test your programs:\n\n```\naleph   1/5.0\nbeth    1/6.0\ngimel   1/7.0\ndaleth  1/8.0\nhe      1/9.0\nwaw     1/10.0\nzayin   1/11.0\nheth    1759/27720 # adjusted so that probabilities add to 1\n```\n\nRelated task\n\n* Random number generator (device)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.10\n\n```\nconstant TRIALS = 1e6;\n \nconstant @event = <aleph beth gimel daleth he waw zayin heth>;\n \nconstant @P = flat (1 X/ 5 .. 11), 1759/27720;\nconstant @cP = [\\+] @P;\n \nmy atomicint @results[+@event];\n(^TRIALS).race.map: { @results[ @cP.first: { $_ > once rand }, :k ]⚛++; }\n\nsay  'Event    Occurred Expected  Difference';\nfor ^@results {\n    my ($occurred, $expected) = @results[$_], @P[$_] * TRIALS;\n    printf \"%-9s%8.0f%9.1f%12.1f\\n\",\n            @event[$_],\n                $occurred,\n                     $expected,\n                          abs $occurred - $expected;\n}\n\n```\n\nOutput:\n\n```\nEvent    Occurred Expected  Difference\naleph      200369 200000.0       369.0\nbeth       167005 166666.7       338.3\ngimel      142690 142857.1       167.1\ndaleth     125061 125000.0        61.0\nhe         110563 111111.1       548.1\nwaw        100214 100000.0       214.0\nzayin       90617  90909.1       292.1\nheth        63481  63456.0        25.0\n```"}]}
{"messages": [{"role": "user", "content": "Two solutions to the problem of Apollonius\n\nTask\n\nImplement a solution to the Problem of Apollonius   (description on Wikipedia)   which is the problem of finding the circle that is tangent to three specified circles   (colored black in the diagram below to the right).\n\nThere is an   algebraic solution   which is pretty straightforward.\n\nThe solutions to the example in the code are shown in the diagram   (below and to the right).\n\nThe red circle is \"internally tangent\" to all three black circles,   and the green circle is \"externally tangent\" to all three black circles."}, {"role": "assistant", "content": "(formerly Perl 6)\nThis program is written mostly in the \"sigilless\" style for several reasons. First, sigils tend to imply variables, and these sigilless symbols are not variables, but readonly bindings to values that are calculated only once, so leaving off the sigil emphasizes the fact that they are not variables, but merely named intermediate results.\n\nSecond, it looks more like the original mathematical formulas to do it this way.\n\nThird, together with the use of Unicode, we are emphasizing the social contract between the writer and the reader, which has a clause in it that indicates code is read much more often than it is written, therefore the writer is obligated to undergo vicarious suffering on behalf of the reader to make things clear. If the reader doesn't understand, it's the writer's fault, in other words. Or in other other words, figure out how to type those Unicode characters, even if it's hard. And you should type them whenever it makes things clearer to the reader.\n\nFinally, writing in an SSA style tends to help the optimizer.\n\n```\nclass Circle {\n   has $.x;\n   has $.y;\n   has $.r;\n   method gist { sprintf \"%s =%7.3f \" xx 3, (:$!x,:$!y,:$!r)».kv }\n}\n\nsub circle($x,$y,$r) { Circle.new: :$x, :$y, :$r }\n\nsub solve-Apollonius([\\c1, \\c2, \\c3], [\\s1, \\s2, \\s3]) {\n    my \\𝑣11 = 2 * c2.x - 2 * c1.x;\n    my \\𝑣12 = 2 * c2.y - 2 * c1.y;\n    my \\𝑣13 = c1.x² - c2.x² + c1.y² - c2.y² - c1.r² + c2.r²;\n    my \\𝑣14 = 2 * s2 * c2.r - 2 * s1 * c1.r;\n \n    my \\𝑣21 = 2 * c3.x - 2 * c2.x;\n    my \\𝑣22 = 2 * c3.y - 2 * c2.y;\n    my \\𝑣23 = c2.x² - c3.x² + c2.y² - c3.y² - c2.r² + c3.r²;\n    my \\𝑣24 = 2 * s3 * c3.r - 2 * s2 * c2.r;\n \n    my \\𝑤12 = 𝑣12 / 𝑣11;\n    my \\𝑤13 = 𝑣13 / 𝑣11;\n    my \\𝑤14 = 𝑣14 / 𝑣11;\n \n    my \\𝑤22 = 𝑣22 / 𝑣21 - 𝑤12;\n    my \\𝑤23 = 𝑣23 / 𝑣21 - 𝑤13;\n    my \\𝑤24 = 𝑣24 / 𝑣21 - 𝑤14;\n \n    my \\𝑃 = -𝑤23 / 𝑤22;\n    my \\𝑄 = 𝑤24 / 𝑤22;\n    my \\𝑀 = -𝑤12 * 𝑃 - 𝑤13;\n    my \\𝑁 = 𝑤14 - 𝑤12 * 𝑄;\n \n    my \\𝑎 = 𝑁² + 𝑄² - 1;\n    my \\𝑏 = 2 * 𝑀 * 𝑁 - 2 * 𝑁 * c1.x + 2 * 𝑃 * 𝑄 - 2 * 𝑄 * c1.y + 2 * s1 * c1.r;\n    my \\𝑐 = c1.x² + 𝑀² - 2 * 𝑀 * c1.x + 𝑃² + c1.y² - 2 * 𝑃 * c1.y - c1.r²;\n \n    my \\𝐷 = 𝑏² - 4 * 𝑎 * 𝑐;\n    my \\rs = (-𝑏 - sqrt 𝐷) / (2 * 𝑎);\n \n    my \\xs = 𝑀 + 𝑁 * rs;\n    my \\ys = 𝑃 + 𝑄 * rs;\n \n    circle(xs, ys, rs);\n}\n \nmy @c = circle(0, 0, 1), circle(4, 0, 1), circle(2, 4, 2);\nfor ([X] [-1,1] xx 3) -> @i {\n    say (solve-Apollonius @c, @i).gist;\n}\n\n```\n\nOutput:\n\n```\nx =  2.000  y =  0.833  r =  1.167\nx =  2.000  y =  3.214  r =  2.786\nx =  3.002  y =  0.123  r =  2.005\nx =  4.127  y =  3.252  r =  4.255\nx =  0.998  y =  0.123  r =  2.005\nx = -0.127  y =  3.252  r =  4.255\nx =  2.000  y = -1.500  r =  3.500\nx =  2.000  y =  2.100  r =  3.900\n```"}]}
{"messages": [{"role": "user", "content": "In order to represent evolutions of contents over time, the SMIL standard provides a solution to record the animation of data. Smil animations can be added to any kind of contents formated in XML.\n\n* SMIL on Wikipedia and at W3\n\nThe task is to create an utility that given the first Smiled XML file, would return the following ones:\n\n```\n<?xml version=\"1.0\" ?>\n<smil>\n<X3D>\n  <Scene>\n    <Viewpoint position=\"0 0 8\" orientation=\"0 0 1 0\"/>\n    <PointLight color='1 1 1' location='0 2 0'/>\n    <Shape>\n      <Box size='2 1 2'>\n        <animate attributeName=\"size\" from=\"2 1 2\"\n                                        to=\"1 2 1\" begin=\"0s\" dur=\"10s\"/>\n      </Box>\n      <Appearance>\n        <Material diffuseColor='0.0 0.6 1.0'>\n          <animate attributeName=\"diffuseColor\" from=\"0.0 0.6 1.0\"\n                                                  to=\"1.0 0.4 0.0\" begin=\"0s\" dur=\"10s\"/>\n        </Material>\n      </Appearance>\n    </Shape>\n  </Scene>\n</X3D>\n</smil>\n\n```\n\nAt t = 0 second here is the expected output:\n\n```\n<?xml version=\"1.0\" ?>\n<X3D>\n  <Scene>\n    <Viewpoint position=\"0 0 8\" orientation=\"0 0 1 0\"/>\n    <PointLight color='1 1 1' location='0 2 0'/>\n    <Shape>\n      <Box size='2 1 2'/>\n      <Appearance>\n        <Material diffuseColor='0.0 0.6 1.0'/>\n      </Appearance>\n    </Shape>\n  </Scene>\n</X3D>\n\n```\n\nAt t = 2 second here is the expected output:\n\n```\n<?xml version=\"1.0\" ?>\n<X3D>\n  <Scene>\n    <Viewpoint position=\"0 0 8\" orientation=\"0 0 1 0\"/>\n    <PointLight color='1 1 1' location='0 2 0'/>\n    <Shape>\n      <Box size='1.8 1.2 1.8'/>\n      <Appearance>\n        <Material diffuseColor='0.2 0.56 0.8'/>\n      </Appearance>\n    </Shape>\n  </Scene>\n</X3D>\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\nA crude attempt that only works with task data.\n\n```\nuse XML::XPath;\n\nmy $smil = q:to<DATA>; # cramped verison, modified from task data\n<?xml version=\"1.0\" ?> <smil><X3D><Scene><Viewpoint position=\"0 0 8\" orientation=\"0 0 1 0\" /><PointLight color=\"1 1 1\" location=\"0 2 0\" /><Shape><Box size=\"2 1 2\"><animate attributeName=\"size\" from=\"2 1 2\" to=\"1 2 1\" begin=\"0s\" dur=\"10s\" /></Box><Appearance><Material diffuseColor=\"0.0 0.6 1.0\"><animate attributeName=\"diffuseColor\" from=\"0.0 0.6 1.0\" to=\"1.0 0.4 0.0\" begin=\"0s\" dur=\"10s\" /></Material></Appearance></Shape></Scene></X3D></smil>\nDATA\n\nclass Animatee { has ($.todo, @.from, @.to, $.begin, $.dur) is rw };\n\nmy %Parents; # keys store the parent tags that got <animate> child\n\nmy $x = XML::XPath.new(xml => $smil) or die;\n\nfor @($x.find(\"//animate\")) { # strangely need .List or @ coercion to work\n   my $y = .parent.name;\n   %Parents{$y}:exists ?? die() !! %Parents{$y} = Animatee.new; # unique only\n   for .parent.elements {\n      %Parents{$y}.todo  = .attribs<attributeName>;\n      %Parents{$y}.from  = .attribs<from>.split(/\\s+/);\n      %Parents{$y}.to    = .attribs<to>.split(/\\s+/);\n      %Parents{$y}.begin = .attribs<begin>.match(/\\d+/);\n      %Parents{$y}.dur   = .attribs<dur>.match(/\\d+/);\n   }\n}\n\n# use regex to strip SMIL tag and create a master template; sub-optimal approach\nmy $z = XML::XPath.new(xml => $smil.subst(/\\<\\/?smil\\>/,'',:g:ii:ss)) or die;\n\nfor 0, 2, 4 -> $t { # task requires 0 & 2 only\n   my $clone = $z.clone; # work on a copy\n   for %Parents.kv -> $k,$v {\n      my @incre = ($v.to »-« $v.from) »/» $v.dur; # increment list\n      with $clone.find(\"//$k\") { # moving attribute = @from + @increment*$t\n         .attribs{%Parents{$_.name}.todo} = $v.from »+« @incre »*» $t;\n         .removeChild($_); #  ditch <animate> and friends\n      }\n   }\n   say \"when t = \", $t;\n   say $clone.find(\"/\");\n}\n\n```\n\nOutput:\n\n```\nwhen t = 0\n<?xml version=\"1.0\"?><X3D><Scene><Viewpoint position=\"0 0 8\" orientation=\"0 0 1 0\"/><PointLight location=\"0 2 0\" color=\"1 1 1\"/><Shape><Box size=\"2 1 2\"/><Appearance><Material diffuseColor=\"0 0.6 1\"/></Appearance></Shape></Scene></X3D>\nwhen t = 2\n<?xml version=\"1.0\"?><X3D><Scene><Viewpoint position=\"0 0 8\" orientation=\"0 0 1 0\"/><PointLight location=\"0 2 0\" color=\"1 1 1\"/><Shape><Box size=\"1.8 1.2 1.8\"/><Appearance><Material diffuseColor=\"0.2 0.56 0.8\"/></Appearance></Shape></Scene></X3D>\nwhen t = 4\n<?xml version=\"1.0\"?><X3D><Scene><Viewpoint position=\"0 0 8\" orientation=\"0 0 1 0\"/><PointLight location=\"0 2 0\" color=\"1 1 1\"/><Shape><Box size=\"1.6 1.4 1.6\"/><Appearance><Material diffuseColor=\"0.4 0.52 0.6\"/></Appearance></Shape></Scene></X3D>\n\n```"}]}
{"messages": [{"role": "user", "content": "Given a positive integer, return the product of its positive divisors.\n\nTask\n\nShow the result for the first 50 positive integers."}, {"role": "assistant", "content": "Yet more tasks that are tiny variations of each other. Tau function, Tau number, Sum of divisors and Product of divisors all use code with minimal changes. What the heck, post 'em all.\n\n```\nuse Prime::Factor:ver<0.3.0+>;\nuse Lingua::EN::Numbers;\n\nsay \"\\nTau function - first 100:\\n\",        # ID\n(1..*).map({ +.&divisors })[^100]\\          # the task\n.batch(20)».fmt(\"%3d\").join(\"\\n\");          # display formatting\n\nsay \"\\nTau numbers - first 100:\\n\",         # ID\n(1..*).grep({ $_ %% +.&divisors })[^100]\\   # the task\n.batch(10)».&comma».fmt(\"%5s\").join(\"\\n\");  # display formatting\n\nsay \"\\nDivisor sums - first 100:\\n\",        # ID\n(1..*).map({ [+] .&divisors })[^100]\\       # the task\n.batch(20)».fmt(\"%4d\").join(\"\\n\");          # display formatting\n\nsay \"\\nDivisor products - first 100:\\n\",    # ID\n(1..*).map({ [×] .&divisors })[^100]\\       # the task\n.batch(5)».&comma».fmt(\"%16s\").join(\"\\n\");  # display formatting\n\n```\n\nOutput:\n\n```\nTau function - first 100:\n  1   2   2   3   2   4   2   4   3   4   2   6   2   4   4   5   2   6   2   6\n  4   4   2   8   3   4   4   6   2   8   2   6   4   4   4   9   2   4   4   8\n  2   8   2   6   6   4   2  10   3   6   4   6   2   8   4   8   4   4   2  12\n  2   4   6   7   4   8   2   6   4   8   2  12   2   4   6   6   4   8   2  10\n  5   4   2  12   4   4   4   8   2  12   4   6   4   4   4  12   2   6   6   9\n\nTau numbers - first 100:\n    1     2     8     9    12    18    24    36    40    56\n   60    72    80    84    88    96   104   108   128   132\n  136   152   156   180   184   204   225   228   232   240\n  248   252   276   288   296   328   344   348   360   372\n  376   384   396   424   441   444   448   450   468   472\n  480   488   492   504   516   536   560   564   568   584\n  600   612   625   632   636   640   664   672   684   708\n  712   720   732   776   792   804   808   824   828   852\n  856   864   872   876   880   882   896   904   936   948\n  972   996 1,016 1,040 1,044 1,048 1,056 1,068 1,089 1,096\n\nDivisor sums - first 100:\n   1    3    4    7    6   12    8   15   13   18   12   28   14   24   24   31   18   39   20   42\n  32   36   24   60   31   42   40   56   30   72   32   63   48   54   48   91   38   60   56   90\n  42   96   44   84   78   72   48  124   57   93   72   98   54  120   72  120   80   90   60  168\n  62   96  104  127   84  144   68  126   96  144   72  195   74  114  124  140   96  168   80  186\n 121  126   84  224  108  132  120  180   90  234  112  168  128  144  120  252   98  171  156  217\n\nDivisor products - first 100:\n               1                2                3                8                5\n              36                7               64               27              100\n              11            1,728               13              196              225\n           1,024               17            5,832               19            8,000\n             441              484               23          331,776              125\n             676              729           21,952               29          810,000\n              31           32,768            1,089            1,156            1,225\n      10,077,696               37            1,444            1,521        2,560,000\n              41        3,111,696               43           85,184           91,125\n           2,116               47      254,803,968              343          125,000\n           2,601          140,608               53        8,503,056            3,025\n       9,834,496            3,249            3,364               59   46,656,000,000\n              61            3,844          250,047        2,097,152            4,225\n      18,974,736               67          314,432            4,761       24,010,000\n              71  139,314,069,504               73            5,476          421,875\n         438,976            5,929       37,015,056               79    3,276,800,000\n          59,049            6,724               83  351,298,031,616            7,225\n           7,396            7,569       59,969,536               89  531,441,000,000\n           8,281          778,688            8,649            8,836            9,025\n 782,757,789,696               97          941,192          970,299    1,000,000,000\n```"}]}
{"messages": [{"role": "user", "content": "Exactly as the task title implies.\n\nTask\n\n* Find and display the product of the minimum and maximum prime factors for the terms 1 through 100, inclusive.\n\n:   *For some reason, the term for **1** is defined to be **1***\n:   *A equal case could be made that it should be **0**, **undefined**, or **-∞***. ¯\\\\_(ツ)\\_/¯\n\nSee also\n\n* OEIS:A066048 - Product of smallest and greatest prime factors of n"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\nput \"Product of smallest and greatest prime factors of n for 1 to 100:\\n\" ~\n  (1..100).map({ 1 max .max × .min given cache .&prime-factors })».fmt(\"%4d\").batch(10).join: \"\\n\";\n\n```\n\nOutput:\n\n```\nProduct of smallest and greatest prime factors of n for 1 to 100:\n   1    4    9    4   25    6   49    4    9   10\n 121    6  169   14   15    4  289    6  361   10\n  21   22  529    6   25   26    9   14  841   10\n 961    4   33   34   35    6 1369   38   39   10\n1681   14 1849   22   15   46 2209    6   49   10\n  51   26 2809    6   55   14   57   58 3481   10\n3721   62   21    4   65   22 4489   34   69   14\n5041    6 5329   74   15   38   77   26 6241   10\n   9   82 6889   14   85   86   87   22 7921   10\n  91   46   93   94   95    6 9409   14   33   10\n```"}]}
{"messages": [{"role": "user", "content": "The task is to programmatically obtain the name used to invoke the program. (For example determine whether the user ran \"python hello.py\", or \"python hellocaller.py\", a program importing the code from \"hello.py\".)\n\nSometimes a multiline shebang is necessary in order to provide the script name to a language's internal ARGV.\n\nSee also Command-line arguments\n\nExamples from GitHub."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-10-16\n\nIn Raku, the name of the program being executed is in the special global variable $\\*PROGRAM-NAME.\n\n```\nsay $*PROGRAM-NAME;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow the syntax for a complete stoppage of a program inside a   conditional.\n\nThis includes all threads/processes which are part of your program.\n\nExplain the cleanup (or lack thereof) caused by the termination (allocated memory, database connections, open files, object finalizers/destructors, run-on-exit hooks, etc.).\n\nUnless otherwise described, no special cleanup outside that provided by the operating system is provided."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nif $problem { exit $error-code }\n```\n\nAn exit runs all appropriate scope-leaving blocks such as LEAVE, KEEP, or UNDO,\nfollowed by all END blocks, followed by all destructors that do more than just reclaim memory, and so cannot be skipped because they may have side effects visible outside the process. If run from an embedded interpreter, all\nmemory must also be reclaimed. (Raku does not yet have a thread-termination policy, but will need to before we're done.)"}]}
{"messages": [{"role": "user", "content": "This task only makes sense for dependently-typed languages and proof assistants, or for languages with a type system strong enough to emulate certain dependent types. It does *not* ask you to implement a theorem prover yourself.\n\nIn the following task the word \"define\" implies the need to build the system of Peano axioms using the language itself, that is a way to construct natural and even natural numbers in the canonical forms, as well as a definition of the rules of addition and a way to construct all other acceptable terms. The word \"prove\" means that some form of logical unification is used (i.e., it requires a type checker in the case of languages ​​with dependent types and a verifying algorithm in the case of proof assistants). Thus, the metatheory of a language must be expressive enough to allow embedding of the Peano axioms and the opportunity to carry out constructive proofs. Examples of the *trusted* mathematical metatheories can be given: SystemF for Haskell, MLTT for Agda, CoC/CoIC for Coq.\n\n**Task**:\n\n1. To illustrate the possibility of type formation and type introduction:\n   1. Define a countably infinite set of natural numbers {0, 1, 2, 3, ...}.\n   2. Define a countably infinite set of even natural numbers {0, 2, 4, 6, ...} within the previously defined set of natural numbers.\n   3. Define a countably infinite set of odd natural numbers {1, 3, 5, 7, ...} within the previously defined set of natural numbers.\n2. To illustrate the possibility of type elimination:\n   1. Define the addition on natural numbers.\n3. To demonstrate constructive proofs:\n   1. Prove that the addition of *any* two even numbers is even.\n   2. Prove that the addition is *always* associative.\n   3. Prove that the addition is *always* commutative.\n   4. Try to prove that the addition of *any* two even numbers is odd (it should be rejected).\n4. To demonstrate the ability of disproofs:\n   1. Prove that the addition of *any* two even numbers cannot be odd.\n   2. Try to prove that the addition of *any* two even numbers cannot be even (it should be rejected).\n\n3. and 4. can't be done using a simple number enumeration since there is a countable many natural numbers which is quantified in propositions."}, {"role": "assistant", "content": "Partial attempt only.\n\n```\n# 20200807 Raku programming solution (Incomplete)\n\nsub check ($type, @testee) {\n   @testee.map: { say \"Is\\t$_\\t∈ \", $type.^name, \"\\t: \", $_ ~~ $type}\n}\n\n# 1.1 natural numbers\n\nsubset ℕ of Any where ( $_ ≥ 0 and $_.narrow ~~ Int ); # add constraints to Any\n# alternative : subset ℕ of Int where * ≥ 0;\n\ncheck ℕ, < 0 1 -1 3.3 >;\n\n# 1.2 even natural numbers\n\nsubset EvenNatural of ℕ where * %% 2;\n\ncheck EvenNatural, < 33 66 >;\n\n# 1.3 odd natural numbers\n\nsubset OddNatural of ℕ where ( $_ ≠ $_ div 2 × 2 );\n# alternative : subset OddNatural of ℕ where * !~~ Even;\n\ncheck OddNatural, < 33 66 >;\n\n# 2.1 Define the addition on natural numbers  (Translation from #Go)\n\nsub infix:<⊞>(ℕ $a, ℕ $b --> ℕ) {\n   return $a if $b == 0;\n   return $a.succ ⊞ $b.pred;\n}\n\ncheck ℕ, [ 3 ⊞ 5 ];\n\n# 3.1 Prove that the addition of any two even numbers is even\n# 3.2 Prove that the addition is always associative\n# 3.3 Prove that the addition is always commutative\n# 3.4 Try to prove that the addition of any two even numbers is odd (it should be rejected)\n\n# 4.1 Prove that the addition of any two even numbers cannot be odd\n# 4.2 Try to prove that the addition of any two even numbers cannot be even (it should be rejected)\n\n```\n\nOutput:\n\n```\nIs      0       ∈ ℕ     : True\nIs      1       ∈ ℕ     : True\nIs      -1      ∈ ℕ     : False\nIs      3.3     ∈ ℕ     : False\nIs      33      ∈ EvenNatural   : False\nIs      66      ∈ EvenNatural   : True\nIs      33      ∈ OddNatural    : True\nIs      66      ∈ OddNatural    : False\nIs      8       ∈ ℕ     : True\n\n```"}]}
{"messages": [{"role": "user", "content": "The   proper divisors   of a positive integer **N** are those numbers, other than **N** itself, that divide **N** without remainder.\n\nFor **N** > 1 they will always include 1,   but for **N** == 1 there are no proper divisors.\n\nExamples\n\nThe proper divisors of     6     are   1, 2, and 3.\n  \nThe proper divisors of   100   are   1, 2, 4, 5, 10, 20, 25, and 50.\n\nTask\n\n1. Create a routine to generate all the proper divisors of a number.\n2. use it to show the proper divisors of the numbers 1 to 10 inclusive.\n3. Find a number in the range 1 to 20,000 with the most proper divisors. Show the number and just the count of how many proper divisors it has.\n\nShow all output here.\n\nRelated tasks\n\n* Amicable pairs\n* Abundant, deficient and perfect number classifications\n* Aliquot sequence classifications\n* Factors of an integer\n* Prime decomposition"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.10\n\nOnce your threshold is over 1000, the maximum proper divisors will always include 2, 3 and 5 as divisors, so only bother to check multiples of 2, 3 and 5.\n\nThere really isn't any point in using concurrency for a limit of 20\\_000. The setup and bookkeeping drowns out any benefit. Really doesn't start to pay off until the limit is 50\\_000 and higher. Try swapping in the commented out race map iterator line below for comparison.\n\n```\nsub propdiv (\\x) {\n    my @l = 1 if x > 1;\n    (2 .. x.sqrt.floor).map: -> \\d {\n        unless x % d { @l.push: d; my \\y = x div d; @l.push: y if y != d }\n    }\n    @l\n}\n\nput \"$_ [{propdiv($_)}]\" for 1..10;\n\nmy @candidates;\nloop (my int $c = 30; $c <= 20_000; $c += 30) {\n#(30, *+30 …^ * > 500_000).race.map: -> $c {\n    my \\mx = +propdiv($c);\n    next if mx < @candidates - 1;\n    @candidates[mx].push: $c\n}\n\nsay \"max = {@candidates - 1}, candidates = {@candidates.tail}\";\n\n```\n\nOutput:\n\n```\n1 []\n2 [1]\n3 [1]\n4 [1 2]\n5 [1]\n6 [1 2 3]\n7 [1]\n8 [1 2 4]\n9 [1 3]\n10 [1 2 5]\nmax = 79, candidates = 15120 18480\n```"}]}
{"messages": [{"role": "user", "content": "MRG32k3a Combined recursive generator (pseudo-code)\n\n```\n   /* Constants */\n   /* First generator */\n   a1 = [0, 1403580, -810728]\n   m1 = 2**32 - 209\n   /* Second Generator */\n   a2 = [527612, 0, -1370589]\n   m2 = 2**32 - 22853\n    \n   d = m1 + 1\n   \n   class MRG32k3a\n       x1 = [0, 0, 0]  /* list of three last values of gen #1 */\n       x2 = [0, 0, 0]  /* list of three last values of gen #2 */\n       \n       method seed(u64 seed_state)\n           assert seed_state in range >0 and < d \n           x1 = [seed_state, 0, 0]\n           x2 = [seed_state, 0, 0]\n       end method\n           \n       method next_int()\n           x1i = (a1[0]*x1[0] + a1[1]*x1[1] + a1[2]*x1[2]) mod m1\n           x2i = (a2[0]*x2[0] + a2[1]*x2[1] + a2[2]*x2[2]) mod m2\n           x1 = [x1i, x1[0], x1[1]]    /* Keep last three */\n           x2 = [x2i, x2[0], x2[1]]    /* Keep last three */\n           z = (x1i - x2i) % m1\n           answer = (z + 1)\n           \n           return answer\n       end method\n       \n       method next_float():\n           return float next_int() / d\n       end method\n       \n   end class\n\n\n```\n\n:   MRG32k3a Use:\n\n```\n   random_gen = instance MRG32k3a\n   random_gen.seed(1234567)\n   print(random_gen.next_int())   /* 1459213977 */\n   print(random_gen.next_int())   /* 2827710106 */\n   print(random_gen.next_int())   /* 4245671317 */\n   print(random_gen.next_int())   /* 3877608661 */\n   print(random_gen.next_int())   /* 2595287583 */\n   \n       \n\n```\n\nTask\n\n* Generate a class/set of functions that generates pseudo-random\n\nnumbers as shown above.\n\n* Show that the first five integers generated with the seed `1234567`\n\nare as shown above\n\n* Show that for an initial seed of '987654321' the counts of 100\\_000\n\nrepetitions of\n\n```\n   floor(random_gen.next_float() * 5)\n\n```\n\nIs as follows:\n\n```\n   0: 20002, 1: 20060, 2: 19948, 3: 20059, 4: 19931\n\n```\n\n* Show your output here, on this page."}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.07\n\n**Translation of**: Python\n\nAll constants are encapsulated within the class.\n\n```\nclass MRG32k3a {\n    has @!x1;\n    has @!x2;\n\n    constant a1 = 0, 1403580, -810728;\n    constant a2 = 527612, 0, -1370589;\n    constant m1 = 2**32 - 209;\n    constant m2 = 2**32 - 22853;\n\n    submethod BUILD ( Int :$seed where 0 < * <= m1 = 1 ) { @!x1 = @!x2 = $seed, 0, 0 }\n\n    method next-int {\n        @!x1.unshift: (a1[0] * @!x1[0] + a1[1] * @!x1[1] + a1[2] * @!x1[2]) % m1; @!x1.pop;\n        @!x2.unshift: (a2[0] * @!x2[0] + a2[1] * @!x2[1] + a2[2] * @!x2[2]) % m2; @!x2.pop;\n        (@!x1[0] - @!x2[0]) % (m1 + 1)\n    }\n\n    method next-rat { self.next-int / (m1 + 1) }\n}\n\n\n# Test next-int with custom seed\nsay 'Seed: 1234567; first five Int values:';\nmy $rng = MRG32k3a.new :seed(1234567);\n.say for $rng.next-int xx 5;\n\n\n# Test next-rat (since these are rational numbers by default)\nsay \"\\nSeed: 987654321; first 1e5 Rat values histogram:\";\n$rng = MRG32k3a.new :seed(987654321);\nsay ( ($rng.next-rat * 5).floor xx 100_000 ).Bag;\n\n\n# Test next-int with default seed\nsay \"\\nSeed: default; first five Int values:\";\n$rng = MRG32k3a.new;\n.say for $rng.next-int xx 5;\n\n```\n\nOutput:\n\n```\nSeed: 1234567; first five Int values:\n1459213977\n2827710106\n4245671317\n3877608661\n2595287583\n\nSeed: 987654321; first 1e5 Rat values histogram:\nBag(0(20002) 1(20060) 2(19948) 3(20059) 4(19931))\n\nSeed: default; first five Int values:\n4294439476\n798392476\n1012402088\n1268414424\n3353586348\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Middle-square method. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThe Method\n\nTo generate a sequence of n-digit pseudorandom numbers, an n-digit starting value is created and squared, producing a 2n-digit number. If the result has fewer than 2n digits, leading zeroes are added to compensate. The middle n digits of the result would be the next number in the sequence and returned as the result. This process is then repeated to generate more numbers.\n\nPseudo code\n\n```\nvar seed = 675248\nfunction random()\n    var s = str(seed * seed) 'str: turn a number into string\n    do while not len(s) = 12\n        s = \"0\" + s          'add zeroes before the string\n    end do\n    seed = val(mid(s, 4, 6)) 'mid: string variable, start, length\n                             'val: turn a string into number\n    return seed\nend function\n\n```\n\nMiddle-square method use\n\n```\nfor i = 1 to 5\n    print random()\nend for\n\n```\n\nTask\n\n* Generate a class/set of functions that generates pseudo-random\n\nnumbers (6 digits) as shown above.\n\n* Show the first five integers generated with the seed 675248 as shown above.\n\n* Show your output here, on this page."}, {"role": "assistant", "content": "```\nsub msq {\n    state $seed = 675248;\n    $seed = $seed² div 1000 mod 1000000;\n}\n\nsay msq() xx 5;\n\n```\n\nOutput:\n\n```\n(959861 333139 981593 524817 432883)\n```"}]}
{"messages": [{"role": "user", "content": "Some definitions to help in the explanation\n\n:   Floor operation  \n\n    :   https://en.wikipedia.org/wiki/Floor\\_and\\_ceiling\\_functions\n    :   Greatest integer less than or equal to a real number.\n\n:   Bitwise Logical shift operators (c-inspired)  \n\n    :   https://en.wikipedia.org/wiki/Bitwise\\_operation#Bit\\_shifts\n    :   Binary bits of value shifted left or right, with zero bits shifted in where appropriate.\n    :   Examples are shown for 8 bit binary numbers; most significant bit to the left.\n\n:   :   **<<** Logical shift left by given number of bits.\n\n        :   E.g Binary 00110101 **<<** 2 == Binary 11010100\n\n:   :   **>>** Logical shift right by given number of bits.\n\n        :   E.g Binary 00110101 **>>** 2 == Binary 00001101\n\n:   **^** Bitwise exclusive-or operator\n\n    :   https://en.wikipedia.org/wiki/Exclusive\\_or\n    :   Bitwise comparison for if bits differ\n\n        :   E.g Binary 00110101 **^** Binary 00110011 == Binary 00000110\n\n:   **|** Bitwise or operator\n\n    :   https://en.wikipedia.org/wiki/Bitwise\\_operation#OR\n    :   Bitwise comparison gives 1 if any of corresponding bits are 1\n\n        :   E.g Binary 00110101 **|** Binary 00110011 == Binary 00110111\n\nPCG32 Generator (pseudo-code)\n\nPCG32 has two unsigned 64-bit integers of internal state:\n\n1. **state**: All 2\\*\\*64 values may be attained.\n2. **sequence**: Determines which of 2\\*\\*63 sequences that `state` iterates through. (Once set together with `state` at time of seeding will stay constant for this generators lifetime).\n\nValues of `sequence` allow 2\\*\\*63 *different* sequences of random numbers from the same `state`.\n\nThe algorithm is given 2 U64 inputs called `seed_state`, and `seed_sequence`. The algorithm proceeds in accordance with the following pseudocode:-\n\n```\nconst N<-U64 6364136223846793005\nconst inc<-U64 (seed_sequence << 1) | 1\nstate<-U64 ((inc+seed_state)*N+inc\ndo forever\n  xs<-U32 (((state>>18)^state)>>27)\n  rot<-INT (state>>59)\n  OUTPUT U32 (xs>>rot)|(xs<<((-rot)&31))\n  state<-state*N+inc\nend do\n\n```\n\nNote that this an anamorphism – dual to catamorphism, and encoded in some languages as a general higher-order `unfold` function, dual to `fold` or `reduce`.\n\nTask\n\n* Generate a class/set of functions that generates pseudo-random\n\nnumbers using the above.\n\n* Show that the first five integers generated with the seed `42, 54`\n\nare: 2707161783 2068313097 3122475824 2211639955 3215226955\n\n* Show that for an initial seed of `987654321, 1` the counts of 100\\_000 repetitions of\n\n```\n   floor(random_gen.next_float() * 5)\n\n```\n\n:   Is as follows:\n\n```\n   0: 20049, 1: 20022, 2: 20115, 3: 19809, 4: 20005\n\n```\n\n* Show your output here, on this page."}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.07\n\n**Translation of**: Python\n\nOr... at least, it started out that way.\n\nRaku does not have unsigned Integers at this time (Integers are arbitrary sized) so use explicit bit masks during bitwise operations.\n\n```\nclass PCG32 {\n    has $!state;\n    has $!incr;\n    constant mask32 = 2³² - 1;\n    constant mask64 = 2⁶⁴ - 1;\n    constant const = 6364136223846793005;\n\n    submethod BUILD (\n        Int :$seed = 0x853c49e6748fea9b, # default seed\n        Int :$incr = 0xda3e39cb94b95bdb  # default increment\n      ) {\n        $!incr  = $incr +< 1 +| 1 +& mask64;\n        $!state = (($!incr + $seed) * const + $!incr) +& mask64;\n    }\n\n    method next-int {\n        my $shift  = ($!state +> 18 +^ $!state) +> 27 +& mask32;\n        my $rotate =  $!state +> 59 +& 31;\n        $!state    = ($!state * const + $!incr) +& mask64;\n        ($shift +> $rotate) +| ($shift +< (32 - $rotate) +& mask32)\n    }\n\n    method next-rat { self.next-int / 2³² }\n}\n\n\n# Test next-int with custom seed and increment\nsay 'Seed: 42, Increment: 54; first five Int values:';\nmy $rng = PCG32.new( :seed(42), :incr(54) );\n.say for $rng.next-int xx 5;\n\n\n# Test next-rat (since these are rational numbers by default)\nsay \"\\nSeed: 987654321, Increment: 1; first 1e5 Rat values histogram:\";\n$rng = PCG32.new( :seed(987654321), :incr(1) );\nsay ( ($rng.next-rat * 5).floor xx 100_000 ).Bag;\n\n\n# Test next-int with default seed and increment\nsay \"\\nSeed: default, Increment: default; first five Int values:\";\n$rng = PCG32.new;\n.say for $rng.next-int xx 5;\n\n```\n\nOutput:\n\n```\nSeed: 42, Increment: 54; first five Int values:\n2707161783\n2068313097\n3122475824\n2211639955\n3215226955\n\nSeed: 987654321, Increment: 1; first 1e5 Rat values histogram:\nBag(0(20049), 1(20022), 2(20115), 3(19809), 4(20005))\n\nSeed: default, Increment: default; first five Int values:\n465482994\n3895364073\n1746730475\n3759121132\n2984354868\n```"}]}
{"messages": [{"role": "user", "content": "Splitmix64 is the default pseudo-random number generator algorithm in Java and is included / available in many other languages. It uses a fairly simple algorithm that, though it is considered to be poor for cryptographic purposes, is very fast to calculate, and is \"good enough\" for many random number needs. It passes several fairly rigorous PRNG \"fitness\" tests that some more complex algorithms fail.\n\nSplitmix64 is not recommended for demanding random number requirements, but is often used to calculate initial states for other more complex pseudo-random number generators.\n\nThe \"standard\" splitmix64 maintains one 64 bit state variable and returns 64 bits of random data with each call.\n\nBasic pseudocode algorithm:\n\n```\n    uint64 state                                  /* The state can be seeded with any (upto) 64 bit integer value. */\n\n    next_int() {\n        state += 0x9e3779b97f4a7c15               /* increment the state variable */\n        uint64 z = state                          /* copy the state to a working variable */\n        z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9  /* xor the variable with the variable right bit shifted 30 then multiply by a constant */\n        z = (z ^ (z >> 27)) * 0x94d049bb133111eb  /* xor the variable with the variable right bit shifted 27 then multiply by a constant */\n        return z ^ (z >> 31)                      /* return the variable xored with itself right bit shifted 31 */\n    }\n\n    next_float() {\n        return next_int() / (1 << 64)             /* divide by 2^64 to return a value between 0 and 1 */\n    }\n```\n\nThe returned value should hold 64 bits of numeric data. If your language does not support unsigned 64 bit integers directly you may need to apply appropriate bitmasks during bitwise operations.\n\nIn keeping with the general layout of several recent pseudo-random number tasks:\n\nTask\n\n* Write a class or set of functions that generates pseudo-random numbers using splitmix64.\n\n* Show the first five integers generated using the seed 1234567.\n\n```\n    6457827717110365317\n    3203168211198807973\n    9817491932198370423\n    4593380528125082431\n   16408922859458223821\n  \n\n```\n\n* Show that for an initial seed of 987654321, the counts of 100\\_000 repetitions of `floor next_float() * 5` is as follows:\n\n```\n   0: 20027, 1: 19892, 2: 20073, 3: 19978, 4: 20030  \n\n```\n\n* Show your output here, on this page.\n\nSee also\n\n* Java docs for splitmix64 * Public domain C code used in many PRNG implementations; by Sebastiano Vigna\n\nRelated tasks\n\n* Pseudo-random numbers/Combined recursive generator MRG32k3a‎‎ * Pseudo-random numbers/PCG32‎‎ * Pseudo-random\\_numbers/Xorshift\\_star"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.07\n\n```\nclass splitmix64 {\n    has $!state;\n\n    submethod BUILD ( Int :$seed where * >= 0 = 1 ) { $!state = $seed }\n\n    method next-int {\n        my $next = $!state = ($!state + 0x9e3779b97f4a7c15) +& (2⁶⁴ - 1);\n        $next = ($next +^ ($next +> 30)) * 0xbf58476d1ce4e5b9 +& (2⁶⁴ - 1);\n        $next = ($next +^ ($next +> 27)) * 0x94d049bb133111eb +& (2⁶⁴ - 1);\n        ($next +^ ($next +> 31)) +& (2⁶⁴ - 1);\n    }\n\n    method next-rat { self.next-int / 2⁶⁴ }\n}\n\n# Test next-int\nsay 'Seed: 1234567; first five Int values';\nmy $rng = splitmix64.new( :seed(1234567) );\n.say for $rng.next-int xx 5;\n\n\n# Test next-rat (since these are rational numbers by default)\nsay \"\\nSeed: 987654321; first 1e5 Rat values histogram\";\n$rng = splitmix64.new( :seed(987654321) );\nsay ( ($rng.next-rat * 5).floor xx 100_000 ).Bag;\n\n```\n\nOutput:\n\n```\nSeed: 1234567; first five Int values\n6457827717110365317\n3203168211198807973\n9817491932198370423\n4593380528125082431\n16408922859458223821\n\nSeed: 987654321; first 1e5 Rat values histogram\nBag(0(20027) 1(19892) 2(20073) 3(19978) 4(20030))\n```"}]}
{"messages": [{"role": "user", "content": "Some definitions to help in the explanation\n\n:   Floor operation  \n\n    :   https://en.wikipedia.org/wiki/Floor\\_and\\_ceiling\\_functions\n    :   Greatest integer less than or equal to a real number.\n\n:   Bitwise Logical shift operators (c-inspired)  \n\n    :   https://en.wikipedia.org/wiki/Bitwise\\_operation#Bit\\_shifts\n    :   Binary bits of value shifted left or right, with zero bits shifted in where appropriate.\n    :   Examples are shown for 8 bit binary numbers; most significant bit to the left.\n\n:   :   **<<** Logical shift left by given number of bits.\n\n        :   E.g Binary 00110101 **<<** 2 == Binary 11010100\n\n:   :   **>>** Logical shift right by given number of bits.\n\n        :   E.g Binary 00110101 **>>** 2 == Binary 00001101\n\n:   **^** Bitwise exclusive-or operator\n\n    :   https://en.wikipedia.org/wiki/Exclusive\\_or\n    :   Bitwise comparison for if bits differ\n\n        :   E.g Binary 00110101 **^** Binary 00110011 == Binary 00000110\n\nXorshift\\_star Generator (pseudo-code)\n\n```\n   /* Let u64 denote an unsigned 64 bit integer type. */\n   /* Let u32 denote an unsigned 32 bit integer type. */\n   \n   class Xorshift_star\n       u64 state       /* Must be seeded to non-zero initial value */\n       u64 const = HEX '2545F4914F6CDD1D'\n   \n       method seed(u64 num):\n           state =  num\n       end method\n       \n       method next_int():\n           u64 x = state\n           x = x ^ (x >> 12)\n           x = x ^ (x << 25)\n           x = x ^ (x >> 27)\n           state = x\n           u32 answer = ((x * const) >> 32)\n           \n           return answer\n       end method\n       \n       method next_float():\n           return float next_int() / (1 << 32)\n       end method\n       \n   end class\n       \n\n```\n\n:   Xorshift use\n\n```\n   random_gen = instance Xorshift_star\n   random_gen.seed(1234567)\n   print(random_gen.next_int())   /* 3540625527 */\n   print(random_gen.next_int())   /* 2750739987 */\n   print(random_gen.next_int())   /* 4037983143 */\n   print(random_gen.next_int())   /* 1993361440 */\n   print(random_gen.next_int())   /* 3809424708 */\n\n```\n\nTask\n\n* Generate a class/set of functions that generates pseudo-random\n\nnumbers as shown above.\n\n* Show that the first five integers genrated with the seed 1234567\n\nare as shown above\n\n* Show that for an initial seed of 987654321, the counts of 100\\_000 repetitions of\n\n```\n   floor(random_gen.next_float() * 5)\n\n```\n\n:   Is as follows:\n\n```\n   0: 20103, 1: 19922, 2: 19937, 3: 20031, 4: 20007\n\n```\n\n* Show your output here, on this page."}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.07\n\n**Translation of**: Python\n\nRaku does not have unsigned Integers at this time (Integers are arbitrary sized) so use explicit bit masks during bitwise operations. All constants are encapsulated inside the class.\n\n```\nclass Xorshift-star {\n    has $!state;\n\n    submethod BUILD ( Int :$seed where * > 0 = 1 ) { $!state = $seed }\n\n    method next-int {\n        $!state +^= $!state +> 12;\n        $!state +^= $!state +< 25 +& (2⁶⁴ - 1);\n        $!state +^= $!state +> 27;\n        ($!state * 0x2545F4914F6CDD1D) +> 32 +& (2³² - 1)\n    }\n\n    method next-rat { self.next-int / 2³² }\n}\n\n# Test next-int\nsay 'Seed: 1234567; first five Int values';\nmy $rng = Xorshift-star.new( :seed(1234567) );\n.say for $rng.next-int xx 5;\n\n\n# Test next-rat (since these are rational numbers by default)\nsay \"\\nSeed: 987654321; first 1e5 Rat values histogram\";\n$rng = Xorshift-star.new( :seed(987654321) );\nsay ( ($rng.next-rat * 5).floor xx 100_000 ).Bag;\n\n\n# Test with default seed\nsay \"\\nSeed: default; first five Int values\";\n$rng = Xorshift-star.new;\n.say for $rng.next-int xx 5;\n\n```\n\nOutput:\n\n```\nSeed: 1234567; first five Int values\n3540625527\n2750739987\n4037983143\n1993361440\n3809424708\n\nSeed: 987654321; first 1e5 Rat values histogram\nBag(0(20103), 1(19922), 2(19937), 3(20031), 4(20007))\n\nSeed: default; first five Int values\n1206177355\n2882512552\n3117485455\n1303648416\n241277360\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program that creates an image from a Pseudorandom Number Generator (PRNG) algorithm's output.\nThe image can have the following dimensions:\n\n:   :   1. 250px by 250px : If the algorithm requires the use of prime numbers, use 8-15 bit primes.\n        2. 500px by 500px : If the algorithm requires the use of prime numbers, use 8-15 bit primes.\n        3. 1000px by 1000px : If the algorithm requires the use of prime numbers, use 8-32 bit primes.\n        4. 1500px by 1500px : If the algorithm requires the use of prime numbers, use 16-64 bit primes.\n\nPossible Output\n\nhttps://www.random.org/analysis/randbitmap-rdo.png\n\nhttps://ibb.co/ZJPS16j\n\nSee also\n\n* Blum Blum Shub [1].\n* Blum-Micali Algorithm: [2].\n* Linear congruential generator [3]."}, {"role": "assistant", "content": "MoarVM uses Mersenne Twister as its PRNG but a prime seeder is not mandatory.\n\n```\n# 20200818 Raku programming solution\n\nuse Image::PNG::Portable;\n\nsrand 2⁶³ - 25; # greatest prime smaller than 2⁶³ and the max my system can take\n\nmy @data = < 250 500 1000 1500 >;\n\n@data.map: {\n   my $o = Image::PNG::Portable.new: :width($_), :height($_);\n   for ^$_ X ^$_ -> @pixel { # about 40% slower if split to ($x,$y) or (\\x,\\y)\n      $o.set: @pixel[0], @pixel[1], 256.rand.Int, 256.rand.Int, 256.rand.Int\n   }\n   $o.write: \"image$_.png\" or die;\n}\n\n```\n\nOutput:\n\n```\nfile image*.png\nimage1000.png: PNG image data, 1000 x 1000, 8-bit/color RGBA, non-interlaced\nimage1500.png: PNG image data, 1500 x 1500, 8-bit/color RGBA, non-interlaced\nimage250.png:  PNG image data, 250 x 250, 8-bit/color RGBA, non-interlaced\nimage500.png:  PNG image data, 500 x 500, 8-bit/color RGBA, non-interlaced\n\n```\n\nimage500.png (sample image, offsite)"}]}
{"messages": [{"role": "user", "content": "The Pythagoras tree is a fractal tree constructed from squares. It is named after Pythagoras because each triple of touching squares encloses a right triangle, in a configuration traditionally used to represent the Pythagorean theorem.\n\nTask\n\nConstruct a Pythagoras tree of order 7 using only vectors (no rotation or trigonometric functions).\n\nRelated tasks\n\n* Fractal tree"}, {"role": "assistant", "content": "(formerly Perl 6)\nWe'll generate a SVG image.\n\n```\nclass Square {\n    has Complex ($.position, $.edge);\n    method size { $!edge.abs }\n    method svg-polygon {\n\tqq[<polygon points=\"{join ' ', map\n\t{ ($!position + $_ * $!edge).reals.join(',') },\n\t0, 1, 1+1i, 1i}\" style=\"fill:lime;stroke=black\" />]\n    }\n    method left-child {\n\tself.new:\n\tposition => $!position + i*$!edge,\n\tedge => sqrt(2)/2*cis(pi/4)*$!edge;\n    }\n    method right-child {\n\tself.new:\n\tposition => $!position + i*$!edge + self.left-child.edge,\n\tedge => sqrt(2)/2*cis(-pi/4)*$!edge;\n    }\n}\n\nBEGIN say '<svg width=\"500\" height=\"500\">';\nEND   say '</svg>';\n\nsub tree(Square $s, $level = 0) {\n    return if $level > 8;\n    say $s.svg-polygon;\n    tree($s.left-child, $level+1);\n    tree($s.right-child, $level+1);\n}\n\ntree Square.new: :position(250+0i), :edge(60+0i);\n\n```"}]}
{"messages": [{"role": "user", "content": "One form of   **Pythagorean quadruples**   is   (for positive integers   **a**,   **b**,   **c**,   and   **d**):\n\n:   :   :   :   :   :   :   :   a2   +   b2   +   c2     =     d2\n\nAn example:\n\n:   :   :   :   :   :   :   :   22   +   32   +   62     =     72\n\n:   :   :   :   :   which is:\n\n:   :   :   :   :   :   :   :   4    +   9    +   36     =     49\n\nTask\n\nFor positive integers up   **2,200**   (inclusive),   for all values of   **a**,  \n**b**,   **c**,   and   **d**,\n  \nfind   (and show here)   those values of   **d**   that   *can't*   be represented.\n\nShow the values of   **d**   on one line of output   (optionally with a title).\n\nRelated tasks\n\n* Euler's sum of powers conjecture.\n* Pythagorean triples.\n\nReference\n:   * the Wikipedia article:   Pythagorean quadruple."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\n```\nmy \\N = 2200;\nmy @sq = (0 .. N)»²;\nmy @not = False xx N;\n@not[0] = True;\n\n(1 .. N).race.map: -> $d {\n    my $last = 0;\n    for $d ... ($d/3).ceiling -> $a {\n        for 1 .. ($a/2).ceiling -> $b {\n            last if (my $ab = @sq[$a] + @sq[$b]) > @sq[$d];\n            if (@sq[$d] - $ab).sqrt.narrow ~~ Int {\n                @not[$d] = True;\n                $last = 1;\n                last\n            }\n        }\n        last if $last;\n    }\n}\n\nsay @not.grep( *.not, :k );\n\n```\n\nOutput:\n\n```\n(1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048)\n```"}]}
{"messages": [{"role": "user", "content": "A Pythagorean triple is defined as three positive integers \n\n(\na\n,\nb\n,\nc\n)\n{\\displaystyle {\\displaystyle (a,b,c)}}\n where \n\na\n<\nb\n<\nc\n{\\displaystyle {\\displaystyle a<b<c}}\n, and \n\na\n\n2\n+\n\nb\n\n2\n=\n\nc\n\n2\n.\n{\\displaystyle {\\displaystyle a^{2}+b^{2}=c^{2}.}}\n\nThey are called primitive triples if \n\na\n,\nb\n,\nc\n{\\displaystyle {\\displaystyle a,b,c}}\n are co-prime, that is, if their pairwise greatest common divisors \n\ng\nc\nd\n(\na\n,\nb\n)\n=\n\n\ng\nc\nd\n(\na\n,\nc\n)\n=\n\n\ng\nc\nd\n(\nb\n,\nc\n)\n=\n1\n{\\displaystyle {\\displaystyle {\\rm {gcd}}(a,b)={\\rm {gcd}}(a,c)={\\rm {gcd}}(b,c)=1}}\n.\n\nBecause of their relationship through the Pythagorean theorem, a, b, and c are co-prime if a and b are co-prime (\n\ng\nc\nd\n(\na\n,\nb\n)\n=\n1\n{\\displaystyle {\\displaystyle {\\rm {gcd}}(a,b)=1}}\n).\n\nEach triple forms the length of the sides of a right triangle, whose perimeter is \n\nP\n=\na\n+\nb\n+\nc\n{\\displaystyle {\\displaystyle P=a+b+c}}\n.\n\nTask\n\nThe task is to determine how many Pythagorean triples there are with a perimeter no larger than 100 and the number of these that are primitive.\n\nExtra credit\n\nDeal with large values.   Can your program handle a maximum perimeter of 1,000,000?   What about 10,000,000?   100,000,000?\n\nNote: the extra credit is not for you to demonstrate how fast your language is compared to others;   you need a proper algorithm to solve them in a timely manner.\n\nRelated tasks\n\n* Euler's sum of powers conjecture\n* List comprehensions\n* Pythagorean quadruples"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\nHere is a straight-forward, naïve brute force implementation:\n\n```\nconstant limit = 100;\n\nfor [X] [^limit] xx 3 -> (\\a, \\b, \\c) {\n    say [a, b, c] if a < b < c and a + b + c <= limit and a*b + b*b == c*c\n}\n\n```\n\nOutput:\n\n```\n[3 4 5]\n[5 12 13]\n[6 8 10]\n[7 24 25]\n[8 15 17]\n[9 12 15]\n[9 40 41]\n[10 24 26]\n[12 16 20]\n[12 35 37]\n[15 20 25]\n[15 36 39]\n[16 30 34]\n[18 24 30]\n[20 21 29]\n[21 28 35]\n[24 32 40]\n\n```\n\nHere is a slightly less naive brute force implementation, but still not practical for large perimeter limits.\n\n```\nmy $limit = 10000;\nmy atomicint $i = 0;\nmy @triples[$limit/2];\n(3 .. $limit/2).race.map: -> $c {\n   for 1 .. $c -> $a {\n       my $b = ($c * $c - $a * $a).sqrt;\n       last if $c + $a + $b > $limit;\n       last if $a > $b;\n       @triples[$i⚛++] = ([gcd] $c, $a, $b) > 1 ?? 0 !! 1 if $b == $b.Int;\n   }\n}\n\nsay my $result = \"There are {+@triples.grep:{$_ !eqv Any}} Pythagorean Triples with a perimeter <= $limit,\"\n ~\"\\nof which {[+] @triples.grep: so *} are primitive.\";\n\n```\n\nOutput:\n\n```\nThere are 4858 Pythagorean Triples with a perimeter <= 10000,\nof which 703 are primitive.\n```\n\nHere's a much faster version. Hint, \"oyako\" is Japanese for \"parent/child\". :-)\n\n```\nsub triples($limit) {\n    my $primitive = 0;\n    my $civilized = 0;\n \n    sub oyako($a, $b, $c) {\n        my $perim = $a + $b + $c;\n        return if $perim > $limit;\n        ++$primitive; $civilized += $limit div $perim;\n        oyako( $a - 2*$b + 2*$c,  2*$a - $b + 2*$c,  2*$a - 2*$b + 3*$c);\n        oyako( $a + 2*$b + 2*$c,  2*$a + $b + 2*$c,  2*$a + 2*$b + 3*$c);\n        oyako(-$a + 2*$b + 2*$c, -2*$a + $b + 2*$c, -2*$a + 2*$b + 3*$c);\n    }\n \n    oyako(3,4,5);\n    \"$limit => ($primitive $civilized)\";\n}\n \nfor 10,100,1000 ... * -> $limit {\n    say triples $limit;\n}\n\n```\n\nOutput:\n\n```\n10 => (0 0)\n100 => (7 17)\n1000 => (70 325)\n10000 => (703 4858)\n100000 => (7026 64741)\n1000000 => (70229 808950)\n10000000 => (702309 9706567)\n100000000 => (7023027 113236940)\n1000000000 => (70230484 1294080089)\n^C\n```\n\nThe geometric sequence of limits will continue on forever, so eventually when you get tired of waiting (about a billion on my computer), you can just stop it. Another efficiency trick of note: we avoid passing the limit in as a parameter to the inner helper routine, but instead supply the limit via the lexical scope. Likewise, the accumulators are referenced lexically, so only the triples themselves need to be passed downward, and nothing needs to be returned.\n\nHere is an alternate version that avoids naming any scalars that can be handled by vector processing instead. Using vectorized ops allows a bit more potential for parallelization in theory, but techniques like the use of complex numbers to add two numbers in parallel, and the use of gather/take generate so much overhead that this version runs 70-fold slower than the previous one.\n\n```\nconstant @coeff = [[+1, -2, +2], [+2, -1, +2], [+2, -2, +3]],\n                  [[+1, +2, +2], [+2, +1, +2], [+2, +2, +3]],\n                  [[-1, +2, +2], [-2, +1, +2], [-2, +2, +3]];\n\nsub triples($limit) {\n\n    sub oyako(@trippy) {\n        my $perim = [+] @trippy;\n        return if $perim > $limit;\n        take (1 + ($limit div $perim)i);\n        for @coeff -> @nine {\n            oyako (map -> @three { [+] @three »*« @trippy }, @nine);\n        }\n        return;\n    }\n\n    my $complex = 0i + [+] gather oyako([3,4,5]);\n    \"$limit => ({$complex.re, $complex.im})\";\n}\n\nfor 10, 100, 1000, 10000 -> $limit {\n    say triples $limit;\n}\n\n```\n\nOutput:\n\n```\n10 => (0 0)\n100 => (7 17)\n1000 => (70 325)\n10000 => (703 4858)\n```"}]}
{"messages": [{"role": "user", "content": "Any rectangular \n\nm\n×\nn\n{\\displaystyle {\\displaystyle m\\times n}}\n matrix \n\nA\n{\\displaystyle {\\displaystyle {\\mathit {A}}}}\n can be decomposed to a product of an orthogonal matrix \n\nQ\n{\\displaystyle {\\displaystyle {\\mathit {Q}}}}\n and an upper (right) triangular matrix \n\nR\n{\\displaystyle {\\displaystyle {\\mathit {R}}}}\n, as described in QR decomposition.\n\n**Task**\n\nDemonstrate the QR decomposition on the example matrix from the Wikipedia article:\n\n:   :   A\n        =\n\n\n        (\n\n        12\n\n        −\n        51\n\n        4\n\n\n        6\n\n        167\n\n        −\n        68\n\n\n        −\n        4\n\n        24\n\n        −\n        41\n        )\n        {\\displaystyle {\\displaystyle A={\\begin{pmatrix}12&-51&4\\\\6&167&-68\\\\-4&24&-41\\end{pmatrix}}}}\n\nand the usage for linear least squares problems on the example from Polynomial regression. The method of Householder reflections should be used:\n\n**Method**\n\nMultiplying a given vector \n\na\n{\\displaystyle {\\displaystyle {\\mathit {a}}}}\n, for example the first column of matrix \n\nA\n{\\displaystyle {\\displaystyle {\\mathit {A}}}}\n, with the Householder matrix \n\nH\n{\\displaystyle {\\displaystyle {\\mathit {H}}}}\n, which is given as\n\n:   :   H\n        =\n        I\n        −\n\n\n        2\n\n\n        u\n\n        T\n        u\n        u\n\n        u\n\n        T\n        {\\displaystyle {\\displaystyle H=I-{\\frac {2}{u^{T}u}}uu^{T}}}\n\nreflects \n\na\n{\\displaystyle {\\displaystyle {\\mathit {a}}}}\n about a plane given by its normal vector \n\nu\n{\\displaystyle {\\displaystyle {\\mathit {u}}}}\n. When the normal vector of the plane \n\nu\n{\\displaystyle {\\displaystyle {\\mathit {u}}}}\n is given as\n\n:   :   u\n        =\n        a\n        −\n        ‖\n        a\n\n        ‖\n\n        2\n\n\n        e\n\n        1\n        {\\displaystyle {\\displaystyle u=a-\\|a\\|\\_{2}\\;e\\_{1}}}\n\nthen the transformation reflects \n\na\n{\\displaystyle {\\displaystyle {\\mathit {a}}}}\n onto the first standard basis vector\n\n:   :   e\n\n        1\n        =\n        [\n        1\n\n        0\n\n        0\n\n        .\n        .\n        .\n\n        ]\n\n        T\n        {\\displaystyle {\\displaystyle e\\_{1}=[1\\;0\\;0\\;...]^{T}}}\n\nwhich means that all entries but the first become zero. To avoid numerical cancellation errors, we should take the opposite sign of \n\na\n\n1\n{\\displaystyle {\\displaystyle a\\_{1}}}\n:\n\n:   :   u\n        =\n        a\n        +\n\n\n        sign\n        (\n\n        a\n\n        1\n        )\n        ‖\n        a\n\n        ‖\n\n        2\n\n\n        e\n\n        1\n        {\\displaystyle {\\displaystyle u=a+{\\textrm {sign}}(a\\_{1})\\|a\\|\\_{2}\\;e\\_{1}}}\n\nand normalize with respect to the first element:\n\n:   :   v\n        =\n\n\n        u\n\n        u\n\n        1\n        {\\displaystyle {\\displaystyle v={\\frac {u}{u\\_{1}}}}}\n\nThe equation for \n\nH\n{\\displaystyle {\\displaystyle H}}\n thus becomes:\n\n:   :   H\n        =\n        I\n        −\n\n\n        2\n\n\n        v\n\n        T\n        v\n        v\n\n        v\n\n        T\n        {\\displaystyle {\\displaystyle H=I-{\\frac {2}{v^{T}v}}vv^{T}}}\n\nor, in another form\n\n:   :   H\n        =\n        I\n        −\n        β\n        v\n\n        v\n\n        T\n        {\\displaystyle {\\displaystyle H=I-\\beta vv^{T}}}\n\nwith\n\n:   :   β\n        =\n\n\n        2\n\n\n        v\n\n        T\n        v\n        {\\displaystyle {\\displaystyle \\beta ={\\frac {2}{v^{T}v}}}}\n\nApplying \n\nH\n{\\displaystyle {\\displaystyle {\\mathit {H}}}}\n on \n\na\n{\\displaystyle {\\displaystyle {\\mathit {a}}}}\n then gives\n\n:   :   H\n\n        a\n        =\n        −\n\n\n        sign\n        (\n\n        a\n\n        1\n        )\n\n        ‖\n        a\n\n        ‖\n\n        2\n\n\n        e\n\n        1\n        {\\displaystyle {\\displaystyle H\\;a=-{\\textrm {sign}}(a\\_{1})\\;\\|a\\|\\_{2}\\;e\\_{1}}}\n\nand applying \n\nH\n{\\displaystyle {\\displaystyle {\\mathit {H}}}}\n on the matrix \n\nA\n{\\displaystyle {\\displaystyle {\\mathit {A}}}}\n zeroes all subdiagonal elements of the first column:\n\n:   :   H\n\n        1\n\n        A\n        =\n\n\n        (\n\n        r\n\n        11\n\n\n        r\n\n        12\n\n\n        r\n\n        13\n\n\n        0\n\n        ∗\n\n        ∗\n\n\n        0\n\n        ∗\n\n        ∗\n        )\n        {\\displaystyle {\\displaystyle H\\_{1}\\;A={\\begin{pmatrix}r\\_{11}&r\\_{12}&r\\_{13}\\\\0&\\*&\\*\\\\0&\\*&\\*\\end{pmatrix}}}}\n\nIn the second step, the second column of \n\nA\n{\\displaystyle {\\displaystyle {\\mathit {A}}}}\n, we want to zero all elements but the first two, which means that we have to calculate \n\nH\n{\\displaystyle {\\displaystyle {\\mathit {H}}}}\n with the first column of the *submatrix* (denoted \\*), not on the whole second column of \n\nA\n{\\displaystyle {\\displaystyle {\\mathit {A}}}}\n.\n\nTo get \n\nH\n\n2\n{\\displaystyle {\\displaystyle H\\_{2}}}\n, we then embed the new \n\nH\n{\\displaystyle {\\displaystyle {\\mathit {H}}}}\n into an \n\nm\n×\nn\n{\\displaystyle {\\displaystyle m\\times n}}\n identity:\n\n:   :   H\n\n        2\n        =\n\n\n        (\n\n        1\n\n        0\n\n        0\n\n\n        0\n\n        H\n\n        0\n\n        )\n        {\\displaystyle {\\displaystyle H\\_{2}={\\begin{pmatrix}1&0&0\\\\0&H&\\\\0&&\\end{pmatrix}}}}\n\nThis is how we can, column by column, remove all subdiagonal elements of \n\nA\n{\\displaystyle {\\displaystyle {\\mathit {A}}}}\n and thus transform it into \n\nR\n{\\displaystyle {\\displaystyle {\\mathit {R}}}}\n.\n\n:   :   H\n\n        n\n\n        .\n        .\n        .\n\n\n        H\n\n        3\n\n        H\n\n        2\n\n        H\n\n        1\n        A\n        =\n        R\n        {\\displaystyle {\\displaystyle H\\_{n}\\;...\\;H\\_{3}H\\_{2}H\\_{1}A=R}}\n\nThe product of all the Householder matrices \n\nH\n{\\displaystyle {\\displaystyle {\\mathit {H}}}}\n, for every column, in reverse order, will then yield the orthogonal matrix \n\nQ\n{\\displaystyle {\\displaystyle {\\mathit {Q}}}}\n.\n\n:   :   H\n\n        1\n\n        H\n\n        2\n\n        H\n\n        3\n\n        .\n        .\n        .\n\n\n        H\n\n        n\n        =\n        Q\n        {\\displaystyle {\\displaystyle H\\_{1}H\\_{2}H\\_{3}\\;...\\;H\\_{n}=Q}}\n\nThe QR decomposition should then be used to solve linear least squares (Multiple regression) problems \n\nA\nx\n=\nb\n{\\displaystyle {\\displaystyle {\\mathit {A}}x=b}}\n by solving\n\n:   :   R\n\n        x\n        =\n\n        Q\n\n        T\n\n        b\n        {\\displaystyle {\\displaystyle R\\;x=Q^{T}\\;b}}\n\nWhen \n\nR\n{\\displaystyle {\\displaystyle {\\mathit {R}}}}\n is not square, i.e. \n\nm\n>\nn\n{\\displaystyle {\\displaystyle m>n}}\n we have to cut off the \n\nm\n−\nn\n{\\displaystyle {\\displaystyle {\\mathit {m}}-n}}\n zero padded bottom rows.\n\n:   :   R\n        =\n\n\n        (\n\n        R\n\n        1\n\n\n        0\n        )\n        {\\displaystyle {\\displaystyle R={\\begin{pmatrix}R\\_{1}\\\\0\\end{pmatrix}}}}\n\nand the same for the RHS:\n\n:   :   Q\n\n        T\n\n        b\n        =\n\n\n        (\n\n        q\n\n        1\n\n        q\n\n        2\n        )\n        {\\displaystyle {\\displaystyle Q^{T}\\;b={\\begin{pmatrix}q\\_{1}\\\\q\\_{2}\\end{pmatrix}}}}\n\nFinally, solve the square upper triangular system by back substitution:\n\n:   :   R\n\n        1\n\n        x\n        =\n\n        q\n\n        1\n        {\\displaystyle {\\displaystyle R\\_{1}\\;x=q\\_{1}}}"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.06\n\n```\n# sub householder translated from https://codereview.stackexchange.com/questions/120978/householder-transformation\n\nuse v6;\n\nsub identity(Int:D $m --> Array of Array) {\n   my Array @M; \n   \n   for 0 ..^ $m -> $i {\n      @M.push: [0 xx $m];\n      @M[$i; $i] = 1;\n   }\n\n   @M;\n}\n\nmulti multiply(Array:D @A, @b where Array:D --> Array) {\n   my @c;\n\n   for ^@A X ^@b -> ($i, $j) {\n      @c[$i] += @A[$i; $j] * @b[$j];\n   }\n\n   @c;\n}\n\nmulti multiply(Array:D @A, Array:D @B --> Array of Array) {\n   my Array @C;\n\n   for ^@A X ^@B[0] -> ($i, $j) {\n      @C[$i; $j] += @A[$i; $_] * @B[$_; $j] for ^@B;\n   }\n\n   @C;\n}\n\nsub transpose(Array:D @M --> Array of Array) {\n   my ($rows, $cols) = (@M.elems, @M[0].elems);\n\n   my Array @T;\n\n   for ^$cols X ^$rows -> ($j, $i) {\n      @T[$j; $i] = @M[$i; $j];\n   }\n\n   @T;\n}\n\n####################################################\n# NOTE: @A gets overwritten and becomes @R, only need\n# to return @Q.\n####################################################\nsub householder(Array:D @A --> Array) {\n   my Int ($m, $n) = (@A.elems, @A[0].elems);\n   my @v = 0 xx $m;\n   my Array @Q = identity($m);\n\n   for 0 ..^ $n -> $k {\n      my Real $sum = 0;\n      my Real $A0 = @A[$k; $k];\n      my Int $sign = $A0 < 0 ?? -1 !! 1;\n\n      for $k ..^ $m -> $i {\n         $sum += @A[$i; $k] * @A[$i; $k];\n      }\n\n      my Real $sqr_sum = $sign * sqrt($sum);\n      my Real $tmp = sqrt(2 * ($sum + $A0 * $sqr_sum));     \n      @v[$k] = ($sqr_sum  + $A0) / $tmp;\n\n      for ($k + 1) ..^ $m -> $i {\n         @v[$i] = @A[$i; $k] / $tmp;\n      }              \n\n      for 0 ..^ $n -> $j {\n         $sum = 0;\n\n         for $k ..^ $m -> $i {\n            $sum += @v[$i] * @A[$i; $j];\n         }\n\n         for $k ..^ $m -> $i {\n            @A[$i; $j] -= 2 * @v[$i] * $sum;\n         }\n      }       \n\n      for 0 ..^ $m -> $j {\n         $sum = 0;\n\n         for $k ..^ $m -> $i {\n            $sum += @v[$i] * @Q[$i; $j];\n         }\n\n         for $k ..^ $m -> $i {\n            @Q[$i; $j] -= 2 * @v[$i] * $sum;\n         }\n      }\n   }\n\n   @Q\n}\n \nsub dotp(@a where Array:D, @b where Array:D --> Real) {\n   [+] @a >>*<< @b;\n}\n\nsub upper-solve(Array:D @U, @b where Array:D, Int:D $n --> Array) {\n   my @y = 0 xx $n;\n\n   @y[$n - 1] = @b[$n - 1] / @U[$n - 1; $n - 1];\n\n   for reverse ^($n - 1) -> $i {\n      @y[$i] = (@b[$i] - (dotp(@U[$i], @y))) / @U[$i; $i];\n   }\n   \n   @y;\n}\n\nsub polyfit(@x where Array:D, @y where Array:D, Int:D $n) {\n   my Int $m = @x.elems;\n   my Array @V;\n\n   # Vandermonde matrix\n   for ^$m X (0 .. $n) -> ($i, $j) {\n      @V[$i; $j] = @x[$i] ** $j\n   }\n\n   # least squares\n   my $Q = householder(@V);\n   my @b = multiply($Q, @y);\n\n   return upper-solve(@V, @b, $n + 1);\n}\n\nsub print-mat(Array:D @M, Str:D $name) {\n   my Int ($m, $n) = (@M.elems, @M[0].elems);\n   print \"\\n$name:\\n\";\n\n   for 0 ..^ $m -> $i {\n      for 0 ..^ $n -> $j {\n         print @M[$i; $j].fmt(\"%12.6f \");\n      }\n\n      print \"\\n\";\n   }\n}\n\nsub MAIN() {\n   ############\n   # 1st part #\n   ############\n   my Array @A = (\n      [12, -51,   4],\n      [ 6, 167, -68],\n      [-4,  24, -41],\n      [-1,   1,   0],\n      [ 2,   0,   3]\n   );\n\n   print-mat(@A, 'A');\n   my $Q = householder(@A);\n   $Q = transpose($Q);\n   print-mat($Q, 'Q');\n   # after householder, @A is now @R\n   print-mat(@A, 'R');\n   print-mat(multiply($Q, @A), 'check Q x R = A');\n\n   ############\n   # 2nd part #\n   ############\n   my @x = [^11];\n   my @y = [1, 6, 17, 34, 57, 86, 121, 162, 209, 262, 321];\n\n   my @coef = polyfit(@x, @y, 2);\n\n   say \n      \"\\npolyfit:\\n\", \n      <constant X X^2>.fmt(\"%12s\"),\n      \"\\n\",\n      @coef.fmt(\"%12.6f\");\n}\n\n```\n\noutput:\n\n```\nA:\n   12.000000   -51.000000     4.000000 \n    6.000000   167.000000   -68.000000 \n   -4.000000    24.000000   -41.000000 \n   -1.000000     1.000000     0.000000 \n    2.000000     0.000000     3.000000 \n\nQ:\n   -0.846415     0.391291    -0.343124     0.066137    -0.091462 \n   -0.423207    -0.904087     0.029270     0.017379    -0.048610 \n    0.282138    -0.170421    -0.932856    -0.021942     0.143712 \n    0.070535    -0.014041     0.001099     0.997401     0.004295 \n   -0.141069     0.016656     0.105772     0.005856     0.984175 \n\nR:\n  -14.177447   -20.666627    13.401567 \n   -0.000000  -175.042539    70.080307 \n    0.000000     0.000000    35.201543 \n   -0.000000     0.000000     0.000000 \n    0.000000    -0.000000     0.000000 \n\ncheck Q x R = A:\n   12.000000   -51.000000     4.000000 \n    6.000000   167.000000   -68.000000 \n   -4.000000    24.000000   -41.000000 \n   -1.000000     1.000000    -0.000000 \n    2.000000    -0.000000     3.000000 \n\npolyfit:\n    constant            X          X^2\n    1.000000     2.000000     3.000000\n\n\n```"}]}
{"messages": [{"role": "user", "content": "Generate the sequence of quad-power prime seeds: positive integers **n** such that:\n\n```\n   n1 + n + 1, n2 + n + 1, n3 + n + 1 and n4 + n + 1 are all prime.\n\n```\n\nTask\n\n* Find and display the first fifty quad-power prime seeds. (Or as many as are reasonably supported by your languages math capability if it is less.)\n\nStretch\n\n* Find and display the position and value of first with a value greater than one million, two million, three million.\n\nSee also\n\n* Task: Penta-power prime seeds * A219117 - Numbers n such that n^1+n+1, n^2+n+1, n^3+n+1 and n^4+n+1 are all prime"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\n\nmy @qpps = lazy (1..*).hyper(:5000batch).grep: -> \\n { my \\k = n + 1; (n+k).is-prime && (n²+k).is-prime && (n³+k).is-prime && (n⁴+k).is-prime }\n\nsay \"First fifty quad-power prime seeds:\\n\" ~ @qpps[^50].batch(10)».&comma».fmt(\"%7s\").join: \"\\n\";\n\nsay \"\\nFirst quad-power prime seed greater than:\";\n\nfor 1..10 {\n    my $threshold = Int(1e6 × $_);\n    my $key = @qpps.first: * > $threshold, :k;\n    say \"{$threshold.&cardinal.fmt: '%13s'} is the {ordinal-digit $key + 1}: {@qpps[$key].&comma}\";\n}\n\n```\n\nOutput:\n\n```\nFirst fifty quad-power prime seeds:\n      1       2       5       6      69     131     426   1,665   2,129   2,696\n  5,250   7,929   9,689  13,545  14,154  14,286  16,434  19,760  25,739  27,809\n 29,631  36,821  41,819  46,619  48,321  59,030  60,500  61,955  62,321  73,610\n 77,685  79,646  80,535  82,655  85,251  86,996  91,014  96,566  97,739 105,939\n108,240 108,681 119,754 122,436 123,164 126,489 140,636 150,480 153,179 163,070\n\nFirst quad-power prime seed greater than:\n  one million is the 141st: 1,009,286\n  two million is the 234th: 2,015,496\nthree million is the 319th: 3,005,316\n four million is the 383rd: 4,004,726\n five million is the 452nd: 5,023,880\n  six million is the 514th: 6,000,554\nseven million is the 567th: 7,047,129\neight million is the 601st: 8,005,710\n nine million is the 645th: 9,055,151\n  ten million is the 701st: 10,023,600\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind the sequence of increasing primes, q, from 2 up to but excluding **16,000**,\nwhere the successor of q is the least prime, p, such that p - q is a perfect square."}, {"role": "assistant", "content": "```\nmy @sqp = 2, -> $previous {\n    my $next;\n    for (1..∞).map: *² {\n        $next = $previous + $_;\n        last if $next.is-prime;\n    }\n    $next\n} … *;\n\nsay \"{+$_} matching numbers:\\n\", $_».fmt('%5d').batch(7).join: \"\\n\" given\n    @sqp[^(@sqp.first: * > 16000, :k)];\n\n```\n\nOutput:\n\n```\n49 matching numbers:\n    2     3     7    11    47    83   227\n  263   587   911   947   983  1019  1163\n 1307  1451  1487  1523  1559  2459  3359\n 4259  4583  5483  5519  5843  5879  6203\n 6779  7103  7247  7283  7607  7643  8219\n 8363 10667 11243 11279 11423 12323 12647\n12791 13367 13691 14591 14627 14771 15671\n```"}]}
{"messages": [{"role": "user", "content": "Quaternions   are an extension of the idea of   complex numbers.\n\nA complex number has a real and complex part,   sometimes written as     `a + bi,`  \n  \nwhere     `a`     and     `b`     stand for real numbers, and     `i`     stands for the square root of minus 1.\n\nAn example of a complex number might be     `-3 + 2i,`    \n  \nwhere the real part,     `a`     is     `-3.0`     and the complex part,     `b`     is     `+2.0.`\n\nA quaternion has one real part and *three* imaginary parts,     `i,`       `j,`     and     `k.`\n\nA quaternion might be written as     `a + bi + cj + dk.`\n\nIn the quaternion numbering system:\n\n:   :   :   * `i∙i = j∙j = k∙k = i∙j∙k = -1,`         or more simply,\n            * `ii  = jj  = kk  = ijk   = -1.`\n\nThe order of multiplication is important, as, in general, for two quaternions:\n\n:   :   :   :   `q1`     and     `q2:`         `q1q2 ≠ q2q1.`\n\nAn example of a quaternion might be     `1 +2i +3j +4k`\n\nThere is a list form of notation where just the numbers are shown and the imaginary multipliers    `i,`       `j,`     and     `k`     are assumed by position.\n\nSo the example above would be written as     `(1, 2, 3, 4)`\n\nTask\n\nGiven the three quaternions and their components:\n\n```\n   q  = (1, 2, 3, 4) = (a,  b,  c,  d)\n   q1 = (2, 3, 4, 5) = (a1, b1, c1, d1)\n   q2 = (3, 4, 5, 6) = (a2, b2, c2, d2) \n\n```\n\nAnd a wholly real number     `r = 7.`\n\nCreate functions   (or classes)   to perform simple maths with quaternions including computing:\n\n1. The norm of a quaternion:   \n   `=\n\n   a\n\n   2\n   +\n\n   b\n\n   2\n   +\n\n   c\n\n   2\n   +\n\n   d\n\n   2\n   {\\displaystyle {\\displaystyle ={\\sqrt {a^{2}+b^{2}+c^{2}+d^{2}}}}}`\n2. The negative of a quaternion:   \n      `= (-a, -b, -c, -d)`\n3. The conjugate of a quaternion:   \n      `= ( a, -b, -c, -d)`\n4. Addition of a real number     `r`     and a quaternion     `q:`     \n      `r + q = q + r = (a+r, b, c, d)`\n5. Addition of two quaternions:   \n      `q1 + q2 = (a1+a2, b1+b2, c1+c2, d1+d2)`\n6. Multiplication of a real number and a quaternion:   \n      `qr = rq = (ar, br, cr, dr)`\n7. Multiplication of two quaternions     `q1`     and   `q2`     is given by:   \n      `( a1a2 − b1b2 − c1c2 − d1d2,`    \n     `a1b2 + b1a2 + c1d2 − d1c2,`    \n     `a1c2 − b1d2 + c1a2 + d1b2,`    \n     `a1d2 + b1c2 − c1b2 + d1a2 )`\n8. Show that, for the two quaternions     `q1`     and     `q2:   \n    q1q2 ≠ q2q1`\n\nIf a language has built-in support for quaternions, then use it.\n\nC.f.\n\n* Vector products\n* On Quaternions;   or on a new System of Imaginaries in Algebra.   By Sir William Rowan Hamilton LL.D, P.R.I.A., F.R.A.S., Hon. M. R. Soc. Ed. and Dub., Hon. or Corr. M. of the Royal or Imperial Academies of St. Petersburgh, Berlin, Turin and Paris, Member of the American Academy of Arts and Sciences, and of other Scientific Societies at Home and Abroad, Andrews' Prof. of Astronomy in the University of Dublin, and Royal Astronomer of Ireland."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nclass Quaternion {\n    has Real ( $.r, $.i, $.j, $.k );\n \n    multi method new ( Real $r, Real $i, Real $j, Real $k ) {\n        self.bless: :$r, :$i, :$j, :$k;\n    }\n    multi qu(*@r) is export { Quaternion.new: |@r }\n    sub postfix:<j>(Real $x) is export { qu 0, 0, $x, 0 }\n    sub postfix:<k>(Real $x) is export { qu 0, 0, 0, $x }\n \n    method Str   () { \"$.r + {$.i}i + {$.j}j + {$.k}k\" }\n    method reals () { $.r, $.i, $.j, $.k }\n    method conj  () { qu $.r, -$.i, -$.j, -$.k }\n    method norm  () { sqrt [+] self.reals X** 2 }\n \n    multi infix:<eqv> ( Quaternion $a, Quaternion $b ) is export { $a.reals eqv $b.reals }\n \n    multi infix:<+> ( Quaternion $a,       Real $b ) is export { qu $b+$a.r, $a.i, $a.j, $a.k }\n    multi infix:<+> (       Real $a, Quaternion $b ) is export { qu $a+$b.r, $b.i, $b.j, $b.k }\n    multi infix:<+> ( Quaternion $a,    Complex $b ) is export { qu $b.re + $a.r, $b.im + $a.i, $a.j, $a.k }\n    multi infix:<+> (    Complex $a, Quaternion $b ) is export { qu $a.re + $b.r, $a.im + $b.i, $b.j, $b.k }\n    multi infix:<+> ( Quaternion $a, Quaternion $b ) is export { qu $a.reals Z+ $b.reals }\n \n    multi prefix:<-> ( Quaternion $a ) is export { qu $a.reals X* -1 }\n \n    multi infix:<*> ( Quaternion $a,       Real $b ) is export { qu $a.reals X* $b }\n    multi infix:<*> (       Real $a, Quaternion $b ) is export { qu $b.reals X* $a }\n    multi infix:<*> ( Quaternion $a,    Complex $b ) is export { $a * qu $b.reals, 0, 0 }\n    multi infix:<*> ( Complex $a,    Quaternion $b ) is export { $b R* qu $a.reals, 0, 0 }\n \n    multi infix:<*> ( Quaternion $a, Quaternion $b ) is export {\n\tmy @a_rijk            = $a.reals;\n\tmy ( $r, $i, $j, $k ) = $b.reals;\n\treturn qu [+]( @a_rijk Z* $r, -$i, -$j, -$k ), # real\n\t\t  [+]( @a_rijk Z* $i,  $r,  $k, -$j ), # i\n\t\t  [+]( @a_rijk Z* $j, -$k,  $r,  $i ), # j\n\t\t  [+]( @a_rijk Z* $k,  $j, -$i,  $r ); # k\n    }\n}\nimport Quaternion;\n \nmy $q  = 1 + 2i + 3j + 4k;\nmy $q1 = 2 + 3i + 4j + 5k;\nmy $q2 = 3 + 4i + 5j + 6k;\nmy $r  = 7;\n \nsay \"1) q norm  = {$q.norm}\";\nsay \"2) -q      = {-$q}\";\nsay \"3) q conj  = {$q.conj}\";\nsay \"4) q  + r  = {$q + $r}\";\nsay \"5) q1 + q2 = {$q1 + $q2}\";\nsay \"6) q  * r  = {$q  * $r}\";\nsay \"7) q1 * q2 = {$q1 * $q2}\";\nsay \"8) q1q2 { $q1 * $q2 eqv $q2 * $q1 ?? '==' !! '!=' } q2q1\";\n\n```\n\nOutput:\n\n```\n1) q norm  = 5.47722557505166\n2) -q      = -1 + -2i + -3j + -4k\n3) q conj  = 1 + -2i + -3j + -4k\n4) q  + r  = 8 + 2i + 3j + 4k\n5) q1 + q2 = 5 + 7i + 9j + 11k\n6) q  * r  = 7 + 14i + 21j + 28k\n7) q1 * q2 = -56 + 16i + 24j + 26k\n8) q1q2 != q2q1\n```"}]}
{"messages": [{"role": "user", "content": "Illustration of FIFO behavior\n\nTask\n\nImplement a FIFO queue.\n\nElements are added at one side and popped from the other in the order of insertion.\n\nOperations:\n\n:   * push   (aka *enqueue*)    - add element\n    * pop     (aka *dequeue*)    - pop first element\n    * empty                             - return truth value when empty\n\nErrors:\n\n* handle the error of trying to pop from an empty queue (behavior depends on the language and platform)\n\nSee\n\n* Queue/Usage   for the built-in FIFO or queue of your language or standard library.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\nWe could build a new container class to do FIFO pretty easily, but Arrays already do everything needed by a FIFO queue, so it is easier to just compose a Role on the existing Array class.\n\n```\nrole FIFO {\n    method enqueue ( *@values ) { # Add values to queue, returns the number of values added.\n        self.push: @values;\n        return @values.elems;\n    }\n    method dequeue ( ) {         # Remove and return the first value from the queue.\n                                 # Return Nil if queue is empty.\n        return self.elems ?? self.shift !! Nil;\n    }\n    method is-empty ( ) {        # Check to see if queue is empty. Returns Boolean value.\n        return self.elems == 0;\n    }\n}\n\n# Example usage:\n\nmy @queue does FIFO;\n\nsay @queue.is-empty;                         # -> Bool::True\nfor <A B C> -> $i { say @queue.enqueue: $i } # 1 \\n 1 \\n 1\nsay @queue.enqueue: Any;                     # -> 1\nsay @queue.enqueue: 7, 8;                    # -> 2\nsay @queue.is-empty;                         # -> Bool::False\nsay @queue.dequeue;                          # -> A\nsay @queue.elems;                            # -> 4\nsay @queue.dequeue;                          # -> B\nsay @queue.is-empty;                         # -> Bool::False\nsay @queue.enqueue('OHAI!');                 # -> 1\nsay @queue.dequeue until @queue.is-empty;    # -> C \\n Any() \\n [7 8] \\n OHAI!\nsay @queue.is-empty;                         # -> Bool::True\nsay @queue.dequeue;                          # ->\n\n```"}]}
{"messages": [{"role": "user", "content": "Illustration of FIFO behavior\n\nTask\n\nCreate a queue data structure and demonstrate its operations.\n\n(For implementations of queues, see the FIFO task.)\n\nOperations:\n\n:   :   * push       (aka *enqueue*) - add element\n        * pop         (aka *dequeue*) - pop first element\n        * empty     - return truth value when empty\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku maintains the same list operators of Perl 5, for this task, the operations are:\n\n```\npush (aka enqueue) -- @list.push\npop (aka dequeue)  -- @list.shift\nempty              -- !@list.elems\n\n```\n\nbut there's also @list.pop which removes a item from the end,\nand @list.unshift which add a item on the start of the list.  \nExample:\n\n```\nmy @queue = < a >;\n\n@queue.push('b', 'c'); # [ a, b, c ]\n\nsay @queue.shift; # a\nsay @queue.pop; # c\n\nsay @queue; # [ b ]\nsay @queue.elems; # 1\n\n@queue.unshift('A'); # [ A, b ]\n@queue.push('C'); # [ A, b, C ]\n\n```"}]}
{"messages": [{"role": "user", "content": "Use the quickselect algorithm on the vector\n\n:   [9, 8, 7, 6, 5, 0, 1, 2, 3, 4]\n\nTo show the first, second, third, ... up to the tenth largest member of the vector, in order, here on this page.\n\n* Note: Quick*sort* has a separate task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n**Works with**: rakudo version 2015-10-20\n\n```\nmy @v = <9 8 7 6 5 0 1 2 3 4>;\nsay map { select(@v, $_) }, 1 .. 10;\n \nsub partition(@vector, $left, $right, $pivot-index) {\n    my $pivot-value = @vector[$pivot-index];\n    @vector[$pivot-index, $right] = @vector[$right, $pivot-index];\n    my $store-index = $left;\n    for $left ..^ $right -> $i {\n        if @vector[$i] < $pivot-value {\n            @vector[$store-index, $i] = @vector[$i, $store-index];\n            $store-index++;\n        }\n    }\n    @vector[$right, $store-index] = @vector[$store-index, $right];\n    return $store-index;\n}\n \nsub select( @vector,\n            \\k where 1 .. @vector,\n            \\l where 0 .. @vector = 0,\n            \\r where l .. @vector = @vector.end ) {\n \n    my ($k, $left, $right) = k, l, r;\n \n    loop {\n        my $pivot-index = ($left..$right).pick;\n        my $pivot-new-index = partition(@vector, $left, $right, $pivot-index);\n        my $pivot-dist = $pivot-new-index - $left + 1;\n        given $pivot-dist <=> $k {\n            when Same {\n                return @vector[$pivot-new-index];\n            }\n            when More {\n                $right = $pivot-new-index - 1;\n            }\n            when Less {\n                $k -= $pivot-dist;\n                $left = $pivot-new-index + 1;\n            }\n        }\n    }\n}\n\n```\n\nOutput:\n\n```\n0 1 2 3 4 5 6 7 8 9\n```"}]}
{"messages": [{"role": "user", "content": "A quine is a self-referential program that can,\nwithout any external access, output its own source.\n\nA   **quine**   (named after Willard Van Orman Quine)   is also known as:\n\n:   :   * *self-reproducing automata*   (1972)\n        * *self-replicating program*         or   *self-replicating computer program*\n        * *self-reproducing program*      or   *self-reproducing computer program*\n        * *self-copying program*             or   *self-copying computer program*\n\nIt is named after the philosopher and logician\nwho studied self-reference and quoting in natural language,\nas for example in the paradox \"'Yields falsehood when preceded by its quotation' yields falsehood when preceded by its quotation.\"\n\n\"Source\" has one of two meanings. It can refer to the text-based program source.\nFor languages in which program source is represented as a data structure, \"source\" may refer to the data structure: quines in these languages fall into two categories: programs which print a textual representation of themselves, or expressions which evaluate to a data structure which is equivalent to that expression.\n\nThe usual way to code a quine works similarly to this paradox: The program consists of two identical parts, once as plain code and once *quoted* in some way (for example, as a character string, or a literal data structure). The plain code then accesses the quoted code and prints it out twice, once unquoted and once with the proper quotation marks added. Often, the plain code and the quoted code have to be nested.\n\nTask\n\nWrite a program that outputs its own source code in this way. If the language allows it, you may add a variant that accesses the code directly. You are not allowed to read any external files with the source code. The program should also contain some sort of self-reference, so constant expressions which return their own value which some top-level interpreter will print out. Empty programs producing no output are not allowed.\n\nThere are several difficulties that one runs into when writing a quine, mostly dealing with quoting:\n\n* Part of the code usually needs to be stored as a string or structural literal in the language, which needs to be quoted somehow. However, including quotation marks in the string literal itself would be troublesome because it requires them to be escaped, which then necessitates the escaping character (e.g. a backslash) in the string, which itself usually needs to be escaped, and so on.\n  + Some languages have a function for getting the \"source code representation\" of a string (i.e. adds quotation marks, etc.); in these languages, this can be used to circumvent the quoting problem.\n  + Another solution is to construct the quote character from its character code, without having to write the quote character itself. Then the character is inserted into the string at the appropriate places. The ASCII code for double-quote is 34, and for single-quote is 39.\n* Newlines in the program may have to be reproduced as newlines in the string, which usually requires some kind of escape sequence (e.g. \"\\n\"). This causes the same problem as above, where the escaping character needs to itself be escaped, etc.\n  + If the language has a way of getting the \"source code representation\", it usually handles the escaping of characters, so this is not a problem.\n  + Some languages allow you to have a string literal that spans multiple lines, which embeds the newlines into the string without escaping.\n  + Write the entire program on one line, for free-form languages (as you can see for some of the solutions here, they run off the edge of the screen), thus removing the need for newlines. However, this may be unacceptable as some languages require a newline at the end of the file; and otherwise it is still generally good style to have a newline at the end of a file. (The task is not clear on whether a newline is required at the end of the file.) Some languages have a print statement that appends a newline; which solves the newline-at-the-end issue; but others do not.\n\n**Next to the Quines presented here, many other versions can be found on the Quine page.**\n\nRelated task\n:   * print itself."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Haskell\n\n**Works with**: Rakudo version #32 \"Pisa\"\n\n```\nmy &f = {say $^s, $^s.raku;}; f \"my \\&f = \\{say \\$^s, \\$^s.raku;}; f \"\n```\n\nNote the terminating newline.\n\n**Works with**: Rakudo version 2014.04\n\nA more compact, but still purely functional, approach:\n\n```\n{.fmt($_).say}(<{.fmt($_).say}(<%s>)>)\n```\n\nNote again the terminating newline."}]}
{"messages": [{"role": "user", "content": "Pretty much every programming language has some form of quoting construct to allow embedding of data in a program, be it literal strings, numeric data or some combination thereof.\n\nShow examples of the quoting constructs in your language. Explain where they would likely be used, what their primary use is, what limitations they have and why one might be preferred over another. Is one style interpolating and another not? Are there restrictions on the size of the quoted data? The type? The format?\n\nThis is intended to be open-ended and free form. If you find yourself writing more than a few thousand words of explanation, summarize and provide links to relevant documentation; but do provide at least a fairly comprehensive summary here, on this page, **NOT** just a link to [See the language docs].\n\nNote: This is primarily for quoting constructs for data to be \"embedded\" in some way into a program. If there is some special format for external data, it may be mentioned but that isn't the focus of this task."}, {"role": "assistant", "content": "The Perl philosophy, which Raku thoroughly embraces, is that \"There Is More Than One Way To Do It\" (often abbreviated to TIMTOWTDI). Quoting constructs is an area where this is enthusiastically espoused.\n\nRaku has a whole quoting specific sub-language built in called Q. Q changes the parsing rules inside the quoting structure and allows extremely fine control over how the enclosed data is parsed. Every quoting construct in Raku is some form of a Q syntactic structure, using adverbs to fine tune the desired behavior, though many of the most commonly used have some form of \"shortcut\" syntax for quick and easy use. Usually, when using an adverbial form, you may omit the Q: and just use the adverb.\n\nIn general, any and all quoting structures have theoretically unlimited length, in practice, are limited by memory size, practically, it is probably better to limit them to less than a gigabyte or so, though they can be read as a supply, not needing to hold the whole thing in memory at once. They can hold multiple lines of data. How the new-line characters are treated depends entirely on any white-space adverb applied. The Q forms use some bracketing character to delimit the quoted data. Usually some Unicode bracket ( [], {}, <>, ⟪⟫, whatever,) that has an \"open\" and \"close\" bracketing character, but they may use any non-indentifier character as both opener and closer. ||, //, ??, the list goes on. The universal escape character for constructs that allow escaping is backslash \"\\\".\n\nThe following exposition barely scratches the surface. For much more detail see the **Raku documentation for quoting constructs** for a comprehensive list of adverbs and examples.\n\nThe most commonly used\n\n:   * **Q[ ]**, common shortcut: **｢ ｣**\n\n:   :   :   The most basic form of quoting. No interpolation, no escaping. What is inside is what you get. No exceptions.\n\n:   :   :   ｢Ze backslash characters!\\ \\Zay do NUSSING!! \\｣ -> Ze backslash characters!\\ \\Zay do NUSSING!! \\\n\n:   * \"Single quote\" quoting. - **Q:q[ ]**, adverbial: **q[ ]**, common shortcut: **' '**\n\n:   :   :   No interpolation, but allow escaping quoting characters.\n\n:   :   :   'Don\\'t panic!' -> Don't panic!\n\n:   * \"Double quote\" quoting. - **Q:qq[ ]**, adverbial: **qq[ ]**, common shortcut: **\" \"**\n\n:   :   :   Interpolates: embedded variables, logical characters, character codes, continuations.\n\n:   :   :   \"Hello $name, today is {Date.today} \\c[grinning face] \\n🦋\" -> Hello Dave, today is 2020-03-25 😀\n        :   🦋\n\n:   :   :   Where $name is a variable containing a name (one would imagine), {Date.today} is a continuation - a code block to be executed and the result inserted, \\c[grinning face] is the literal emoji character 😀 as a character code, \\n is a new-line character and 🦋 is an emoji butterfly. Allows escape sequences, and indeed, requires them when embedding data that *looks* like it may be an interpolation target but isn't.\n\n*Every adverbial form has both a q and a qq variant to give the 'single quote' or \"double quote\" semantics. Only the most commonly used are listed here.*\n\n:   * \"Quote words\" - **Q:qw[ ]**, adverbial: **qw[ ]**, common shortcut: **< >**\n\n:   :   :   No interpolation, but allow escaping quote characters. (Inherited from the q[] escape semantics)\n\n:   :   :   < a β 3 Б 🇩🇪 >\n\n:   :   :   Parses whatever is inside as a white-space separated list of words. Returns a list with all white space removed. Any numeric values are returned as **allomorphs**.\n\n:   :   :   That list may be operated on directly with any listy operator or it may be assigned to a variable.\n\n:   :   :   say < a β 3 Б 🇩🇪 >[\\*-1] # What is the last item in the list? (🇩🇪)\n\n:   :   :   say +< a β 3 Б 🇩🇪 > # How many items are in the list? (5)\n\n:   * \"Quote words with white space protection\" - **Q:qww[ ]**, adverbial: **qww[ ]**\n\n:   :   :   May preserve white space by enclosing it in single or double quote characters, otherwise identical to qw[ ].\n\n:   :   :   say qww< a β '3 Б' 🇩🇪 >[2] # Item 2 in the list? (3 Б)\n\n:   * \"Double quote words\" quoting. - **Q:qqw[ ]**, adverbial: **qqw[ ]**, common shortcut: **<< >>** or **« »**\n\n:   :   :   Interpolates similar to standard double quote, but then interprets the interpolated string as a white space separated list.\n\n:   * \"Double quoted words with white space protection\" - **Q:qqww[ ]**, adverbial: **qqww[ ]**\n\n:   :   :   Same as qqw[ ] but retains quoted white space.\n\n:   * \"System command\" - **Q:qx[ ]**, adverbial: **qx[ ]**\n\n:   :   :   Execute the string inside the construct as a system command and return the result.\n\n:   * \"Heredoc format\" - **Q:q:to/END/; END**, adverbial: **q:to/END/; END**\n\n:   :   :   Return structured text between two textual delimiters. Depending on the adverb, may or may not interpolate (same rules as other adverbial forms.) Will return the text with the same indent as the indent of the final delimiter. The text delimiter is user chosen (and is typically, though not necessarily, uppercase) as is the delimiter bracket character.\n\nThere are other adverbs to give precise control what interpolates or doesn't, that may be applied to any of the above constructs. See **the doc page for details**. There is another whole sub-genre dedicated to **quoting regexes**."}]}
{"messages": [{"role": "user", "content": "Definition\n\nThe **radical** of a positive integer is defined as the product of its distinct prime factors.\n\nAlthough the integer 1 has no prime factors, its radical is regarded as 1 by convention.\n\nExample\n\nThe radical of 504 = 2³ x 3² x 7 is: 2 x 3 x 7 = 42.\n\nTask\n\n1. Find and show on this page the radicals of the first **50** positive integers.\n\n2. Find and show the radicals of the integers: **99999, 499999** and **999999**.\n\n3. By considering their radicals, show the distribution of the first **one million** positive integers by numbers of distinct prime factors (hint: the maximum number of distinct factors is 7).\n\nBonus\n\nBy (preferably) using an independent method, calculate the number of primes and the number of powers of primes less than or equal to **one million** and hence check that your answer in 3. above for numbers with one distinct prime is correct.\n\nRelated tasks\n\n* Square-free integers\n* Almost prime\n\nReferences\n\n* Wikipedia article Radical of an integer\n* OEIS sequence A007947: Largest square free number dividing n"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\nuse List::Divvy;\nuse Lingua::EN::Numbers;\n\nsub radical ($_) { [×] unique .&prime-factors }\n\nsay \"First fifty radicals:\\n\" ~\n  (1..50).map({.&radical}).batch(10)».fmt(\"%2d\").join: \"\\n\";\nsay '';\n\nprintf \"Radical for %7s => %7s\\n\", .&comma, comma .&radical\n  for 99999, 499999, 999999;\n\nmy %rad = 1 => 1;\nmy $limit = 1e6.Int;\n\n%rad.push: $_ for (2..$limit).race(:1000batch).map: {(unique .&prime-factors).elems => $_};\n\nsay \"\\nRadical factor count breakdown, 1 through {comma $limit}:\";\nsay .key ~ \" => {comma +.value}\" for sort %rad;\n\nmy @primes = (2..$limit).grep: &is-prime;\n\nmy int $powers;\n@primes.&upto($limit.sqrt.floor).map: -> $p {\n   for (2..*) { ($p ** $_) < $limit ?? ++$powers !! last }\n}\n\nsay qq:to/RADICAL/;\n\n    Up to {comma $limit}:\n    Primes: {comma +@primes}\n    Powers:    $powers\n    Plus 1:      1\n    Total:  {comma 1 + $powers + @primes}\n    RADICAL\n\n```\n\nOutput:\n\n```\nFirst fifty radicals:\n 1  2  3  2  5  6  7  2  3 10\n11  6 13 14 15  2 17  6 19 10\n21 22 23  6  5 26  3 14 29 30\n31  2 33 34 35  6 37 38 39 10\n41 42 43 22 15 46 47  6  7 10\n\nRadical for  99,999 =>  33,333\nRadical for 499,999 =>   3,937\nRadical for 999,999 => 111,111\n\nRadical factor count breakdown, 1 through 1,000,000:\n1 => 78,735\n2 => 288,726\n3 => 379,720\n4 => 208,034\n5 => 42,492\n6 => 2,285\n7 => 8\n\nUp to 1,000,000:\nPrimes: 78,498\nPowers:    236\nPlus 1:      1\nTotal:  78,735\n\n```"}]}
{"messages": [{"role": "user", "content": "Railway circuit\n\nGiven   **n**   sections of curve tracks,   each one being an arc of   **30°**   of radius   **R**.\n\nThe goal is to build and count all possible different railway circuits.\n\nConstraints\n\n* **n** = 12 + k\\*4     (k = 0, 1,  ...)\n* The circuit must be a closed, connected graph, and the last arc must join the first one\n* Duplicates, either by symmetry, translation, reflexion, or rotation must be eliminated.\n* Paths may overlap or cross each other.\n* All tracks must be used.\n\nIllustrations\n\nhttp://www.echolalie.org/echolisp/duplo.html\n\nTask\n\nWrite a function which counts and displays all possible circuits   **Cn**   for   **n** = 12, 16, 20.\n\nExtra credit for   **n** = 24, 28, ... 48     (no display, only counts).\n\nA circuit   **Cn**   will be displayed as a list, or sequence of   **n**   Right=1/Left=-1 turns.\n\nExamples\n:   :   :   :   C12 = (1,1,1,1,1,1,1,1,1,1,1,1)               and\n            :   C12 = (-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1)\n\nStraight tracks (extra-extra credit)\n\nSuppose we have   **m** = k\\*2   sections of straight tracks, each of length   L.\n\nSuch a circuit is denoted   **Cn,m**\n\nA circuit is a sequence of   +1,   -1,   or   0 = straight move.\n\nCount the number of circuits   **Cn,m**   with   **n**   same as above and   **m** = 2  to  8"}, {"role": "assistant", "content": "**Translation of**: Julia\n\n```\n#!/usr/bin/env raku\n\n# 20200406 Raku programming solution\n\nclass 𝒫 { has ($.x, $.y) } # Point\n\nmulti infix:<⊞>(𝒫 \\p, 𝒫 \\q) { 𝒫.bless: x => p.x + q.x , y => p.y + q.y }\nmulti infix:<≈>(𝒫 \\p, 𝒫 \\q) { my $*TOLERANCE = .0001; p.x ≅ q.x and p.y ≅ q.y }\n\nconstant twelvesteps = (1..12).map: { 𝒫.new: x =>sin(π*$_/6), y=>cos(π*$_/6) };\nconstant foursteps   = (1..4).map:  { 𝒫.new: x =>sin(π*$_/2), y=>cos(π*$_/2) };\n\nsub digits($n!, $base!, $pad=0) {\n   my @output =  $n.base($base).comb.reverse;\n   @output.append: 0 xx ($pad - +@output) if $pad > +@output;\n   return @output\n} # rough port of https://docs.julialang.org/en/v1/base/numbers/#Base.digits\n\nsub addsymmetries(%infound, \\turns) {\n   my @allsym.push: | .&{ (0..^+@$_).map: -> $n {rotate @$_, $n} } for turns, -«turns;\n   %infound{$_} = True for @allsym;\n   return @allsym.max\n}\n\nsub isclosedpath(@turns, \\straight, \\start= 𝒫.bless: x => 0, y => 0) {\n   return False unless ( @turns.sum % (straight ?? 4 !! 12) ) == 0;\n   my ($angl, $point) = (0, start);\n   for @turns -> $turn {\n      $angl  += $turn;\n      $point ⊞= straight ?? foursteps[$angl % 4] !! twelvesteps[$angl % 12];\n   }\n   return $point ≈ start;\n}\n\nsub allvalidcircuits(\\N, \\doPrint=False, \\straight=False) {\n   my ( @found, %infound );\n   say \"\\nFor N of \",N,\" and \", straight ?? \"straight\" !! \"curved\", \" track: \";\n   for (straight ?? (0..^3**N) !! (0..^2**N)) -> \\i {\n      my @turns = straight ??\n         digits(i,3,N).map: { $_ == 0 ??  0 !! ($_ == 1 ?? -1 !! 1) } !!\n         digits(i,2,N).map: { $_ == 0 ?? -1 !! 1 } ;\n      if isclosedpath(@turns, straight) && !(%infound{@turns.Str}:exists) {\n         my \\canon = addsymmetries(%infound, @turns);\n         say canon if doPrint;\n         @found.push: canon.Str;\n      }\n   }\n   say \"There are \", +@found, \" unique valid circuits.\";\n   return @found\n}\n\nallvalidcircuits($_, $_ < 28) for 12, 16, 20;    # 12, 16 … 36\nallvalidcircuits($_, $_ < 12, True) for 4, 6, 8; # 4, 6 … 16;\n\n```\n\nOutput:\n\n```\nFor N of 12 and curved track:\n[1 1 1 1 1 1 1 1 1 1 1 1]\nThere are 1 unique valid circuits.\n\nFor N of 16 and curved track:\n[1 1 1 1 1 1 1 -1 1 1 1 1 1 1 1 -1]\nThere are 1 unique valid circuits.\n\nFor N of 20 and curved track:\n[1 1 1 1 1 1 1 1 -1 -1 1 1 1 1 1 1 1 1 -1 -1]\n[1 1 1 1 1 1 1 -1 1 1 -1 1 1 1 1 1 1 1 -1 -1]\n[1 1 1 1 1 1 1 -1 1 -1 1 1 1 1 1 1 1 -1 1 -1]\n[1 1 1 1 1 1 -1 1 1 -1 1 1 1 1 1 1 -1 1 1 -1]\n[1 1 1 1 1 -1 1 1 1 -1 1 1 1 1 1 -1 1 1 1 -1]\n[1 1 1 1 -1 1 1 1 1 -1 1 1 1 1 -1 1 1 1 1 -1]\nThere are 6 unique valid circuits.\n\nFor N of 4 and straight track:\n[1 1 1 1]\nThere are 1 unique valid circuits.\n\nFor N of 6 and straight track:\n[1 1 0 1 1 0]\nThere are 1 unique valid circuits.\n\nFor N of 8 and straight track:\n[1 1 0 0 1 1 0 0]\n[1 0 1 0 1 0 1 0]\n[1 1 0 1 0 1 1 -1]\n[1 1 1 0 -1 -1 -1 0]\n[1 1 1 1 1 1 1 1]\n[1 1 1 1 -1 -1 -1 -1]\n[1 1 1 -1 1 1 1 -1]\nThere are 7 unique valid circuits.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n:   Print out the word 'RAINBOW' to the screen with every character being a different color of the rainbow."}, {"role": "assistant", "content": "```\nuse Color::Names:api<2>;\nuse Color::Names::X11 :colors;\n\nfor 'RAINBOW',\n    'Another phrase that happens to contain the word \"Rainbow\".'\n  -> $rainbow-text {\n    for $rainbow-text.comb Z, flat(<red orange yellow green blue indigo violet> xx *) -> ($l, $c) {\n        print \"\\e[38;2;{COLORS{\"{$c}-X11\"}<rgb>.join(';')}m$l\\e[0\"\n    }\n    say '';\n}\n\n```\n\nOutput:\n\nDisplayed here as HTML as ANSI colors don't show up on web interfaces.\n\nRAINBOW  \nAnother phrase that happens to contain the word \"Rainbow\"."}]}
{"messages": [{"role": "user", "content": "As the integers get larger, the spacing between prime numbers slowly lengthens, but the spacing\nbetween primes increases at a slower rate than the numbers themselves increase. A consequence of\nthis difference in rates of increase is the existence of special primes, called Ramanujan primes.\n\nThe `n`th Ramanujan prime is defined to be the least integer for which there are at least n primes between\nx and x/2 for all x greater or equal to n.\n\nTask\n\n* :   Generate and show the first 100 Ramanujan prime numbers.\n\n* :   Find and show the 1000th Ramanujan prime number.\n\nStretch task\n\n* :   Find and show the 10,000th Ramanujan prime number.\n\nSee also\n\n:   * The pi prime function, not to be confused with the transcendental number π\n    * The OEIS entry:   OEIS entry\n    * The Wikipedia entry: Ramanujan\\_prime."}, {"role": "assistant", "content": "All timings are purely informational. Will vary by system specs and load.\n\n### Pure Raku\n\n```\nuse Math::Primesieve;\nuse Lingua::EN::Numbers;\n\nmy $primes = Math::Primesieve.new;\n\nmy @mem;\n\nsub ramanujan-prime (\\n) {\n   1 + (1..(4×n × (4×n).log / 2.log).floor).first: :end, -> \\x {\n       my \\y = x div 2;\n       ((@mem[x] //= $primes.count(x)) - (@mem[y] //= $primes.count(y))) < n\n   }\n}\n\nsay 'First 100:';\nsay (1..100).map( &ramanujan-prime ).batch(10)».&comma».fmt(\"%6s\").join: \"\\n\";\nsay \"\\n 1,000th: { comma 1000.&ramanujan-prime }\";\nsay \"10,000th: {  comma 10000.&ramanujan-prime }\";\nsay (now - INIT now).fmt('%.3f') ~ ' seconds';\n\n```\n\nOutput:\n\n```\nFirst 100:\n     2     11     17     29     41     47     59     67     71     97\n   101    107    127    149    151    167    179    181    227    229\n   233    239    241    263    269    281    307    311    347    349\n   367    373    401    409    419    431    433    439    461    487\n   491    503    569    571    587    593    599    601    607    641\n   643    647    653    659    677    719    727    739    751    769\n   809    821    823    827    853    857    881    937    941    947\n   967    983  1,009  1,019  1,021  1,031  1,049  1,051  1,061  1,063\n 1,087  1,091  1,097  1,103  1,151  1,163  1,187  1,217  1,229  1,249\n 1,277  1,289  1,297  1,301  1,367  1,373  1,423  1,427  1,429  1,439\n\n 1,000th: 19,403\n10,000th: 242,057\n18.405 seconds\n```\n\n### ntheory library\n\n**Library:** ntheory\n\n```\nuse ntheory:from<Perl5> <ramanujan_primes nth_ramanujan_prime>;\nuse Lingua::EN::Numbers;\n\nsay 'First 100:';\nsay ramanujan_primes( nth_ramanujan_prime(100) ).batch(10)».&comma».fmt(\"%6s\").join: \"\\n\";\n\nfor (2..12).map: {exp $_, 10} -> $limit {\n    say \"\\n{tc ordinal $limit}: { comma nth_ramanujan_prime($limit) }\";\n}\n\nsay (now - INIT now).fmt('%.3f') ~ ' seconds';\n\n```\n\nOutput:\n\n```\nFirst 100:\n     2     11     17     29     41     47     59     67     71     97\n   101    107    127    149    151    167    179    181    227    229\n   233    239    241    263    269    281    307    311    347    349\n   367    373    401    409    419    431    433    439    461    487\n   491    503    569    571    587    593    599    601    607    641\n   643    647    653    659    677    719    727    739    751    769\n   809    821    823    827    853    857    881    937    941    947\n   967    983  1,009  1,019  1,021  1,031  1,049  1,051  1,061  1,063\n 1,087  1,091  1,097  1,103  1,151  1,163  1,187  1,217  1,229  1,249\n 1,277  1,289  1,297  1,301  1,367  1,373  1,423  1,427  1,429  1,439\n\nOne hundredth: 1,439\n\nOne thousandth: 19,403\n\nTen thousandth: 242,057\n\nOne hundred thousandth: 2,916,539\n\nOne millionth: 34,072,993\n\nTen millionth: 389,433,437\n\nOne hundred millionth: 4,378,259,731\n\nOne billionth: 48,597,112,639\n\nTen billionth: 533,902,884,973\n\nOne hundred billionth: 5,816,713,968,619\n\nOne trillionth: 62,929,891,461,461\n15.572 seconds\n```"}]}
{"messages": [{"role": "user", "content": "In a manner similar to twin primes, twin Ramanujan primes may be explored. The task is to determine how many of the first million Ramanujan primes are twins.\n\nRelated Task\n:   Twin primes"}, {"role": "assistant", "content": "Timing is informational only. Will vary by system specs and load.\n\n**Library:** ntheory\n\n```\nuse ntheory:from<Perl5> <ramanujan_primes nth_ramanujan_prime>;\nuse Lingua::EN::Numbers;\n\nmy @rp = ramanujan_primes nth_ramanujan_prime 1_000_000;\n\nfor (1e5, 1e6)».Int -> $limit {\n    say \"\\nThe {comma $limit}th Ramanujan prime is { comma @rp[$limit-1]}\";\n    say \"There are { comma +(^($limit-1)).race.grep: { @rp[$_+1] == @rp[$_]+2 } } twins in the first {comma $limit} Ramanujan primes.\";\n}\n\nsay (now - INIT now).fmt('%.3f') ~ ' seconds';\n\n```\n\nOutput:\n\n```\nThe 100,000th Ramanujan prime is 2,916,539\nThere are 8,732 twins in the first 100,000 Ramanujan primes.\n\nThe 1,000,000th Ramanujan prime is 34,072,993\nThere are 74,973 twins in the first 1,000,000 Ramanujan primes.\n2.529 seconds\n```"}]}
{"messages": [{"role": "user", "content": "Calculate Ramanujan's constant (as described on the OEIS site) with at least\n32 digits of precision, by the method of your choice. Optionally, if using the 𝑒\\*\\*(π\\*√*x*) approach,\nshow that when evaluated with the last four Heegner numbers\nthe result is *almost* an integer."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Iterative calculations\n\nTo generate a high-precision value for Ramanujan's constant, code is borrowed from three other Rosettacode tasks\n(with some modifications) for performing calculations of\nthe value of π,\nEuler's number, and\ninteger roots. Additional custom routines for exponentiation are used to ensure all computations are done with rationals, specifically FatRats (rational numbers stored with arbitrary size numerator and denominator). The module Rat::Precise makes it simple to display these to a configurable precision.\n\n```\nuse Rat::Precise;\n\n# set the degree of precision for calculations\nconstant D = 54;\nconstant d = 15;\n\n# two versions of exponentiation where base and exponent are both FatRat\nmulti infix:<**> (FatRat $base, FatRat $exp where * >= 1 --> FatRat) {\n    2 R** $base**($exp/2);\n}\n\nmulti infix:<**> (FatRat $base, FatRat $exp where * <  1 --> FatRat) {\n    constant ε = 10**-D;\n    my $low  = 0.FatRat;\n    my $high = 1.FatRat;\n    my $mid  = $high / 2;\n    my $acc  = my $sqr = sqrt($base);\n\n    while (abs($mid - $exp) > ε) {\n      $sqr = sqrt($sqr);\n      if ($mid <= $exp) { $low  = $mid; $acc ×=   $sqr }\n      else              { $high = $mid; $acc ××= 1/$sqr }\n      $mid = ($low + $high) / 2;\n    }\n    $acc.substr(0, D).FatRat;\n}\n\n# calculation of π\nsub π (--> FatRat) {\n    my ($a, $n) = 1, 1;\n    my $g = sqrt 1/2.FatRat;\n    my $z = .25;\n    my $pi;\n\n    for ^d {\n        given [ ($a + $g)/2, sqrt $a × $g ] {\n            $z -= (.[0] - $a)**2 × $n;\n            $n += $n;\n            ($a, $g) = @$_;\n            $pi = ($a ** 2 / $z).substr: 0, 2 + D;\n        }\n    }\n    $pi.FatRat;\n}\n\nmulti sqrt(FatRat $r --> FatRat) {\n    FatRat.new: sqrt($r.nude[0] × 10**(D×2) div $r.nude[1]), 10**D;\n}\n\n# integer roots\nmulti sqrt(Int $n) {\n    my $guess = 10**($n.chars div 2);\n    my $iterator = { ( $^x + $n div ($^x) ) div 2 };\n    my $endpoint = { $^x == $^y|$^z };\n    min ($guess, $iterator … $endpoint)[*-1, *-2];\n}\n\n# 'cosmetic' cover to upgrade input to FatRat sqrt\nsub prefix:<√> (Int $n) { sqrt($n.FatRat) }\n\n# calculation of 𝑒\nsub postfix:<!> (Int $n) { (constant f = 1, |[\\×] 1..*)[$n] }\nsub 𝑒 (--> FatRat) { sum map { FatRat.new(1,.!) }, ^D }\n\n# inputs, and their difference, formatted decimal-aligned\nsub format ($a,$b) {\n    sub pad ($s) { ' ' x ((34 - d - 1) - ($s.split(/\\./)[0]).chars) }\n    my $c = $b.precise(d, :z);\n    my $d = ($a-$b).precise(d, :z);\n    join \"\\n\",\n        (sprintf \"%11s {pad($a)}%s\\n\", 'Int', $a) ~\n        (sprintf \"%11s {pad($c)}%s\\n\", 'Heegner', $c) ~\n        (sprintf \"%11s {pad($d)}%s\\n\", 'Difference', $d)\n}\n\n# override built-in definitions\nconstant π = &π();\nconstant 𝑒 = &𝑒();\n\nmy $Ramanujan = 𝑒**(π × √163);\nsay \"Ramanujan's constant to 32 decimal places:\\nActual:     \" ~\n    \"262537412640768743.99999999999925007259719818568888\\n\" ~\n    \"Calculated: \", $Ramanujan.precise(32, :z), \"\\n\";\n\nsay \"Heegner numbers yielding 'almost' integers\";\nfor 19, 96, 43, 960, 67, 5280, 163, 640320 -> $heegner, $x {\n    my $almost = 𝑒**(π × √$heegner);\n    my $exact  = $x³ + 744;\n    say format($exact, $almost);\n}\n\n```\n\nOutput:\n\n```\nRamanujan's constant to 32 decimal places:\nActual:     262537412640768743.99999999999925007259719818568888\nCalculated: 262537412640768743.99999999999925007259719818568888\n\nHeegner numbers yielding 'almost' integers\n        Int             885480\n    Heegner             885479.777680154319498\n Difference                  0.222319845680502\n\n        Int          884736744\n    Heegner          884736743.999777466034907\n Difference                  0.000222533965093\n\n        Int       147197952744\n    Heegner       147197952743.999998662454225\n Difference                  0.000001337545775\n\n        Int 262537412640768744\n    Heegner 262537412640768743.999999999999250\n Difference                  0.000000000000750\n```\n\n### Continued fractions\n\nRamanujan's constant can also be generated to an arbitrary precision using standard continued fraction formulas for each component of the 𝑒\\*\\*(π\\*√163) expression. Substantially slower than the first method.\n\n```\nuse Rat::Precise;\n\nsub continued-fraction($n, :@a, :@b) {\n    my $x = @a[0].FatRat;\n    $x = @a[$_ - 1] + @b[$_] / $x for reverse 1 ..^ $n;\n    $x;\n}\n\n#`{ √163 } my $r163 =           continued-fraction( 50, :a(12,|((2*12) xx *)),      :b(19 xx *));\n#`{ π    } my $pi   =         4*continued-fraction(140, :a( 0,|(1, 3 ... *)),       :b(4, 1, |((1, 2, 3 ... *) X** 2)));\n#`{ e**x } my $R    = 1 + ($_ / continued-fraction(170, :a( 1,|(2+$_, 3+$_ ... *)), :b(Nil,  |(-1*$_, -2*$_ ... *)  ))) given $r163*$pi;\n\nsay \"Ramanujan's constant to 32 decimal places:\\n\", $R.precise(32);\n\n```\n\nOutput:\n\n```\nRamanujan's constant to 32 decimal places:\n262537412640768743.99999999999925007259719818568888\n```"}]}
{"messages": [{"role": "user", "content": "The   **Ramer–Douglas–Peucker**   algorithm is a line simplification algorithm for reducing the number of points used to define its shape.\n\nTask\n\nUsing the   **Ramer–Douglas–Peucker**   algorithm, simplify the   2D   line defined by the points:\n\n```\n   (0,0)  (1,0.1)  (2,-0.1)  (3,5)  (4,6)  (5,7)  (6,8.1)  (7,9)  (8,9)  (9,9) \n\n```\n\nThe error threshold to be used is:   **1.0**.\n\nDisplay the remaining points here.\n\nReference\n:   * the Wikipedia article:   Ramer-Douglas-Peucker algorithm."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.05\n\n**Translation of**: C++\n\n```\nsub norm (*@list) { @list»².sum.sqrt }\n\nsub perpendicular-distance (@start, @end where @end !eqv @start, @point) {\n    return 0 if @point eqv any(@start, @end);\n    my ( $Δx, $Δy ) =   @end «-» @start;\n    my ($Δpx, $Δpy) = @point «-» @start;\n    ($Δx, $Δy) «/=» norm $Δx, $Δy;\n    norm ($Δpx, $Δpy) «-» ($Δx, $Δy) «*» ($Δx*$Δpx + $Δy*$Δpy);\n}\n\nsub Ramer-Douglas-Peucker(@points where * > 1, \\ε = 1) {\n    return @points if @points == 2;\n    my @d = (^@points).map: { perpendicular-distance |@points[0, *-1, $_] };\n    my ($index, $dmax) = @d.first: @d.max, :kv;\n    return flat\n      Ramer-Douglas-Peucker( @points[0..$index], ε )[^(*-1)],\n      Ramer-Douglas-Peucker( @points[$index..*], ε )\n      if $dmax > ε;\n    @points[0, *-1];\n}\n\n# TESTING\nsay Ramer-Douglas-Peucker(\n   [(0,0),(1,0.1),(2,-0.1),(3,5),(4,6),(5,7),(6,8.1),(7,9),(8,9),(9,9)]\n);\n\n```\n\nOutput:\n\n```\n((0 0) (2 -0.1) (3 5) (7 9) (9 9))\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind a graph with 17 Nodes such that any 4 Nodes are neither totally connected nor totally unconnected, so demonstrating Ramsey's theorem.\n\nA specially-nominated solution may be used, but if so it **must** be checked to see if if there are any sub-graphs that are totally connected or totally unconnected."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.08\n\n```\nmy $n = 17;\nmy @a = [ 0 xx $n ] xx $n;\n@a[$_;$_] = '-' for ^$n;\n\nfor flat ^$n X 1,2,4,8 -> $i, $k {\n    my $j = ($i + $k) % $n;\n    @a[$i;$j] = @a[$j;$i] = 1;\n}\n.say for @a;\n\nfor combinations($n,4) -> $quartet {\n    my $links = [+] $quartet.combinations(2).map: -> $i,$j { @a[$i;$j] }\n    die \"Bogus!\" unless 0 < $links < 6;\n}\nsay \"OK\";\n\n```\n\nOutput:\n\n```\n- 1 1 0 1 0 0 0 1 1 0 0 0 1 0 1 1\n1 - 1 1 0 1 0 0 0 1 1 0 0 0 1 0 1\n1 1 - 1 1 0 1 0 0 0 1 1 0 0 0 1 0\n0 1 1 - 1 1 0 1 0 0 0 1 1 0 0 0 1\n1 0 1 1 - 1 1 0 1 0 0 0 1 1 0 0 0\n0 1 0 1 1 - 1 1 0 1 0 0 0 1 1 0 0\n0 0 1 0 1 1 - 1 1 0 1 0 0 0 1 1 0\n0 0 0 1 0 1 1 - 1 1 0 1 0 0 0 1 1\n1 0 0 0 1 0 1 1 - 1 1 0 1 0 0 0 1\n1 1 0 0 0 1 0 1 1 - 1 1 0 1 0 0 0\n0 1 1 0 0 0 1 0 1 1 - 1 1 0 1 0 0\n0 0 1 1 0 0 0 1 0 1 1 - 1 1 0 1 0\n0 0 0 1 1 0 0 0 1 0 1 1 - 1 1 0 1\n1 0 0 0 1 1 0 0 0 1 0 1 1 - 1 1 0\n0 1 0 0 0 1 1 0 0 0 1 0 1 1 - 1 1\n1 0 1 0 0 0 1 1 0 0 0 1 0 1 1 - 1\n1 1 0 1 0 0 0 1 1 0 0 0 1 0 1 1 -\nOK\n```"}]}
{"messages": [{"role": "user", "content": "A Latin square of size `n` is an arrangement of `n` symbols in an `n-by-n` square in such a way that each row and column has each symbol appearing exactly once.  \nFor the purposes of this task, a random Latin square of size `n` is a Latin square constructed or generated by a probabilistic procedure such that the probability of any particular Latin square of size `n` being produced is non-zero.\n\nExample n=4 randomised Latin square\n\n```\n0 2 3 1\n2 1 0 3\n3 0 1 2\n1 3 2 0\n```\n\nTask\n\n1. Create a function/routine/procedure/method/... that given `n` generates a randomised Latin square of size `n`.\n2. Use the function to generate *and show here*, two randomly generated squares of size 5.\n\nNote\n\nStrict *uniformity* in the random generation is a hard problem and **not** a requirement of the task.\n\nRelated tasks\n\n* Latin Squares in reduced form/Randomizing using Jacobson and Matthews’ Technique\n* Latin Squares in reduced form\n\nReference\n\n* Wikipedia: Latin square\n* OEIS: A002860"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\n**Translation of**: Python\n\n```\nsub latin-square { [[0],] };\n\nsub random ( @ls, :$size = 5 ) {\n\n    # Build\n    for 1 ..^ $size -> $i {\n        @ls[$i] = @ls[0].clone;\n        @ls[$_].splice($_, 0, $i) for 0 .. $i;\n    }\n\n    # Shuffle\n    @ls = @ls[^$size .pick(*)];\n    my @cols = ^$size .pick(*);\n    @ls[$_] = @ls[$_][@cols] for ^@ls;\n\n    # Some random Latin glyphs\n    my @symbols = ('A' .. 'Z').pick($size);\n\n    @ls.deepmap: { $_ = @symbols[$_] };\n\n}\n\nsub display ( @array ) { $_.fmt(\"%2s \").put for |@array, '' }\n\n\n# The Task\n\n# Default size 5\ndisplay random latin-square;\n\n# Specified size\ndisplay random :size($_), latin-square for 5, 3, 9;\n\n# Or, if you'd prefer:\ndisplay random latin-square, :size($_) for 12, 2, 1;\n\n```\n\nSample output:\n\n```\n V   Z   M   J   U \n Z   M   U   V   J \n U   J   V   M   Z \n J   V   Z   U   M \n M   U   J   Z   V \n   \n B   H   K   U   D \n H   D   U   B   K \n K   U   H   D   B \n U   B   D   K   H \n D   K   B   H   U \n   \n I   P   Y \n P   Y   I \n Y   I   P \n   \n Y   J   K   E   Z   B   I   W   H \n E   Y   B   W   K   H   J   Z   I \n B   K   Y   H   J   E   Z   I   W \n I   H   W   J   E   Z   B   Y   K \n J   I   Z   Y   W   K   H   E   B \n W   E   H   Z   B   I   Y   K   J \n H   B   E   I   Y   W   K   J   Z \n K   Z   J   B   I   Y   W   H   E \n Z   W   I   K   H   J   E   B   Y \n   \n L   Q   E   M   A   T   Z   C   N   Y   R   D \n Q   R   Y   L   N   D   C   E   M   T   A   Z \n E   Y   M   C   D   Q   A   N   Z   L   T   R \n M   L   C   N   R   Y   D   Z   A   E   Q   T \n N   M   Z   A   Q   E   T   D   R   C   L   Y \n T   D   Q   Y   C   A   M   L   E   R   Z   N \n R   A   T   Q   M   Z   E   Y   L   D   N   C \n D   Z   R   T   E   N   L   Q   Y   A   C   M \n Y   T   L   E   Z   R   N   M   C   Q   D   A \n A   N   D   R   L   C   Y   T   Q   Z   M   E \n Z   C   A   D   Y   M   Q   R   T   N   E   L \n C   E   N   Z   T   L   R   A   D   M   Y   Q \n   \n Y   G \n G   Y \n   \n I\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nIf your system has a means to generate random numbers involving not only a software algorithm   (like the /dev/urandom devices in Unix),   then:\n\nshow how to obtain a random 32-bit number from that mechanism.\n\nRelated task\n\n* Random\\_number\\_generator\\_(included)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016-11\n\nA lazy list of random numbers:\n\n```\nuse experimental :pack;\nmy $UR = open(\"/dev/urandom\", :bin) orelse .die;\nmy @random-spigot = $UR.read(1024).unpack(\"L*\") ... *;\n\n.say for @random-spigot[^10];\n\n```\n\nOutput:\n\n```\n1431009271\n1702240522\n670020272\n588612037\n1864913839\n2155430433\n1690056587\n385405103\n2366495746\n692037942\n```"}]}
{"messages": [{"role": "user", "content": "The task is to:\n\n:   State the type of random number generator algorithm used in a language's built-in random number generator. If the language or its immediate libraries don't provide a random number generator, skip this task.\n:   If possible, give a link to a wider explanation of the algorithm used.\n\nNote: the task is *not* to create an RNG, but to report on the languages in-built RNG that would be the most likely RNG used.\n\nThe main types of pseudo-random number generator (PRNG) that are in use are the Linear Congruential Generator (LCG), and the Generalized Feedback Shift Register (GFSR), (of which the Mersenne twister generator is a subclass). The last main type is where the output of one of the previous ones (typically a Mersenne twister) is fed through a cryptographic hash function to maximize unpredictability of individual bits.\n\nNote that neither LCGs nor GFSRs should be used for the most demanding applications (cryptography) without additional steps."}, {"role": "assistant", "content": "(formerly Perl 6)\nThe implementation underlying the rand function is platform and VM dependent. The JVM backend uses that platform's SecureRandom class."}]}
{"messages": [{"role": "user", "content": "Task\n\nGenerate a collection filled with   **1000**   normally distributed random (or pseudo-random) numbers\nwith a mean of   **1.0**   and a   standard deviation   of   **0.5**\n\nMany libraries only generate uniformly distributed random numbers. If so, you may use one of these algorithms.\n\nRelated task\n\n* Standard deviation"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #22 \"Thousand Oaks\"\n\n```\nsub randnorm ($mean, $stddev) {\n    $mean + $stddev * sqrt(-2 * log rand) * cos(2 * pi * rand)\n}\n\nmy @nums = randnorm(1, 0.5) xx 1000;\n\n# Checking\nsay my $mean = @nums R/ [+] @nums;\nsay my $stddev = sqrt $mean**2 R- @nums R/ [+] @nums X** 2;\n\n```"}]}
{"messages": [{"role": "user", "content": "* Read in the book \"The War of the Worlds\", by H. G. Wells.\n* Skip to the start of the book, proper.\n* Remove extraneous punctuation, but keep at least sentence-ending punctuation characters . ! and ?\n* Keep account of what words follow words and how many times it is seen, (treat sentence terminators as words too).\n* Keep account of what words follow *two* words and how many times it is seen, (again treating sentence terminators as words too).\n* Assume that a sentence starts with a not to be shown full-stop character then *use a weighted random choice* of the possible words that may follow a full-stop to add to the sentence.\n* Then repeatedly add words to the sentence based on weighted random choices of what words my follow the last two words to extend the sentence.\n* Stop after adding a sentence ending punctuation character.\n* Tidy and then print the sentence.\n\nShow examples of random sentences generated.\n\nRelated task\n\n* Markov\\_chain\\_text\\_generator"}, {"role": "assistant", "content": "Started out as translation of Perl, but diverged.\n\n```\nmy $text = '36-0.txt'.IO.slurp.subst(/.+ '*** START OF THIS' .+? \\n (.*?) 'End of the Project Gutenberg EBook' .*/, {$0} );\n\n$text.=subst(/ <+punct-[.!?\\’,]> /, ' ', :g);\n$text.=subst(/ (\\s) '’' (\\s)  /, '', :g);\n$text.=subst(/ (\\w) '’' (\\s)  /, {$0~$1}, :g);\n$text.=subst(/ (\\s) '’' (\\w)  /, {$0~$1}, :g);\n\nmy (%one, %two);\n\nfor $text.comb(/[\\w+(\\’\\w+)?]','?|<punct>/).rotor(3 => -2) {\n    %two{.[0]}{.[1]}{.[2]}++;\n    %one{.[0]}{.[1]}++;\n}\n\nsub weightedpick (%hash) { %hash.keys.map( { $_ xx %hash{$_} } ).pick }\n\nsub sentence {\n    my @sentence = <. ! ?>.roll;\n    @sentence.push: weightedpick( %one{ @sentence[0] } );\n    @sentence.push: weightedpick( %two{ @sentence[*-2] }{ @sentence[*-1] } // %('.' => 1) )[0]\n      until @sentence[*-1] ∈ <. ! ?>;\n    @sentence.=squish;\n    shift @sentence;\n    redo if @sentence < 7;\n    @sentence.join(' ').tc.subst(/\\s(<:punct>)/, {$0}, :g);\n}\n\nsay sentence() ~ \"\\n\" for ^10;\n\n```\n\nSample output:\n\n```\nTo the inhabitants calling itself the Committee of Public Supply seized the opportunity of slightly shifting my position, which had caused a silent mass of smoke rose slanting and barred the face.\n\nWhy was I after the Martian within the case, but that these monsters.\n\nAs if hell was built for rabbits!\n\nThenks and all that the Secret of Flying, was discovered.\n\nOr did a Martian standing sentinel I suppose the time we drew near the railway officials connected the breakdown with the butt.\n\nFlutter, flutter, went the bats, heeding it not been for the big table like end of it a great light was seen by the humblest things that God, in his jaws coming headlong towards me, and rapidly growing hotter.\n\nSurvivors there were no longer venturing into the side roads of the planet in view.\n\nJust as they began playing at touch in and out into the west, but nothing to me the landscape, weird and vague and strange and incomprehensible that for the wet.\n\nJust as they seem to remember talking, wanderingly, to myself for an accident, but the captain lay off the platforms, and my wife to their former stare, and his lower limbs lay limp and dead horses.\n\nEntrails they had fought across to the post office a little one roomed squatter’s hut of wood, surrounded by a gradual development of brain and hands, the latter giving rise to the corner.\n```"}]}
{"messages": [{"role": "user", "content": "Define a range of numbers   **R**,   with bounds   **b0**   and   **b1**   covering all numbers *between and including both bounds*.\n\nThat range can be shown as:\n\n:   :   :   :   :   :   :   :   :   **[b0, b1]**\n                            :   or equally as:\n\n                                :   **[b1, b0]**\n\nGiven two ranges, the act of consolidation between them compares the two ranges:\n\n* If one range covers all of the other then the result is that encompassing range.\n* If the ranges touch or intersect then the result is   *one*   new single range covering the overlapping ranges.\n* Otherwise the act of consolidation is to return the two non-touching ranges.\n\nGiven   **N**   ranges where   **N > 2**   then the result is the same as repeatedly replacing all combinations of two ranges by their consolidation until no further consolidation between range pairs is possible.\n\nIf   **N < 2**   then range consolidation has no strict meaning and the input can be returned.\n\nExample 1\n:   Given the two ranges   **[1, 2.5]**   and   **[3, 4.2]**   then\n:   there is no common region between the ranges and the result is the same as the input.\n\nExample 2\n:   Given the two ranges   **[1, 2.5]**   and   **[1.8, 4.7]**   then\n:   there is :   an overlap   **[2.5, 1.8]**   between the ranges and\n:   the result is the single range   **[1, 4.7]**.\n:   Note that order of bounds in a range is not (yet) stated.\n\nExample 3\n:   Given the two ranges   **[6.1, 7.2]**   and   **[7.2, 8.3]**   then\n:   they touch at   **7.2**   and\n:   the result is the single range   **[6.1, 8.3]**.\n\nExample 4\n:   Given the three ranges   **[1, 2]**   and   **[4, 8]**   and   **[2, 5]**\n:   then there is no intersection of the ranges   **[1, 2]**   and   **[4, 8]**\n:   but the ranges   **[1, 2]**   and   **[2, 5]**   overlap and\n:   consolidate to produce the range   **[1, 5]**.\n:   This range, in turn, overlaps the other range   **[4, 8]**,   and\n:   so consolidates to the final output of the single range   **[1, 8]**.\n\nTask\n\nLet a normalized range display show the smaller bound to the left;   and show the\nrange with the smaller lower bound to the left of other ranges when showing multiple ranges.\n\nOutput the *normalized* result of applying consolidation to these five sets of ranges:\n\n```\n           [1.1, 2.2]\n           [6.1, 7.2], [7.2, 8.3]\n           [4, 3], [2, 1]\n           [4, 3], [2, 1], [-1, -2], [3.9, 10]\n           [1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6]  \n\n```\n\nShow all output here.\n\nSee also\n\n* Set consolidation\n* Set of real numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\nIn Raku, a Range is a first class object with its own specialized notation. Raku Ranges allow for exclusion of the boundary numbers. This example doesn't since it isn't a requirement in this task. Much of the logic is lifted from the Set\\_of\\_real\\_numbers task with simplified logic for the much simpler requirements.\n\nNote: the output is in standard Raku notation for Ranges.\n\n```\n# Union\nsub infix:<∪> (Range $a, Range $b) { Range.new($a.min,max($a.max,$b.max)) }\n\n# Intersection\nsub infix:<∩> (Range $a, Range $b) { so $a.max >= $b.min }\n\nmulti consolidate() { () }\n\nmulti consolidate($this is copy, **@those) {\n    gather {\n        for consolidate |@those -> $that {\n            if $this ∩ $that { $this ∪= $that }\n            else             { take $that }\n        }\n        take $this;\n    }\n}\n\nfor [[1.1, 2.2],],\n    [[6.1, 7.2], [7.2, 8.3]],\n    [[4, 3], [2, 1]],\n    [[4, 3], [2, 1], [-1, -2], [3.9, 10]],\n    [[1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6]]\n-> @intervals {\n    printf \"%46s => \", @intervals.raku;\n    say reverse consolidate |@intervals.grep(*.elems)».sort.sort({ [.[0], .[*-1]] }).map: { Range.new(.[0], .[*-1]) }\n}\n\n```\n\nOutput:\n\n```\n                                 [[1.1, 2.2],] => (1.1..2.2)\n                      [[6.1, 7.2], [7.2, 8.3]] => (6.1..8.3)\n                              [[4, 3], [2, 1]] => (1..2 3..4)\n         [[4, 3], [2, 1], [-1, -2], [3.9, 10]] => (-2..-1 1..2 3..10)\n[[1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6]] => (-6..-1 1..8)\n\n```"}]}
{"messages": [{"role": "user", "content": "A format for expressing an ordered list of integers is to use a comma separated list of either\n\n* individual integers\n* Or a range of integers denoted by the starting integer separated from the end integer in the range by a dash, '-'. (The range includes all integers in the interval including both endpoints)\n\n:   * **The range syntax is to be used only for, and for every range that expands to more than two values.**\n\n**Example**  \nThe list of integers:\n\n:   -6, -3, -2, -1, 0, 1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20\n\nIs accurately expressed by the range expression:\n\n:   -6,-3-1,3-5,7-11,14,15,17-20\n\n(And vice-versa).\n\nTask\n\nExpand the range description:\n\n```\n  -6,-3--1,3-5,7-11,14,15,17-20 \n\n```\n\nNote that the second element above,\nis the **range from minus 3 to *minus* 1**.\n\nRelated task\n\n* Range extraction"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.07\n\n```\nsub range-expand (Str $range-description) {\n    my token number { '-'? \\d+ }\n    my token range  { (<&number>) '-' (<&number>) }\n    \n    $range-description\n        .split(',')\n        .map({ .match(&range) ?? $0..$1 !! +$_ })\n        .flat\n}\n \nsay range-expand('-6,-3--1,3-5,7-11,14,15,17-20').join(', ');\n\n```\n\nOutput:\n\n```\n-6, -3, -2, -1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20\n```\n\nAlternatively, using a grammar:\n\n```\ngrammar RangeList {\n    token TOP    { <term>* % ','    { make $<term>.map(*.made)       } }\n    token term   { [<range>|<num>]  { make ($<num> // $<range>).made } }\n    token range  { <num> '-' <num>  { make +$<num>[0] .. +$<num>[1]  } }\n    token num    { '-'? \\d+         { make +$/                       } }\n}\n\nsay RangeList.parse('-6,-3--1,3-5,7-11,14,15,17-20').made.flat.join(', ');\n\n```\n\nOutput:\n\n```\n-6, -3, -2, -1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20\n```"}]}
{"messages": [{"role": "user", "content": "A format for expressing an ordered list of integers is to use a comma separated list of either\n\n* individual integers\n* Or a range of integers denoted by the starting integer separated from the end integer in the range by a dash, '-'. (The range includes all integers in the interval including both endpoints)\n\n:   * **The range syntax is to be used only for, and for every range that expands to more than two values.**\n\n**Example**  \nThe list of integers:\n\n:   -6, -3, -2, -1, 0, 1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20\n\nIs accurately expressed by the range expression:\n\n:   -6,-3-1,3-5,7-11,14,15,17-20\n\n(And vice-versa).\n\nTask\n\n* Create a function that takes a list of integers in increasing order and returns a correctly formatted string in the range format.\n* Use the function to compute and print the range formatted version of the following ordered list of integers. (The correct answer is: `0-2,4,6-8,11,12,14-25,27-33,35-39`).\n\n```\n    0,  1,  2,  4,  6,  7,  8, 11, 12, 14,\n   15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n   25, 27, 28, 29, 30, 31, 32, 33, 35, 36,\n   37, 38, 39\n\n```\n\n* Show the output of your program.\n\nRelated task\n\n* Range expansion"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub range-extraction (*@ints) {\n    my $prev = NaN;\n    my @ranges;\n\n    for @ints -> $int {\n        if $int == $prev + 1 {\n            @ranges[*-1].push: $int;\n        }\n        else {\n            @ranges.push: [$int];\n        }\n        $prev = $int;\n    }\n    join ',', @ranges.map: -> @r { @r > 2 ?? \"@r[0]-@r[*-1]\" !! @r }\n}\n\nsay range-extraction\n    -6, -3, -2, -1, 0, 1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20;\n\nsay range-extraction\n    0,  1,  2,  4,  6,  7,  8, 11, 12, 14,\n    15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n    25, 27, 28, 29, 30, 31, 32, 33, 35, 36,\n    37, 38, 39;\n\n```\n\nOutput:\n\n```\n-6,-3-1,3-5,7-11,14,15,17-20\n0-2,4,6-8,11,12,14-25,27-33,35-39\n```"}]}
{"messages": [{"role": "user", "content": "The increasing range of all integers from a lower to an upper bound, including\neach boundary, is shown by the lower-boundary separated from the\nhigher-boundary by a single dash. So `64-1234` is the range of all integers\nfrom 64 to 1234, (including both 64 and 1234). `10-10` is the range covering\nthe single integer 10.\n\nA sequence of ranges is shown by successive integer ranges that do not overlap,\nand which have *increasing* lower bounds. Each range is separated by a single\ncomma. So `13-14,22-22,100999999-101000001` is a sequence of ranges that\ncontain the integers 13 14 22 100999999 101000000 and 101000001.  \nEmpty ranges are removed. An empty sequence has an empty string representation.\n\nNote: There are NO internal spaces in the sequence format.\n\nTask\n\nGiven an initial sequence of ranges write programs to add or remove an integer\nfrom the sequence and display the resultant sequence.  \nNote:\n\n* The initial sequence may be empty.\n* Adding an int that is already covered should not change the sequence.\n* removing an int that is not in the sequence should not change the sequence.\n* The add and remove operations should print their result in the standard form mentioned.\n* Solutions **must** work by modifying range boundaries, splitting and joining, as well as creating and deleting ranges.   \n   **Do not** use algorithms that create and modify arrays of all the integer values within ranges.\n\nShow the results, (including intermediate results), of performing the following\nsteps\n\nEx0\n\n```\n   Start with \"\"\n       add 77\n       add 79\n       add 78\n       remove 77\n       remove 78\n       remove 79\n       \n\n```\n\nEx1\n\n```\n   Start with \"1-3,5-5\"\n       add 1\n       remove 4\n       add 7\n       add 8\n       add 6\n       remove 7\n\n```\n\nEx2\n\n```\n   Start with \"1-5,10-25,27-30\"\n       add 26\n       add 9\n       add 7\n       remove 26\n       remove 9\n       remove 7\n\n```\n\nRequires Gdip Library"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.09\n\nQuite a bit of this is just transforming syntax back and forth. Raku already has Ranges and Sequences as first class objects, though the syntax is different.\n\nDemonstrate the task required examples: adding and removing integers, as well as an example adding and removing ranges to / from the sequence, in both native Raku syntax and the \"Stringy\" syntax required by the task.\n\nDemo with some extremely large values / ranges. Capable of working with infinite ranges by default.\n\nWon't handle negative numbers as written, mostly due the need to work around the syntax requirements for output.\n\n```\nmy @seq;\n\n-> $op, $string { printf \"%20s -> %s\\n\", $op, $string } for\n  'Start',     to-string( @seq  = canonicalize \"\" ),\n  'add 77',    to-string( @seq .= &add(77) ),\n  'add 79',    to-string( @seq .= &add(79) ),\n  'add 78',    to-string( @seq .= &add(78) ),\n  'remove 77', to-string( @seq .= &remove(77) ),\n  'remove 78', to-string( @seq .= &remove(78) ),\n  'remove 79', to-string( @seq .= &remove(79) );\n\nsay '';\n-> $op, $string { printf \"%20s -> %s\\n\", $op, $string } for\n  'Start',    to-string( @seq  = canonicalize \"1-3,5-5\" ),\n  'add 1',    to-string( @seq .= &add(1) ),\n  'remove 4', to-string( @seq .= &remove(4) ),\n  'add 7',    to-string( @seq .= &add(7) ),\n  'add 8',    to-string( @seq .= &add(8) ),\n  'add 6',    to-string( @seq .= &add(6) ),\n  'remove 7', to-string( @seq .= &remove(7) );\n\nsay '';\n-> $op, $string { printf \"%20s -> %s\\n\", $op, $string } for\n  'Start',     to-string( @seq  = canonicalize \"1-5,10-25,27-30\" ),\n  'add 26',    to-string( @seq .= &add(26) ),\n  'add 9',     to-string( @seq .= &add(9) ),\n  'add 7',     to-string( @seq .= &add(7) ),\n  'remove 26', to-string( @seq .= &remove(26) ),\n  'remove 9',  to-string( @seq .= &remove(9) ),\n  'remove 7',  to-string( @seq .= &remove(7) );\n\nsay '';\n-> $op, $string { printf \"%30s -> %s\\n\", $op, $string } for\n  'Start',                  to-string( @seq  = canonicalize \"6-57,160-251,2700-7000000\" ),\n  'add \"2502-2698\"',        to-string( @seq .= &add(\"2502-2698\") ),\n  'add 41..69',             to-string( @seq .= &add(41..69) ),\n  'remove 17..30',          to-string( @seq .= &remove(17..30) ),\n  'remove 4391..6527',      to-string( @seq .= &remove(\"4391-6527\") ),\n  'add 2699',               to-string( @seq .= &add(2699) ),\n  'add 76',                 to-string( @seq .= &add(76) ),\n  'add 78',                 to-string( @seq .= &add(78) ),\n  'remove \"70-165\"',        to-string( @seq .= &remove(\"70-165\") ),\n  'remove 16..31',          to-string( @seq .= &remove(16..31) ),\n  'add 1.417e16 .. 3.2e21', to-string( @seq .= &add(1.417e16.Int .. 3.2e21.Int) ),\n  'remove \"4001-Inf\"',      to-string( @seq .= &remove(\"4001-Inf\") );\n\n\nsub canonicalize (Str $ranges) { sort consolidate |sort parse-range $ranges }\n\nsub parse-range (Str $_) { .comb(/\\d+|'Inf'/).map: { +$^α .. +$^ω } }\n\nsub to-string (@ranges) { qq|\"{ @ranges».minmax».join('-').join(',') }\"| }\n\nmulti add (@ranges, Int   $i) { samewith @ranges, $i .. $i }\nmulti add (@ranges, Str   $s) { samewith @ranges, |parse-range($s) }\nmulti add (@ranges, Range $r) { @ranges > 0 ?? (sort consolidate |sort |@ranges, $r) !! $r }\n\nmulti remove (@ranges, Int   $i) { samewith @ranges, $i .. $i }\nmulti remove (@ranges, Str   $s) { samewith @ranges, |parse-range($s) }\nmulti remove (@ranges, Range $r) {\n    gather for |@ranges -> $this {\n        if $r.min <= $this.min {\n            if $r.max >= $this.min and $r.max < $this.max {\n                take $r.max + 1 .. $this.max\n            }\n            elsif $r.max < $this.min {\n                take $this\n            }\n        }\n        else {\n            if $r.max >= $this.max and $r.min <= $this.max {\n                take $this.min .. $r.min - 1\n            }\n            elsif $r.max < $this.max and $r.min > $this.min {\n                take $this.min .. $r.min - 1;\n                take $r.max + 1 .. $this.max\n            }\n            else {\n                take $this\n            }\n        }\n    }\n}\n\nmulti consolidate() { () }\n\nmulti consolidate($this is copy, **@those) {\n    sub infix:<∪> (Range $a, Range $b) { Range.new($a.min,max($a.max,$b.max)) }\n\n    sub infix:<∩> (Range $a, Range $b) { so $a.max >= $b.min }\n\n    my @ranges = sort gather {\n        for consolidate |@those -> $that {\n            next unless $that;\n            if $this ∩ $that { $this ∪= $that }\n            else             { take $that }\n        }\n        take $this;\n    }\n    for reverse ^(@ranges - 1) {\n        if @ranges[$_].max == @ranges[$_ + 1].min - 1 {\n            @ranges[$_] = @ranges[$_].min .. @ranges[$_ + 1].max;\n            @ranges[$_ + 1]:delete\n        }\n    }\n    @ranges\n}\n\n```\n\nOutput:\n\n```\n               Start -> \"\"\n              add 77 -> \"77-77\"\n              add 79 -> \"77-77,79-79\"\n              add 78 -> \"77-79\"\n           remove 77 -> \"78-79\"\n           remove 78 -> \"79-79\"\n           remove 79 -> \"\"\n\n               Start -> \"1-3,5-5\"\n               add 1 -> \"1-3,5-5\"\n            remove 4 -> \"1-3,5-5\"\n               add 7 -> \"1-3,5-5,7-7\"\n               add 8 -> \"1-3,5-5,7-8\"\n               add 6 -> \"1-3,5-8\"\n            remove 7 -> \"1-3,5-6,8-8\"\n\n               Start -> \"1-5,10-25,27-30\"\n              add 26 -> \"1-5,10-30\"\n               add 9 -> \"1-5,9-30\"\n               add 7 -> \"1-5,7-7,9-30\"\n           remove 26 -> \"1-5,7-7,9-25,27-30\"\n            remove 9 -> \"1-5,7-7,10-25,27-30\"\n            remove 7 -> \"1-5,10-25,27-30\"\n\n                         Start -> \"6-57,160-251,2700-7000000\"\n               add \"2502-2698\" -> \"6-57,160-251,2502-2698,2700-7000000\"\n                    add 41..69 -> \"6-69,160-251,2502-2698,2700-7000000\"\n                 remove 17..30 -> \"6-16,31-69,160-251,2502-2698,2700-7000000\"\n             remove 4391..6527 -> \"6-16,31-69,160-251,2502-2698,2700-4390,6528-7000000\"\n                      add 2699 -> \"6-16,31-69,160-251,2502-4390,6528-7000000\"\n                        add 76 -> \"6-16,31-69,76-76,160-251,2502-4390,6528-7000000\"\n                        add 78 -> \"6-16,31-69,76-76,78-78,160-251,2502-4390,6528-7000000\"\n               remove \"70-165\" -> \"6-16,31-69,166-251,2502-4390,6528-7000000\"\n                 remove 16..31 -> \"6-15,32-69,166-251,2502-4390,6528-7000000\"\n        add 1.417e16 .. 3.2e21 -> \"6-15,32-69,166-251,2502-4390,6528-7000000,14170000000000000-3200000000000000000000\"\n             remove \"4001-Inf\" -> \"6-15,32-69,166-251,2502-4000\"\n\n```"}]}
{"messages": [{"role": "user", "content": "The numerical rank of competitors in a competition shows if one is better than, equal to, or worse than another based on their results in a competition.\n\nThe numerical rank of a competitor can be assigned in several different ways.\n\nTask\n\nThe following scores are accrued for all competitors of a competition (in best-first order):\n\n```\n44 Solomon\n42 Jason\n42 Errol\n41 Garry\n41 Bernard\n41 Barry\n39 Stephen\n```\n\nFor each of the following ranking methods, create a function/method/procedure/subroutine... that applies the ranking method to an ordered list of scores with scorers:\n\n1. Standard. (Ties share what would have been their first ordinal number).\n2. Modified. (Ties share what would have been their last ordinal number).\n3. Dense. (Ties share the next available integer).\n4. Ordinal. ((Competitors take the next available integer. Ties are not treated otherwise).\n5. Fractional. (Ties share the mean of what would have been their ordinal numbers).\n\nSee the wikipedia article for a fuller description.\n\nShow here, on this page, the ranking of the test scores under each of the numbered ranking methods."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @scores =\n    Solomon => 44,\n    Jason   => 42,\n    Errol   => 42,\n    Garry   => 41,\n    Bernard => 41,\n    Barry   => 41,\n    Stephen => 39;\n\nsub tiers (@s) { @s.classify(*.value).pairs.sort.reverse.map: { .value».key } }\n\nsub standard (@s) {\n    my $rank = 1;\n    gather for tiers @s -> @players {\n\ttake $rank => @players;\n\t$rank += @players;\n    }\n}\n\nsub modified (@s) {\n    my $rank = 0;\n    gather for tiers @s -> @players {\n\t$rank += @players;\n\ttake $rank => @players;\n    }\n}\n\nsub dense (@s) { tiers(@s).map: { ++$_ => @^players } }\n\nsub ordinal (@s) { @s.map: ++$_ => *.key }\n\nsub fractional (@s) {\n    my $rank = 1;\n    gather for tiers @s -> @players {\n\tmy $beg = $rank;\n\tmy $end = $rank += @players;\n\ttake [+]($beg ..^ $end) / @players => @players;\n    }\n}\n\nsay   \"Standard:\";   .perl.say for   standard @scores;\nsay \"\\nModified:\";   .perl.say for   modified @scores;\nsay \"\\nDense:\";      .perl.say for      dense @scores;\nsay \"\\nOrdinal:\";    .perl.say for    ordinal @scores;\nsay \"\\nFractional:\"; .perl.say for fractional @scores;\n\n```\n\nOutput:\n\n```\nStandard:\n1 => [\"Solomon\"]\n2 => [\"Jason\", \"Errol\"]\n4 => [\"Garry\", \"Bernard\", \"Barry\"]\n7 => [\"Stephen\"]\n\nModified:\n1 => [\"Solomon\"]\n3 => [\"Jason\", \"Errol\"]\n6 => [\"Garry\", \"Bernard\", \"Barry\"]\n7 => [\"Stephen\"]\n\nDense:\n1 => [\"Solomon\"]\n2 => [\"Jason\", \"Errol\"]\n3 => [\"Garry\", \"Bernard\", \"Barry\"]\n4 => [\"Stephen\"]\n\nOrdinal:\n1 => \"Solomon\"\n2 => \"Jason\"\n3 => \"Errol\"\n4 => \"Garry\"\n5 => \"Bernard\"\n6 => \"Barry\"\n7 => \"Stephen\"\n\nFractional:\n1.0 => [\"Solomon\"]\n2.5 => [\"Jason\", \"Errol\"]\n5.0 => [\"Garry\", \"Bernard\", \"Barry\"]\n7.0 => [\"Stephen\"]\n```"}]}
{"messages": [{"role": "user", "content": "Definitions and restrictions\n\n**Rare**   numbers are positive integers    **n**    where:\n\n:   :   :   * **n**    is expressed in base ten\n            * **r**    is the reverse of    **n**      (decimal digits)\n            * **n**    must be non-palindromic   (**n** ≠ **r**)\n            * **(n+r)**    is the   **sum**\n            * **(n-r)**    is the   **difference**   and must be positive\n            * the   **sum**   and the   **difference**   must be perfect squares\n\nTask\n:   * find and show the first   **5**   *rare*   numbers\n    * find and show the first   **8**   *rare*   numbers       (*optional*)\n    * find and show more   *rare*   numbers                (*stretch goal*)\n\nShow all output here, on this page.\n\nReferences\n:   * an   OEIS   entry:   A035519          rare numbers.\n    * an   OEIS   entry:   A059755   odd rare numbers.\n    * planetmath entry:   rare numbers.     (some hints)\n    * author's  website:   rare numbers   by Shyam Sunder Gupta.     (lots of hints and some observations)."}, {"role": "assistant", "content": "### Translation of Rust\n\n**Translation of**: Rust\n\n```\n# 20220315 Raku programming solution\n\nsub rare (\\target where ( target > 0 and target ~~ Int )) {\n\n   my \\digit          = $ = 2;\n   my $count          = 0;\n   my @numeric_digits = 0..9 Z, 0 xx *;\n   my @diffs1         = 0,1,4,5,6;\n\n   # all possible digits pairs to calculate potential diffs\n   my @pairs     = 0..9 X 0..9; \n   my @all_diffs = -9..9;\n\n   # lookup table for the first diff\n   my @lookup_1 = [ [[2, 2], [8, 8]],    # Diff = 0\n                    [[8, 7], [6, 5]],    # Diff = 1\n                    [],\n                    [],\n                    [[4, 0],       ],    # Diff = 4\n                    [[8, 3],       ],    # Diff = 5\n                    [[6, 0], [8, 2]], ]; # Diff = 6\n\n   # lookup table for all the remaining diffs\n   given my %lookup_n { for @pairs -> \\pair { $_{ [-] pair.values }.push: pair } }\n\n   loop {\n      my @powers = 10 <<**<< (0..digit-1); #  powers like 1, 10, 100, 1000....\n \n      #  for n-r (aka L) the required terms, like 9/ 99 / 999 & 90 / 99999 & 9999 & 900 etc\n      my @terms = (@powers.reverse Z- @powers).grep: * > 0 ;\n\n      # create a cartesian product for all potential diff numbers\n      # for the first use the very short one, for all other the complete 19 element\n      my @diff_list = digit == 2 ?? @diffs1 !! [X] @diffs1, |(@all_diffs xx digit div 2 - 1);\n\n      my @diff_list_iter = gather for @diff_list -> \\k {\n         # remove invalid first diff/second diff combinations \n         { take k andthen next } if k.elems == 1 ;    \n         given (my (\\a,\\b) = k.values) {       \n            when a == 0 && b != 0                                    { next } \n            when a == 1 && b ∉ [ -7, -5, -3, -1,  1, 3, 5, 7       ] { next }\n            when a == 4 && b ∉ [ -8, -6, -4, -2,  0, 2, 4, 6, 8    ] { next }\n            when a == 5 && b ∉ [ -3,  7                            ] { next }\n            when a == 6 && b ∉ [ -9, -7, -5, -3, -1, 1, 3, 5, 7, 9 ] { next } \n            default { take k }        \n         }      \n      }\n\n      for @diff_list_iter -> \\diffs {\n         # calculate difference of original n and its reverse (aka L = n-r)\n         # which must be a perfect square\n         if (my \\L = [+] diffs <<*>> @terms) > 0 and { $_ == $_.Int }(L.sqrt) {\n            # potential candiate, at least L is a perfect square\n            # placeholder for the digits\n            my \\dig = @ = 0 xx digit;\n\n            # generate a cartesian product for each identified diff using the lookup tables\n            my @c_iter = digit == 2\n               ?? @lookup_1[diffs[0]].map: { [ $_ ] }\n               !! [X] @lookup_1[diffs[0]], |(1..(+diffs + (digit % 2 - 1))).map: -> \\k {\n                  k == diffs ?? @numeric_digits !! %lookup_n{diffs[k]} }\n\n            # check each H (n+r) by using digit combination\n            for @c_iter -> \\elt {\n               for elt.kv -> \\i, \\pair { dig[i,digit-1-i] = pair.values }\n               # for numbers with odd # digits restore the middle digit\n               # which has been overwritten at the end of the previous cycle\n               dig[(digit - 1) div 2] = elt[+elt - 1][0] if digit % 2 == 1 ;\n\n\t       my \\rev = ( my \\num = [~] dig ).flip;\n\n               if num > rev and { $_ == $_.Int }((num+rev).sqrt) {\n                  printf \"%d: %12d reverse %d\\n\", $count+1, num, rev;\n\t\t  exit if ++$count == target;\n               } \n            }\n         }\n      }\n      digit++\n   }\n}\n\nmy $N = 5;\nsay \"The first $N rare numbers are,\";\nrare $N;\n\n```\n\nOutput:\n\n```\nThe first 5 rare numbers are,\n1:           65 reverse 56\n2:       621770 reverse 77126\n3:    281089082 reverse 280980182\n4:   2022652202 reverse 2022562202\n5:   2042832002 reverse 2002382402\n```\n\n### Using NativeCall with Rust\n\nThis example will make use of a modified version of the 'advanced' routine from the Rust entry.\n\n```\n~> cargo new --lib Rare && cd $_\n     Created library `Rare` package\n\n```\n\nAdd to the stock manifest file, Cargo.toml, all required dependencies and build target,\n\n```\n~/Rare> tail -5 Cargo.toml\n[dependencies]\nitertools = \"0.10.3\"\n\n[lib]\ncrate-type = [\"cdylib\"]\n\n```\n\nNow replace the src/lib.rs file with the following,\n\nlib.rs\n\n```\nuse itertools::Itertools;\nuse std::collections::HashMap;\n\nfn isqrt(n: u64) -> u64 {\n    let mut s = (n as f64).sqrt() as u64;\n    s = (s + n / s) >> 1;\n    if s * s > n {\n        s - 1\n    } else {\n        s\n    }\n}\n\nfn is_square(n: u64) -> bool {\n    match n & 0xf {\n        0 | 1 | 4 | 9 => {\n            let t = isqrt(n);\n            t * t == n\n        }\n        _ => false,\n    }\n}\n\n#[no_mangle]\n/// This algorithm uses an advanced search strategy based on Nigel Galloway's approach\npub extern \"C\" fn advanced64(target: u8) -> *mut u64 {\n    // setup\n    let digit = 2u8;\n    let mut results = Vec::new();\n    let mut counter = 0_u8;\n\n    let numeric_digits = (0..=9).map(|x| [x, 0]).collect::<Vec<_>>();\n    let diffs1: Vec<i8> = vec![0, 1, 4, 5, 6];\n\n    // all possible digits pairs to calculate potential diffs\n    let pairs = (0_i8..=9)\n        .cartesian_product(0_i8..=9)\n        .map(|x| [x.0, x.1])\n        .collect::<Vec<_>>();\n    let all_diffs = (-9i8..=9).collect::<Vec<_>>();\n\n    // lookup table for the first diff\n    let lookup_1 = vec![\n        vec![[2, 2], [8, 8]], //Diff = 0\n        vec![[8, 7], [6, 5]], //Diff = 1\n        vec![],\n        vec![],\n        vec![[4, 0]],         // Diff = 4\n        vec![[8, 3]],         // Diff = 5\n        vec![[6, 0], [8, 2]], // Diff = 6\n    ];\n\n    // lookup table for all the remaining diffs\n    let lookup_n: HashMap<i8, Vec<_>> = pairs.into_iter().into_group_map_by(|elt| elt[0] - elt[1]);\n\n    let mut d = digit;\n\n    while target > counter {\n        // powers like 1, 10, 100, 1000....\n        let powers = (0..d).map(|x| 10_u64.pow(x.into())).collect::<Vec<u64>>();\n\n        // for n-r (aka L) the required terms, like 9/ 99 / 999 & 90 / 99999 & 9999 & 900 etc\n        let terms = powers\n            .iter()\n            .zip(powers.iter().rev())\n            .map(|(a, b)| b.checked_sub(*a).unwrap_or(0))\n            .filter(|x| *x != 0)\n            .collect::<Vec<u64>>();\n\n        // create a cartesian product for all potential diff numbers\n        // for the first use the very short one, for all other the complete 19 element\n        let diff_list_iter = (0_u8..(d / 2))\n            .map(|i| match i {\n                0 => diffs1.iter(),\n                _ => all_diffs.iter(),\n            })\n            .multi_cartesian_product()\n            // remove invalid first diff/second diff combinations - custom iterator would be probably better\n            .filter(|x| {\n                if x.len() == 1 {\n                    return true;\n                }\n                match (*x[0], *x[1]) {\n                    (a, b) if (a == 0 && b != 0) => false,\n                    (a, b) if (a == 1 && ![-7, -5, -3, -1, 1, 3, 5, 7].contains(&b)) => false,\n                    (a, b) if (a == 4 && ![-8, -6, -4, -2, 0, 2, 4, 6, 8].contains(&b)) => false,\n                    (a, b) if (a == 5 && ![7, -3].contains(&b)) => false,\n                    (a, b) if (a == 6 && ![-9, -7, -5, -3, -1, 1, 3, 5, 7, 9].contains(&b)) => {\n                        false\n                    }\n                    _ => true,\n                }\n            });\n\n        'OUTER: for diffs in diff_list_iter {\n            // calculate difference of original n and its reverse (aka L = n-r)\n            // which must be a perfect square\n            let l: i64 = diffs\n                .iter()\n                .zip(terms.iter())\n                .map(|(diff, term)| **diff as i64 * *term as i64)\n                .sum();\n\n            if l > 0 && is_square(l.try_into().unwrap()) {\n                // potential candiate, at least L is a perfect square\n\n                // placeholder for the digits\n                let mut dig: Vec<i8> = vec![0_i8; d.into()];\n\n                // generate a cartesian product for each identified diff using the lookup tables\n                let c_iter = (0..(diffs.len() + d as usize % 2))\n                    .map(|i| match i {\n                        0 => lookup_1[*diffs[0] as usize].iter(),\n                        _ if i != diffs.len() => lookup_n.get(diffs[i]).unwrap().iter(),\n                        _ => numeric_digits.iter(), // for the middle digits\n                    })\n                    .multi_cartesian_product();\n\n                // check each H (n+r) by using digit combination\n                c_iter.for_each(|elt| {\n                    for (i, digit_pair) in elt.iter().enumerate() {\n                        dig[i] = digit_pair[0];\n                        dig[d as usize - 1 - i] = digit_pair[1]\n                    }\n\n                    // for numbers with odd # digits restore the middle digit\n                    // which has been overwritten at the end of the previous cycle\n                    if d % 2 == 1 {\n                        dig[(d as usize - 1) / 2] = elt[elt.len() - 1][0];\n                    }\n\n                    let num = dig\n                        .iter()\n                        .rev()\n                        .enumerate()\n                        .fold(0_u64, |acc, (i, d)| acc + 10_u64.pow(i as u32) * *d as u64);\n\n                    let reverse = dig\n                        .iter()\n                        .enumerate()\n                        .fold(0_u64, |acc, (i, d)| acc + 10_u64.pow(i as u32) * *d as u64);\n\n                    if num > reverse && is_square(num + reverse) {\n                        counter += 1;\n                        results.push(num);\n                    }\n                });\n                if counter == target {\n                    break 'OUTER;\n                }\n            }\n        }\n        d += 1\n    }\n    let ptr = results.as_mut_ptr();\n    std::mem::forget(results); // circumvent the destructor\n\n    ptr\n}\n\n```\n\nThe needful shared library will be available after the build command,\n\n```\n~/Rare> cargo build\n~/Rare> file target/debug/libRare.so\ntarget/debug/libRare.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=4f904cce7f8e82130826bf46f93fe9fe944ab9d0, with debug_info, not stripped\n\n```\n\nHere is the main Raku program,\n\n```\nuse NativeCall;\n\nconstant LIB = '/home/hkdtam/Rare/target/debug/libRare.so';\n\nsub advanced64(uint8) returns Pointer[uint64] is native(LIB) {*}\n\nmy $N = 5;\nsay \"The first $N rare numbers are,\";\n\nfor (advanced64 $N)[^$N].kv -> \\nth,\\rare {\n   printf \"%d: %12d reverse %d\\n\", nth+1, { $_, $_.flip }(rare)\n}\n\n```\n\nOutput is the same."}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay bars of color,   moving up and down across the screen for horizontal raster bars,   or left and right across the screen for vertical raster bars,   making the raster bars move as stated by swaying side-to-side the respective way if possible.\n\nUse multiple colors in succession and carefully make a gradient between the colors   (if possible)   to achieve an effect of metallic-looking horizontal bars.\n\nHorizontal and/or vertical raster bars are acceptable."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\nAs there is no reference implementation, and rather sketchy task instructions, this may or may not fulfill the original task authors intent.\n\nNot really sure what is meant by \"swaying\", perhaps this will suffice.\n\nGenerate random colored bars and display them. (They ended up looking more plastic than metallic; ah well.)\n\n* Use Up / Down arrows to change the scroll speed.\n* Use Left / Right arrows to adjust the gap between the raster bars.\n* Use Pg Up / Pg Dn to adjust raster bar height.\n* Use Z / X to change the angle of the raster bars.\n* Use Space bar to pause / resume scrolling.\n* Use Left Ctrl to toggle the scroll direction.\n* Press R to toggle Randomize on / off.\n* If Randomize is active, adjust the randomize delay with < / >\n* Press S to toggle Swaying on / off.\n* If Swaying is active, adjust the period with D / F\n* Press Q to exit.\n\n```\nunit sub MAIN (\n    Int :b(:$bar-height) is copy = 60; #= Height of the individual \"Raster bars\", minimum 32 (pixels)\n    Int :d(:$dir) is copy        = -1; #= Scroll direction: -1 is \"up\" 1 is \"down\"\n    Int :s(:$step) is copy       = 4;  #= Scroll speed (pixels per step\n    Int :g(:$gap) is copy        = $bar-height + 50; #= Gap between bars (pixels)\n    Int :a(:$angle) is copy      = 0; #= Angle to orient bars off horizontal (-60 to 60 degrees)\n    Int :sw(:$sway) is copy      = 0; #= Swaying on / off\n    Real :r(:$rnd) is copy       = 0; #= Delay between randomize events\n);\n\nsay q:to/END/;\n\n    Use Up / Down arrows to change the scroll speed.\n    Use Left / Right arrows to adjust the gap between the raster bars.\n    Use Pg Up / Pg Dn to adjust raster bar height.\n    Use Z / X to change the angle of the raster bars.\n    Use Space bar to pause / resume scrolling.\n    Use Left Ctrl to toggle the scroll direction.\n    Press R to toggle Randomize on / off.\n    If Randomize is active, adjust the randomize delay with < / >\n    Press S to toggle Swaying on / off.\n    If Swaying is active, adjust the period with D / F\n    Press Q to exit.\n    END\n\nuse SDL2::Raw;\nuse Cairo;\n\nmy $width  = 800;\nmy $height = 800;\n\nSDL_Init(VIDEO);\n\nmy $window = SDL_CreateWindow(\n    'Raster Bars - Raku',\n    SDL_WINDOWPOS_CENTERED_MASK,\n    SDL_WINDOWPOS_CENTERED_MASK,\n    $width, $height, RESIZABLE\n);\n\nmy $render = SDL_CreateRenderer($window, -1, ACCELERATED +| PRESENTVSYNC);\n\nmy @bars = (^128).map: { gen-bar( rand xx 3 ) };\n\nmy $event = SDL_Event.new;\n\nenum KEY_CODES (\n    K_UP     => 82,\n    K_DOWN   => 81,\n    K_LEFT   => 80,\n    K_RIGHT  => 79,\n    K_SPACE  => 44,\n    K_PGUP   => 75,\n    K_PGDN   => 78,\n    K_LCTRL  => 224,\n    K_Z      => 29,\n    K_X      => 27,\n    K_Q      => 20,\n    K_R      => 21,\n    K_S      => 22,\n    K_D      => 7,\n    K_F      => 9,\n    K_LT     => 54,\n    K_GT     => 55,\n);\n\nmy $port  = +@bars * $gap;\nmy $y     = $dir > 0 ?? $height - $port !! $height ;\nmy $now   = now;\nmy $period = 2;\n\nmain: loop {\n    handle-event($event) while SDL_PollEvent($event);\n\n    randomize if $rnd and now - $now > $rnd;\n\n    if $dir > 0 {\n        $y = $height - $port if $y > 0 - ceiling $height / cos(π * $angle / 180).abs\n    } else {\n        $y = 0 - ceiling $height / cos(π * $angle / 180).abs if $y < $height - $port\n    }\n\n    $y = $step * $dir + $y;\n\n    $angle = (((now * $period) % τ).sin * 35).Int if $sway;\n\n    for ^@bars {\n        my $offset = $sway ?? $gap !! ceiling $gap / cos(π * $angle / 180).abs;\n        SDL_RenderCopyEx( $render, @bars[$_], Nil,\n          SDL_Rect.new( -($width*4), $y + $offset * $_, $width * 10, $bar-height),\n          $angle.Num, SDL_Point.new(:x((4.5*$width).Int),:y($y + $offset * $_)), 0\n\n        )\n    }\n\n    SDL_RenderPresent($render);\n\n    SDL_RenderClear($render);\n\n    print fps;\n}\n\nput '';\n\nSDL_Quit();\n\nsub gen-bar (@color) {\n    my $bar = Cairo::Image.create( Cairo::FORMAT_ARGB32, 1, 128 );\n    given Cairo::Context.new($bar) {\n        my Cairo::Pattern::Gradient::Linear $lpat .= create(0.0, 0.0,  0.0, 128.0);\n        $lpat.add_color_stop_rgba(  1, |(@color »*» .3), 1);\n        $lpat.add_color_stop_rgba( .2, |(@color),        1);\n        $lpat.add_color_stop_rgba(.75, |(@color),        1);\n        $lpat.add_color_stop_rgba(  0, |(@color »+» .5), 1);\n        .rectangle(0, 0, 1, 128);\n        .pattern($lpat);\n        .fill;\n        $lpat.destroy;\n    }\n\n    my $bar_texture = SDL_CreateTexture(\n        $render, %PIXELFORMAT<ARGB8888>,\n        STATIC, 1, 128\n    );\n\n    SDL_UpdateTexture(\n        $bar_texture,\n        SDL_Rect.new(:x(0), :y(0), :w(1), :h(128)),\n        $bar.data, $bar.stride // 1\n    );\n\n    $bar_texture\n}\n\nsub handle-event ($event) {\n    my $casted_event = SDL_CastEvent($event);\n    given $casted_event {\n        when *.type == QUIT    { last main }\n        when *.type == KEYDOWN {\n            if KEY_CODES(.scancode) -> $comm {\n                given $comm {\n                    when 'K_UP'     { $step += 1 }\n                    when 'K_DOWN'   { $step -= 1 if $step > 1 }\n                    when 'K_LEFT'   { $gap = $gap < 32 ?? $gap !! $gap - 1; $port = +@bars * $gap; }\n                    when 'K_RIGHT'  { $gap++; $port += +@bars; }\n                    when 'K_PGUP'   { $bar-height += 2 }\n                    when 'K_PGDN'   { $bar-height = $bar-height >= 34 ?? $bar-height - 2 !! $bar-height }\n                    when 'K_SPACE'  { $step = $step ?? 0 !! 1 }\n                    when 'K_LCTRL'  { $dir  *= -1 }\n                    when 'K_Z'      { $angle = $angle > -45 ?? $angle - 5 !! $angle }\n                    when 'K_X'      { $angle = $angle <  45 ?? $angle + 5 !! $angle }\n                    when 'K_R'      { $rnd = $rnd ?? 0 !! 1 }\n                    when 'K_S'      { $sway xor= 1 }\n                    when 'K_F'      { $period += .1 }\n                    when 'K_D'      { $period = $period - .1 max .1;  }\n                    when 'K_GT'     { $rnd += .2 }\n                    when 'K_LT'     { $rnd = $rnd > .2 ?? $rnd -.2 !! .2 }\n                    when 'K_Q'      { last main }\n                }\n            } #else { say .scancode, \"\\n\" }\n        }\n        when *.type == WINDOWEVENT {\n            if .event == RESIZED {\n                $width  = .data1;\n                $height = .data2 + $bar-height;\n            }\n        }\n    }\n}\n\nsub randomize {\n    $dir   = (-1,1).pick;\n    $step  = (4..8).pick;\n    $bar-height   = (32..200).pick;\n    $gap   = $bar-height + (1..100).pick;\n    $angle = (-45, *+5 ... 45).pick;\n\n    $port = +@bars * $gap;\n\n    if $dir > 0 {\n        $y = $height - $port;\n    } else {\n        $y = 0 - ceiling ($height max $width) / cos(π * $angle / 180).abs;\n    }\n    $now = now;\n}\n\nsub fps {\n    state $fps-frames = 0;\n    state $fps-now    = now;\n    state $fps        = '';\n    $fps-frames++;\n    if now - $fps-now >= 1 {\n        $fps = [~] \"\\b\" x 40, ' ' x 20, \"\\b\" x 20 ,\n            sprintf \"FPS: %5.2f  \", ($fps-frames / (now - $fps-now)).round(.01);\n        $fps-frames = 0;\n        $fps-now = now;\n    }\n    $fps\n}\n\n```\n\nScreenshot still of typical run: (offsite .png image)\n\n(Small) Moving gif of swaying bars: (offsite .gif image)"}]}
{"messages": [{"role": "user", "content": "Counting the frequency at which something occurs is a common activity in measuring performance and managing resources. In this task, we assume that there is some job which we want to perform repeatedly, and we want to know how quickly these jobs are being performed.\n\nOf interest is the code that performs the actual measurements. Any other code (such as job implementation or dispatching) that is required to demonstrate the rate tracking is helpful, but not the focus.\n\nMultiple approaches are allowed (even preferable), so long as they can accomplish these goals:\n\n* Run N seconds worth of jobs and/or Y jobs.\n* Report at least three distinct times.\n\nBe aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can.\n\n**See also:** System time, Time a function"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub runrate($N where $N > 0, &todo) {\n    my $n = $N;\n\n    my $start = now;\n    todo() while --$n;\n    my $end = now;\n\n    say \"Start time: \", DateTime.new($start).Str;\n    say \"End time: \", DateTime.new($end).Str;\n    my $elapsed = $end - $start;\n\n    say \"Elapsed time: $elapsed seconds\";\n    say \"Rate: { ($N / $elapsed).fmt('%.2f') } per second\\n\";\n}\n\nsub factorial($n) { (state @)[$n] //= $n < 2 ?? 1 !! $n * factorial($n-1) }\n\nrunrate 100_000, { state $n = 1; factorial($n++) }\n\nrunrate 100_000, { state $n = 1; factorial($n++) }\n\n```\n\nOutput:\n\n```\nStart time: 2023-04-19T08:23:50.276418Z\nEnd time: 2023-04-19T08:23:54.716864Z\nElapsed time: 4.440445313 seconds\nRate: 22520.26 per second\n\nStart time: 2023-04-19T08:23:54.726913Z\nEnd time: 2023-04-19T08:23:54.798238Z\nElapsed time: 0.071324057 seconds\nRate: 1402051.48 per second\n\n```\n\nThe Instant type in Perl 6 is defined to be based on TAI seconds, and represented with rational numbers that are more than sufficiently accurate to represent your clock's accuracy. The actual accuracy will depend on your clock's accuracy (even if you don't have an atomic clock in your kitchen, your smartphone can track various orbiting atomic clocks, right?) modulo the vagaries of returning the atomic time (or unreasonable facsimile) via system calls and library APIs."}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Point\\_in\\_polygon. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nGiven a point and a polygon, check if the point is inside or outside the polygon using the ray-casting algorithm.\n\nA pseudocode can be simply:\n\n```\n count ← 0\n foreach side in polygon:\n   if ray_intersects_segment(P,side) then\n     count ← count + 1\n if is_odd(count) then\n   return inside\n else\n   return outside\n\n```\n\nWhere the function ray\\_intersects\\_segment return true if the horizontal ray starting from the point P intersects the side (segment), false otherwise.\n\nAn intuitive explanation of why it works is that every time we cross\na border, we change \"country\" (inside-outside, or outside-inside), but\nthe last \"country\" we land on is surely *outside* (since the inside of the polygon is finite, while the ray continues towards infinity). So, if we crossed an odd number of borders we were surely inside, otherwise we were outside; we can follow the ray backward to see it better: starting from outside, only an odd number of crossing can give an *inside*: outside-inside, outside-inside-outside-inside, and so on (the - represents the crossing of a border).\n\nSo the main part of the algorithm is how we determine if a ray intersects a segment. The following text explain one of the possible ways.\n\nLooking at the image on the right, we can easily be convinced of the fact that rays starting from points in the hatched area (like P1 and P2) surely do not intersect the segment AB. We also can easily see that rays starting from points in the greenish area surely intersect the segment AB (like point P3).\n\nSo the problematic points are those inside the white area (the box delimited by the points A and B), like P4.\n\nLet us take into account a segment AB (the point A having y coordinate always smaller than B's y coordinate, i.e. point A is always below point B) and a point P. Let us use the cumbersome notation PAX to denote the angle between segment AP and AX, where X is always a point on the horizontal line passing by A with x coordinate bigger than the maximum between the x coordinate of A and the x coordinate of B. As explained graphically by the figures on the right, if PAX is greater than the angle BAX, then the ray starting from P intersects the segment AB. (In the images, the ray starting from PA does not intersect the segment, while the ray starting from PB in the second picture, intersects the segment).\n\nPoints on the boundary or \"on\" a vertex are someway special and through this approach we do not obtain *coherent* results. They could be treated apart, but it is not necessary to do so.\n\nAn algorithm for the previous speech could be (if P is a point, Px is its x coordinate):\n\n```\n ray_intersects_segment:\n    P : the point from which the ray starts\n    A : the end-point of the segment with the smallest y coordinate\n        (A must be \"below\" B)\n    B : the end-point of the segment with the greatest y coordinate\n        (B must be \"above\" A)\n if Py = Ay or Py = By then\n   Py ← Py + ε\n end if\n if Py < Ay or Py > By then \n   return false\n else if Px >= max(Ax, Bx) then \n   return false\n else\n   if Px < min(Ax, Bx) then\n     return true\n   else\n     if Ax ≠ Bx then\n       m_red ← (By - Ay)/(Bx - Ax)\n     else\n       m_red ← ∞\n     end if\n     if Ax ≠ Px then\n       m_blue ← (Py - Ay)/(Px - Ax)\n     else\n       m_blue ← ∞\n     end if\n     if m_blue ≥ m_red then\n       return true\n     else\n       return false\n     end if\n   end if\n end if\n\n```\n\n(To avoid the \"ray on vertex\" problem, the point is moved upward of a small quantity   ε.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nconstant ε = 0.0001;\n \nsub ray-hits-seg([\\Px,\\Py], [[\\Ax,\\Ay], [\\Bx,\\By]] --> Bool) {\n    Py += ε if Py == Ay | By;\n \n    if Py < Ay or Py > By or Px > (Ax max Bx) {\n\tFalse;\n    }\n    elsif Px < (Ax min Bx) {\n\tTrue;\n    }\n    else {\n\tmy \\red  = Ax == Bx ?? Inf !! (By - Ay) / (Bx - Ax);\n\tmy \\blue = Ax == Px ?? Inf !! (Py - Ay) / (Px - Ax);\n\tblue >= red;\n    }\n}\n\nsub point-in-poly(@point, @polygon --> Bool) {\n    so 2 R% [+] gather for @polygon -> @side {\n\ttake ray-hits-seg @point, @side.sort(*.[1]);\n    }\n}\n \nmy %poly =\n    squared => \n\t [[[ 0.0,  0.0], [10.0,  0.0]],\n\t  [[10.0,  0.0], [10.0, 10.0]],\n\t  [[10.0, 10.0], [ 0.0, 10.0]],\n\t  [[ 0.0, 10.0], [ 0.0,  0.0]]],\n    squaredhole =>\n\t [[[ 0.0,  0.0], [10.0,  0.0]],\n\t  [[10.0,  0.0], [10.0, 10.0]],\n\t  [[10.0, 10.0], [ 0.0, 10.0]],\n\t  [[ 0.0, 10.0], [ 0.0,  0.0]],\n\t  [[ 2.5,  2.5], [ 7.5,  2.5]],\n\t  [[ 7.5,  2.5], [ 7.5,  7.5]],\n\t  [[ 7.5,  7.5], [ 2.5,  7.5]],\n\t  [[ 2.5,  7.5], [ 2.5,  2.5]]],\n    strange =>\n\t [[[ 0.0,  0.0], [ 2.5,  2.5]],\n\t  [[ 2.5,  2.5], [ 0.0, 10.0]],\n\t  [[ 0.0, 10.0], [ 2.5,  7.5]],\n\t  [[ 2.5,  7.5], [ 7.5,  7.5]],\n\t  [[ 7.5,  7.5], [10.0, 10.0]],\n\t  [[10.0, 10.0], [10.0,  0.0]],\n\t  [[10.0,  0.0], [ 2.5,  2.5]],\n\t  [[ 2.5,  2.5], [ 0.0,  0.0]]],  # conjecturally close polygon\n    exagon =>\n\t [[[ 3.0,  0.0], [ 7.0,  0.0]],\n\t  [[ 7.0,  0.0], [10.0,  5.0]],\n\t  [[10.0,  5.0], [ 7.0, 10.0]],\n\t  [[ 7.0, 10.0], [ 3.0, 10.0]],\n\t  [[ 3.0, 10.0], [ 0.0,  5.0]],\n\t  [[ 0.0,  5.0], [ 3.0,  0.0]]];\n \nmy @test-points =\n\t  [  5.0,  5.0],\n\t  [  5.0,  8.0],\n\t  [-10.0,  5.0],\n\t  [  0.0,  5.0],\n\t  [ 10.0,  5.0],\n\t  [  8.0,  5.0],\n\t  [ 10.0, 10.0];\n \nfor <squared squaredhole strange exagon> -> $polywanna {\n    say \"$polywanna\";\n    my @poly = %poly{$polywanna}[];\n    for @test-points -> @point {\n\tsay \"\\t(@point.fmt('%.1f',','))\\t{ point-in-poly(@point, @poly) ?? 'IN' !! 'OUT' }\";\n    }\n}\n\n```\n\nOutput:\n\n```\nsquared\n\t(5.0,5.0)\tIN\n\t(5.0,8.0)\tIN\n\t(-10.0,5.0)\tOUT\n\t(0.0,5.0)\tOUT\n\t(10.0,5.0)\tIN\n\t(8.0,5.0)\tIN\n\t(10.0,10.0)\tOUT\nsquaredhole\n\t(5.0,5.0)\tOUT\n\t(5.0,8.0)\tIN\n\t(-10.0,5.0)\tOUT\n\t(0.0,5.0)\tOUT\n\t(10.0,5.0)\tIN\n\t(8.0,5.0)\tIN\n\t(10.0,10.0)\tOUT\nstrange\n\t(5.0,5.0)\tIN\n\t(5.0,8.0)\tOUT\n\t(-10.0,5.0)\tOUT\n\t(0.0,5.0)\tOUT\n\t(10.0,5.0)\tIN\n\t(8.0,5.0)\tIN\n\t(10.0,10.0)\tOUT\nexagon\n\t(5.0,5.0)\tIN\n\t(5.0,8.0)\tIN\n\t(-10.0,5.0)\tOUT\n\t(0.0,5.0)\tOUT\n\t(10.0,5.0)\tIN\n\t(8.0,5.0)\tIN\n\t(10.0,10.0)\tOUT\n```"}]}
{"messages": [{"role": "user", "content": "The task is to read a configuration file in standard configuration file format,\nand set variables accordingly.\n\nFor this task, we have a configuration file as follows:\n\n```\n# This is a configuration file in standard configuration file format\n#\n# Lines beginning with a hash or a semicolon are ignored by the application\n# program. Blank lines are also ignored by the application program.\n\n# This is the fullname parameter\nFULLNAME Foo Barber\n\n# This is a favourite fruit\nFAVOURITEFRUIT banana\n\n# This is a boolean that should be set\nNEEDSPEELING\n\n# This boolean is commented out\n; SEEDSREMOVED\n\n# Configuration option names are not case sensitive, but configuration parameter\n# data is case sensitive and may be preserved by the application program.\n\n# An optional equals sign can be used to separate configuration parameter data\n# from the option name. This is dropped by the parser. \n\n# A configuration option may take multiple parameters separated by commas.\n# Leading and trailing whitespace around parameter names and parameter data fields\n# are ignored by the application program.\n\nOTHERFAMILY Rhu Barber, Harry Barber\n\n```\n\nFor the task we need to set four variables according to the configuration entries as follows:\n\n* fullname = Foo Barber\n* favouritefruit = banana\n* needspeeling = true\n* seedsremoved = false\n\nWe also have an option that contains multiple parameters. These may be stored in an array.\n\n* otherfamily(1) = Rhu Barber\n* otherfamily(2) = Harry Barber\n\nRelated tasks\n\n* Update a configuration file"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\nThis demonstrates several interesting features of Raku, including full grammar support, derived grammars, alternation split across derivations, and longest-token matching that works across derivations. It also shows off Raku's greatly cleaned up regex syntax.\n\n```\nmy $fullname;\nmy $favouritefruit;\nmy $needspeeling = False;\nmy $seedsremoved = False;\nmy @otherfamily;\n\ngrammar ConfFile {\n    token TOP {\n\t:my $*linenum = 0;\n\t^ <fullline>* [$ || (\\N*) { die \"Parse failed at $0\" } ]\n    }\n\n    token fullline {\n\t<?before .>\n\t{ ++$*linenum }\n\t<line>\n\t[ \\n || { die \"Parse failed at line $*linenum\" } ]\n    }\n\n    proto token line() {*}\n\n    token line:misc  { {} (\\S+) { die \"Unrecognized word: $0\" } }\n\n    token line:sym<comment> { ^^ [ ';' | '#' ] \\N* }\n    token line:sym<blank>   { ^^ \\h* $$ }\n\n    token line:sym<fullname>       {:i fullname»       <rest> { $fullname = $<rest>.trim } }\n    token line:sym<favouritefruit> {:i favouritefruit» <rest> { $favouritefruit = $<rest>.trim } }\n    token line:sym<needspeeling>   {:i needspeeling»    <yes> { $needspeeling = defined $<yes> } }\n    token rest { \\h* '='? (\\N*) }\n    token yes { :i \\h* '='? \\h*\n    \t[\n\t    || ([yes|true|1])\n\t    || [no|false|0] \n\t    || (<?>)\n\t] \\h*\n    }\n}\n\ngrammar MyConfFile is ConfFile {\n    token line:sym<otherfamily>    {:i otherfamily»    <rest> { @otherfamily = $<rest>.split(',')».trim } }\n}\n\nMyConfFile.parsefile('file.cfg');\n\nsay \"fullname: $fullname\";\nsay \"favouritefruit: $favouritefruit\";\nsay \"needspeeling: $needspeeling\";\nsay \"seedsremoved: $seedsremoved\";\nprint \"otherfamily: \"; say @otherfamily.raku;\n\n```\n\nOutput:\n\n```\nfullname: Foo Barber\nfavouritefruit: banana\nneedspeeling: True\nseedsremoved: False\notherfamily: [\"Rhu Barber\", \"Harry Barber\"]\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nRead a file one character at a time, as opposed to reading the entire file at once.\n\nThe solution may be implemented as a procedure, which returns the next character in the file on each consecutive call (returning EOF when the end of the file is reached).\n\nThe procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read.\n\nRelated task\n\n* Read a file line by line"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku has a built in method .getc to get a single character from an open file handle. File handles default to UTF-8, so they will handle multi-byte characters correctly.\n\nTo read a single character at a time from the Standard Input terminal; $\\*IN in Raku:\n\n```\n.say while defined $_ = $*IN.getc;\n\n```\n\nOr, from a file:\n\n```\nmy $filename = 'whatever';\n\nmy $in = open( $filename, :r ) orelse .die;\n\nprint $_ while defined $_ = $in.getc;\n\n```"}]}
{"messages": [{"role": "user", "content": "Read a file one line at a time,\nas opposed to reading the entire file at once.\n\nRelated tasks\n\n* Read a file character by character\n* Input loop."}, {"role": "assistant", "content": "(formerly Perl 6)\nThe lines method is lazy so the following code does indeed read the file line by line, and not all at once.\n\n```\nfor open('test.txt').lines\n{\n  .say\n}\n```\n\nIn order to be more explicit about the file being read on line at a time, one can write:\n\n```\nmy $f = open 'test.txt';\nwhile my $line = $f.get {\n    say $line;\n}\n```"}]}
{"messages": [{"role": "user", "content": "Some languages have special semantics for obtaining a known line number from a file.\n\nTask\n\nDemonstrate how to obtain the contents of a specific line within a file.\n\nFor the purpose of this task demonstrate how the contents of the seventh line of a file can be obtained,   and store it in a variable or in memory   (for potential future use within the program if the code were to become embedded).\n\nIf the file does not contain seven lines,   or the seventh line is empty,   or too big to be retrieved,   output an appropriate message.\n\nIf no special semantics are available for obtaining the required line,   it is permissible to read line by line.\n\nNote that empty lines are considered and should still be counted.\n\nAlso note that for functional languages or languages without variables or storage,   it is permissible to output the extracted data to standard output."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsay lines[6] // die \"Short file\";\n\n```\n\nWithout an argument, the lines function reads filenames from the command line, or defaults to standard input. It then returns a lazy list, which we subscript to get the 7th element. Assuming this code is in a program called line7:\n\n```\n$ cal 2011 > cal.txt\n$ line7 cal.txt\n16 17 18 19 20 21 22  20 21 22 23 24 25 26  20 21 22 23 24 25 26  \n$\n```\n\nThis works even on infinite files because lists are lazy:\n\n```\n$ yes | line7\ny\n$\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nLoad the entire contents of some text file as a single string variable.\n\nIf applicable, discuss: encoding selection, the possibility of memory-mapping.\n\nOf course, in practice one should avoid reading an entire file at once\nif the file is large and the task can be accomplished incrementally instead\n(in which case check File IO);\nthis is for those cases where having the entire file is actually what is wanted."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2010.07\n\n```\nmy $string = slurp 'sample.txt';\n```\n\nThe default encoding is UTF-8. The :enc adverb can be used to specify a different one:\n\n```\nmy $string = slurp 'sample.txt', :enc<UTF-16>;\n```\n\nIO::Path objects also provide slurp as a method:\n\n```\nmy $string = 'sample.txt'.IO.slurp;\n```"}]}
{"messages": [{"role": "user", "content": "A readline interface is a line editing facility that provides auto completion facilities and the ability to recall previously typed lines. Build a simple application that accepts at least two commands and uses a readline style interface.\n\nThe interface should provide\n\n* the ability to recall previously typed commands\n* commandline editing\n* application specific commands\n\nThe application could be based on Simple database or something else.\n\nIf the language already provides a readline interface, then it should be demonstrated how build an application specific readline interface (one that only understands the applications commands) and also show how to customize the builtin readline to provide the above features and especially add application specific commands.\n\nSee also: Input loop"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku has a built in REPL that can be initiated by running the Raku executable without any parameters. It is fairly basic on its own but here are bindings available in the Raku ecosystem for GNU Readline and/or Linenoise either of which will automatically provide command history, tab completion and more advance command line editing capability if installed. They are not included in the Raku distribution directly. There are incompatible licensing requirements and providing hooks for third party tools allows for more customization options.\n\nLinenoise is generally the preferred option unless you really want the emacs compatible command line editing key bindings. Readline is arguably more powerful but is somewhat fiddly to set up.\n\nIf you are not inclined to install Readline *or* Linenoise, the REPL also works fairly well with 3rd party tools like rlwrap."}]}
{"messages": [{"role": "user", "content": "Task\n\nShow how to use the following math constants and functions in your language   (if not available, note it):\n\n:   * *e*   (base of the natural logarithm)\n    * π\n      {\\displaystyle {\\displaystyle \\pi }}\n    * square root\n    * logarithm   (any base allowed)\n    * exponential   (*e**x* )\n    * absolute value   (a.k.a. \"magnitude\")\n    * floor   (largest integer less than or equal to this number--not the same as truncate or int)\n    * ceiling   (smallest integer not less than this number--not the same as round up)\n    * power   (*x**y* )\n\nRelated task\n\n* Trigonometric Functions"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsay e;            # e\nsay π; # or pi    # pi\nsay τ; # or tau   # tau\n\n# Common mathmatical function are availble\n# as subroutines and as numeric methods.\n# It is a matter of personal taste and\n# programming style as to which is used.\nsay sqrt 2;       # Square root\nsay 2.sqrt;       # Square root\n\n# If you omit a base, does natural logarithm\nsay log 2;        # Natural logarithm\nsay 2.log;        # Natural logarithm\n\n# Specify a base if other than e\nsay log 4, 10;    # Base 10 logarithm\nsay 4.log(10);    # Base 10 logarithm\nsay 4.log10;      # Convenience, base 10 only logarithm\n\nsay exp 7;        # Exponentiation base e\nsay 7.exp;        # Exponentiation base e\n\n# Specify a base if other than e\nsay exp 7, 4;     # Exponentiation\nsay 7.exp(4);     # Exponentiation\nsay 4 ** 7;       # Exponentiation\n\nsay abs -2;       # Absolute value\nsay (-2).abs;     # Absolute value\n\nsay floor -3.5;   # Floor\nsay (-3.5).floor; # Floor\n\nsay ceiling pi;   # Ceiling\nsay pi.ceiling;   # Ceiling\n\nsay e ** π\\i + 1 ≅ 0; # :-)\n\n```"}]}
{"messages": [{"role": "user", "content": "The **Recamán's sequence** generates Natural numbers.\n\nStarting from a(0)=0, the n'th term `a(n)`, where n>0, is the previous term minus `n` i.e `a(n) = a(n-1) - n` but only if this is **both** positive *and* has not been previously generated.\n\nIf the conditions *don't* hold then `a(n) = a(n-1) + n`.\n\nTask\n\n1. Generate and show here the first 15 members of the sequence.\n2. Find and show here, the first duplicated number in the sequence.\n3. **Optionally**: Find and show here, how many terms of the sequence are needed until all the integers 0..1000, inclusive, are generated.\n\nReferences\n\n* A005132, The On-Line Encyclopedia of Integer Sequences.\n* The Slightly Spooky Recamán Sequence, Numberphile video.\n* Recamán's sequence, on Wikipedia."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.06\n\n```\nmy @recamans = 0, {\n   state %seen;\n   state $term;\n   $term++;\n   my $this = $^previous - $term;\n   $this = $previous + $term unless ($this > 0) && !%seen{$this};\n   %seen{$this} = True;\n   $this\n} … *;\n\nput \"First fifteen terms of Recaman's sequence: \", @recamans[^15];\n\nsay \"First duplicate at term: a[{ @recamans.first({@recamans[^$_].Bag.values.max == 2})-1 }]\";\n\nmy @seen;\nmy int $i = 0;\nloop {\n    next if (my int $this = @recamans[$i++]) > 1000 or @seen[$this];\n    @seen[$this] = 1;\n    say \"Range 0..1000 covered by terms up to a[{$i - 1}]\" and last if ++$ == 1001;\n}\n\n```\n\nOutput:\n\n```\nFirst fifteen terms of Recaman's sequence: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9\nFirst duplicate at term: a[24]\nRange 0..1000 covered by terms up to a[328002]\n```"}]}
{"messages": [{"role": "user", "content": "Record a monophonic 16-bit PCM sound into either memory space, a file or array.\n\n(This task neglects to specify the sample rate, and whether to use signed samples.\nThe programs in this page might use signed 16-bit or unsigned 16-bit samples, at 8000 Hz, 44100 Hz, or any other sample rate.\nTherefore, these programs might not record sound in the same format.)"}, {"role": "assistant", "content": "(formerly Perl 6)\nSlightly modified from an example provided with the `Audio::PortAudio` module distribution.\n\n```\nuse Audio::PortAudio;\nuse Audio::Sndfile;\n\nsub MAIN(Str $filename, Str :$source, Int :$buffer = 256) {\n    my $pa = Audio::PortAudio.new;\n    my $format = Audio::Sndfile::Info::Format::WAV +| Audio::Sndfile::Info::Subformat::PCM_16;\n    my $out-file = Audio::Sndfile.new(:$filename, channels => 1, samplerate => 44100, :$format, :w);\n    my $st;\n    \n    if $source.defined {\n        my $index = 0;\n        for $pa.devices -> $device {\n            if $device.name eq $source {\n                else {\n                    my $la = $device.default-high-input-latency;\n                    my $si = Audio::PortAudio::StreamParameters.new(device => $index,\n                                                                    channel-count => 1,\n                                                                    sample-format => Audio::PortAudio::StreamFormat::Float32,\n                                                                    suggested-latency => ($la || 0.05e0 ));\n                    $st = $pa.open-stream($si, Audio::PortAudio::StreamParameters, 44100, $buffer );\n                    last;\n                }\n\n            }\n            $index++;\n        }\n        die \"Couldn't find a device for '$source'\" if !$st.defined;\n    }\n    else {\n        $st = $pa.open-default-stream(2,0, Audio::PortAudio::StreamFormat::Float32, 44100, $buffer);\n    }\n    $st.start;\n    my $p = Promise.new;\n    signal(SIGINT).act({\n        say \"stopping recording\";\n        $p.keep: \"stopped\";\n        $out-file.close;\n        $st.close;\n        exit;\n    });\n    my Channel $write-channel = Channel.new;\n    my $write-promise = start {\n        react {\n            whenever $write-channel -> $item {\n                if $p.status ~~ Planned {\n                    $out-file.write-float($item[0], $item[1]);\n                    $out-file.sync;\n                }\n                else {\n                    done;\n                }\n            }\n        }\n    };\n\n    loop {\n        if $p.status ~~ Planned {\n            my $f = $buffer || $st.read-available;\n            if $f > 0 {\n                my $buff = $st.read($f,2, num32);\n                $write-channel.send([$buff, $f]);\n            }\n        }\n        else {\n            last;\n        }\n    }\n\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Write a recursive descent parser generator that takes a description of a grammar as input and outputs the source code for a parser in the same language as the generator. (So a generator written in C++ would output C++ source code for the parser.) You can assume that all of the rules have been preprocessed into a form suitable for the construction of a recursive descent parser. Check the following links for more details.\n\n* http://www.cs.engr.uky.edu/~lewis/essays/compilers/rec-des.html (broken)\n* http://www.engr.mun.ca/~theo/Misc/exp\\_parsing.htm\n\nUse the parser generator and a grammar file to build a parser that takes an arithmetic expression and turns it in to three address code. The resulting parser should take this (or something similar) as input:\n\n```\n(one + two) * three - four * five\n\n```\n\nAnd generate this (or something similar) as output:\n\n```\n_0001 = one + two\n_0002 = _0001 * three\n_0003 = four * five\n_0004 = _0002 - _0003\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\nInstead of writing a full-blown generator, it is possible to solve the task partly by making use of the built-in optimizer and study the relevant AST output\n\n```\nraku --target=optimize -e 'no strict; say ($one + $two) * $three - $four * $five' | tail -11\n                  - QAST::Op(callstatic &say) <sunk> :statement_id<2> say ($one + $two) * $three - $four * $five\n                    - QAST::Op(callstatic &infix:<->) <wanted> -\n                      - QAST::Op(callstatic &infix:<*>) <wanted> *\n                        - QAST::Op(callstatic &infix:<+>) <wanted> :statement_id<3> +\n                          - QAST::Var(local __lowered_lex_5) <wanted> $one\n                          - QAST::Var(local __lowered_lex_4) <wanted> $two\n                        - QAST::Var(local __lowered_lex_3) <wanted> $three\n                      - QAST::Op(callstatic &infix:<*>) <wanted> *\n                        - QAST::Var(local __lowered_lex_2) <wanted> $four\n                        - QAST::Var(local __lowered_lex_1) <wanted> $five\n            - QAST::WVal(Nil)\n\n```\n\nAs you can see by examining the nested tree, the calculations are done as follows (expressed using a postfix notation)\n\n```\none two + three * four five * -\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Rref#Pseudocode. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nShow how to compute the **reduced row echelon form**\n(a.k.a. **row canonical form**) of a matrix.\n\nThe matrix can be stored in any datatype that is convenient\n(for most languages, this will probably be a two-dimensional array).\n\nBuilt-in functions or this pseudocode (from Wikipedia) may be used:\n\n```\nfunction ToReducedRowEchelonForm(Matrix M) is\n    lead := 0\n    rowCount := the number of rows in M\n    columnCount := the number of columns in M\n    for 0 ≤ r < rowCount do\n        if columnCount ≤ lead then\n            stop\n        end if\n        i = r\n        while M[i, lead] = 0 do\n            i = i + 1\n            if rowCount = i then\n                i = r\n                lead = lead + 1\n                if columnCount = lead then\n                    stop\n                end if\n            end if\n        end while\n        Swap rows i and r\n        If M[r, lead] is not 0 divide row r by M[r, lead]\n        for 0 ≤ i < rowCount do\n            if i ≠ r do\n                Subtract M[i, lead] multiplied by row r from row i\n            end if\n        end for\n        lead = lead + 1\n    end for\nend function\n\n```\n\nFor testing purposes, the RREF of this matrix:\n\n```\n 1    2   -1   -4\n 2    3   -1   -11\n-2    0   -3    22\n\n```\n\nis:\n\n```\n 1    0    0   -8\n 0    1    0    1\n 0    0    1   -2\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Following pseudocode\n\n**Translation of**: Perl\n\n```\nsub rref (@m) {\n    my ($lead, $rows, $cols) = 0, @m, @m[0];\n    for ^$rows -> $r {\n        return @m unless $lead < $cols;\n        my $i = $r;\n        until @m[$i;$lead] {\n            next unless ++$i == $rows;\n            $i = $r;\n            return @m if ++$lead == $cols;\n        }\n        @m[$i, $r] = @m[$r, $i] if $r != $i;\n        @m[$r] »/=» $ = @m[$r;$lead];\n\n        for ^$rows -> $n {\n            next if $n == $r;\n            @m[$n] »-=» @m[$r] »×» (@m[$n;$lead] // 0);\n        }\n        ++$lead;\n    }\n    @m\n}\n\nsub rat-or-int ($num) {\n    return $num unless $num ~~ Rat;\n    return $num.narrow if $num.narrow ~~ Int;\n    $num.nude.join: '/';\n}\n\nsub say_it ($message, @array) {\n    say \"\\n$message\";\n    $_».&rat-or-int.fmt(\" %5s\").say for @array;\n}\n\nmy @M = (\n    [ # base test case\n      [  1,  2,  -1,  -4 ],\n      [  2,  3,  -1, -11 ],\n      [ -2,  0,  -3,  22 ],\n    ],\n    [ # mix of number styles\n      [  3,   0,  -3,    1 ],\n      [ .5, 3/2,  -3,   -2 ],\n      [ .2, 4/5,  -1.6, .3 ],\n    ],\n    [ # degenerate case\n      [ 1,  2,  3,  4,  3,  1],\n      [ 2,  4,  6,  2,  6,  2],\n      [ 3,  6, 18,  9,  9, -6],\n      [ 4,  8, 12, 10, 12,  4],\n      [ 5, 10, 24, 11, 15, -4],\n    ],\n    [ # larger matrix\n      [1,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0, -1,  0,  0,  0,  0,  0,  0],\n      [1,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0, -1,  0,  0,  0,  0,  0],\n      [1,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0, -1,  0,  0,  0,  0],\n      [0,  1,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0, -1,  0,  0,  0],\n      [0,  1,  0,  0,  0,  0,  0,  0,  1,  0,  0, -1,  0,  0,  0,  0,  0,  0],\n      [0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0, -1,  0],\n      [0,  0,  1,  0,  0,  0,  1,  0,  0,  0,  0,  0, -1,  0,  0,  0,  0,  0],\n      [0,  0,  1,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0, -1,  0,  0,  0],\n      [0,  0,  0,  1,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0, -1,  0,  0],\n      [0,  0,  0,  1,  0,  0,  0,  0,  0,  1,  0,  0, -1,  0,  0,  0,  0,  0],\n      [0,  0,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0, -1,  0,  0,  0,  0],\n      [0,  0,  0,  0,  1,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0, -1,  0],\n      [0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0, -1,  0,  0],\n      [0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],\n      [0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0],\n      [0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  1],\n      [0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  1,  0,  0,  0, -1,  0,  0,  0],\n   ]\n);\n\nfor @M -> @matrix {\n    say_it( 'Original Matrix', @matrix );\n    say_it( 'Reduced Row Echelon Form Matrix', rref(@matrix) );\n    say \"\\n\";\n}\n\n```\n\nRaku handles rational numbers internally as a ratio of two integers\nto maintain precision.\nFor some situations it is useful to return the ratio\nrather than the floating point result.\n\nOutput:\n\n```\nOriginal Matrix\n     1      2     -1     -4\n     2      3     -1    -11\n    -2      0     -3     22\n\nReduced Row Echelon Form Matrix\n     1      0      0     -8\n     0      1      0      1\n     0      0      1     -2\n\nOriginal Matrix\n     3      0     -3      1\n   1/2    3/2     -3     -2\n   1/5    4/5   -8/5   3/10\n\nReduced Row Echelon Form Matrix\n     1      0      0  -41/2\n     0      1      0  -217/6\n     0      0      1  -125/6\n\nOriginal Matrix\n     1      2      3      4      3      1\n     2      4      6      2      6      2\n     3      6     18      9      9     -6\n     4      8     12     10     12      4\n     5     10     24     11     15     -4\n\nReduced Row Echelon Form Matrix\n     1      2      0      0      3      4\n     0      0      1      0      0     -1\n     0      0      0      1      0      0\n     0      0      0      0      0      0\n     0      0      0      0      0      0\n\nOriginal Matrix\n     1      0      0      0      0      0      1      0      0      0      0     -1      0      0      0      0      0      0\n     1      0      0      0      0      0      0      1      0      0      0      0     -1      0      0      0      0      0\n     1      0      0      0      0      0      0      0      1      0      0      0      0     -1      0      0      0      0\n     0      1      0      0      0      0      1      0      0      0      0      0      0      0     -1      0      0      0\n     0      1      0      0      0      0      0      0      1      0      0     -1      0      0      0      0      0      0\n     0      1      0      0      0      0      0      0      0      0      1      0      0      0      0      0     -1      0\n     0      0      1      0      0      0      1      0      0      0      0      0     -1      0      0      0      0      0\n     0      0      1      0      0      0      0      0      0      1      0      0      0      0     -1      0      0      0\n     0      0      0      1      0      0      0      1      0      0      0      0      0      0      0     -1      0      0\n     0      0      0      1      0      0      0      0      0      1      0      0     -1      0      0      0      0      0\n     0      0      0      0      1      0      0      1      0      0      0      0      0     -1      0      0      0      0\n     0      0      0      0      1      0      0      0      1      0      0      0      0      0      0      0     -1      0\n     0      0      0      0      1      0      0      0      0      0      1      0      0      0      0     -1      0      0\n     0      0      0      0      0      1      0      0      0      0      0      0      0      0      0      0      0      0\n     0      0      0      0      0      0      0      0      0      1      0      0      0      0      0      0      0      0\n     0      0      0      0      0      0      0      0      0      0      0      0      0      0      0      1      0      1\n     0      0      0      0      0      1      0      0      0      0      1      0      0      0     -1      0      0      0\n\nReduced Row Echelon Form Matrix\n     1      0      0      0      0      0      0      0      0      0      0      0      0      0      0      0      0  17/39\n     0      1      0      0      0      0      0      0      0      0      0      0      0      0      0      0      0   4/13\n     0      0      1      0      0      0      0      0      0      0      0      0      0      0      0      0      0  20/39\n     0      0      0      1      0      0      0      0      0      0      0      0      0      0      0      0      0  28/39\n     0      0      0      0      1      0      0      0      0      0      0      0      0      0      0      0      0  19/39\n     0      0      0      0      0      1      0      0      0      0      0      0      0      0      0      0      0      0\n     0      0      0      0      0      0      1      0      0      0      0      0      0      0      0      0      0   8/39\n     0      0      0      0      0      0      0      1      0      0      0      0      0      0      0      0      0  11/39\n     0      0      0      0      0      0      0      0      1      0      0      0      0      0      0      0      0    1/3\n     0      0      0      0      0      0      0      0      0      1      0      0      0      0      0      0      0      0\n     0      0      0      0      0      0      0      0      0      0      1      0      0      0      0      0      0  20/39\n     0      0      0      0      0      0      0      0      0      0      0      1      0      0      0      0      0  25/39\n     0      0      0      0      0      0      0      0      0      0      0      0      1      0      0      0      0  28/39\n     0      0      0      0      0      0      0      0      0      0      0      0      0      1      0      0      0  10/13\n     0      0      0      0      0      0      0      0      0      0      0      0      0      0      1      0      0  20/39\n     0      0      0      0      0      0      0      0      0      0      0      0      0      0      0      1      0      1\n     0      0      0      0      0      0      0      0      0      0      0      0      0      0      0      0      1  32/39\n\n```\n\n### Row operations, procedural code\n\nRe-implemented as elementary matrix row operations. Follow links for background on\nrow operations\nand\nreduced row echelon form\n\n```\nsub    scale-row ( @M, \\scale, \\r       ) { @M[r]  =              @M[r]  »×» scale   }\nsub    shear-row ( @M, \\scale, \\r1, \\r2 ) { @M[r1] = @M[r1] »+» ( @M[r2] »×» scale ) }\nsub   reduce-row ( @M,         \\r,  \\c  ) { scale-row @M, 1/@M[r;c], r }\nsub clear-column ( @M,         \\r,  \\c  ) { shear-row @M, -@M[$_;c], $_, r for @M.keys.grep: * != r }\n\nmy @M = (\n    [<  1   2   -1    -4 >],\n    [<  2   3   -1   -11 >],\n    [< -2   0   -3    22 >],\n);\n\nmy $column-count = @M[0];\nmy $col = 0;\nfor @M.keys -> $row {\n      reduce-row( @M, $row, $col );\n    clear-column( @M, $row, $col );\n    last if ++$col == $column-count;\n}\n\nsay @$_».fmt(' %4g') for @M;\n\n```\n\nOutput:\n\n```\n[    1     0     0    -8]\n[    0     1     0     1]\n[    0     0     1    -2]\n```\n\n### Row operations, object-oriented code\n\nThe same code as previous section, recast into OO. Also, scale and shear are recast as unscale and unshear, which fit the problem better.\n\n```\nclass Matrix is Array {\n    method  unscale-row ( @M: \\scale, \\row       ) { @M[row] =            @M[row] »/» scale }\n    method  unshear-row ( @M: \\scale, \\r1,  \\r2  ) { @M[r1]  = @M[r1] »-» @M[r2]  »×» scale }\n    method   reduce-row ( @M:         \\row, \\col ) { @M.unscale-row( @M[row;col], row ) }\n    method clear-column ( @M:         \\row, \\col ) { @M.unshear-row( @M[$_;col], $_, row ) for @M.keys.grep: * != row }\n\n    method reduced-row-echelon-form ( @M: ) {\n        my $column-count =  @M[0];\n        my $col = 0;\n        for @M.keys -> $row {\n            @M.reduce-row(   $row, $col );\n            @M.clear-column( $row, $col );\n            return if ++$col == $column-count;\n        }\n    }\n}\n\nmy $M = Matrix.new(\n    [<  1   2   -1    -4 >],\n    [<  2   3   -1   -11 >],\n    [< -2   0   -3    22 >],\n);\n\n$M.reduced-row-echelon-form;\nsay @$_».fmt(' %4g') for @$M;\n\n```\n\nOutput:\n\n```\n[    1     0     0    -8]\n[    0     1     0     1]\n[    0     0     1    -2]\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nThe goal is to get the source code or file path and line number where a programming object (e.g. module, class, function, method) is defined."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.11\n\nA full path is provided for built-in routines/methods. However for routines exported by pre-compiled modules a precompilation hash is returned, not a proper file path.\n\n```\nsay &sum.file;\nsay Date.^find_method(\"day-of-week\").file;\n\n```\n\nOutput:\n\n```\nSETTING::src/core/Any.pm\nSETTING::src/core/Dateish.pm\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nThe goal is to get the methods of an object, as names, values or both.\n\nSome languages offer dynamic methods, which in general can only be inspected if a class' public API includes a way of listing them."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nYou can get a list of an object's methods using .^methods, which is part of the Meta Object Protocol.  \nEach is represented as a Method object that contains a bunch of info:\n\n```\nclass Foo {\n    method foo ($x)      { }\n    method bar ($x, $y)  { }\n    method baz ($x, $y?) { }\n}\n\nmy $object = Foo.new;\n\nfor $object.^methods {\n    say join \", \", .name, .arity, .count, .signature.gist\n}\n\n```\n\nOutput:\n\n```\nfoo, 2, 2, (Foo $: $x, *%_)\nbar, 3, 3, (Foo $: $x, $y, *%_)\nbaz, 2, 3, (Foo $: $x, $y?, *%_)\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nThe goal is to get the properties of an object, as names, values or both.\n\nSome languages support dynamic properties, which in general can only be inspected if a class' public API includes a way of listing them."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nYou can get a list of an object's attributes (instance variables) using .^attributes, which is part of the Meta Object Protocol..  \nEach is represented as an Attribute object that contains a bunch of info:\n\n```\nclass Foo {\n    has $!a = now;\n    has Str $.b;\n    has Int $.c is rw;\n}\n\nmy $object = Foo.new: b => \"Hello\", c => 42;\n\nfor $object.^attributes {\n    say join \", \", .name, .readonly, .container.^name, .get_value($object);\n}\n\n```\n\nOutput:\n\n```\n$!a, True, Any, Instant:1470517602.295992\n$!b, True, Str, Hello\n$!c, False, Int, 42\n\n```\n\nPublic attributes (in this case, $.b and $.c) are really just attributes for which the compiler also auto-generates a method of the same name. See Reflection/List\\_methods#Raku."}]}
{"messages": [{"role": "user", "content": "Task\n:   * match a string against a regular expression\n    * substitute part of a string using a regular expression"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nif 'a long string' ~~ /string$/ {\n   say \"It ends with 'string'\";\n}\n\n# substitution has a few nifty features\n\n$_ = 'The quick Brown fox';\ns:g:samecase/\\w+/xxx/;\n.say;\n# output:\n# Xxx xxx Xxx xxx\n\n```"}]}
{"messages": [{"role": "user", "content": "Given an Array, derive a sequence of elements in which all duplicates are removed.\n\nThere are basically three approaches seen here:\n\n* Put the elements into a hash table which does not allow duplicates. The complexity is O(*n*) on average, and O(*n*2) worst case. This approach requires a hash function for your type (which is compatible with equality), either built-in to your language, or provided by the user.\n* Sort the elements and remove consecutive duplicate elements. The complexity of the best sorting algorithms is O(*n* log *n*). This approach requires that your type be \"comparable\", i.e., have an ordering. Putting the elements into a self-balancing binary search tree is a special case of sorting.\n* Go through the list, and for each element, check the rest of the list to see if it appears again, and discard it if it does. The complexity is O(*n*2). The up-shot is that this always works on any type (provided that you can test for equality)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @unique = [1, 2, 3, 5, 2, 4, 3, -3, 7, 5, 6].unique;\n```\n\nOr just make a set of it.\n\n```\nset(1,2,3,5,2,4,3,-3,7,5,6).list\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nRemove a specific line or a number of lines from a file.\n\nThis should be implemented as a routine that takes three parameters (filename, starting line, and the number of lines to be removed).\n\nFor the purpose of this task, line numbers and the number of lines start at one, so to remove the first two lines from the file foobar.txt, the parameters should be: foobar.txt, 1, 2\n\nEmpty lines are considered and should still be counted, and if the specified line is empty, it should still be removed.\n\nAn appropriate message should appear if an attempt is made to remove lines beyond the end of the file."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub MAIN ($filename, $beg, $len) {\n    my @lines = split /^^/, slurp $filename;\n    unlink $filename;  # or rename\n    splice(@lines,$beg,$len) == $len or warn \"Too few lines\";\n    spurt $filename, @lines;\n}\n\n```\n\nOutput:\n\n```\n$ cal >foo\n$ ./rmlines\n Usage:\n   rmlines <filename> <beg> <len>\n$ ./rmlines foo 1 2\n$ cat foo\n  1  2  3  4  5  6  7  \n  8  9 10 11 12 13 14  \n 15 16 17 18 19 20 21  \n 22 23 24 25 26 27 28  \n 29 30 31\n\n```"}]}
{"messages": [{"role": "user", "content": "Remove vowels from a string\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.07\n\nNot going to bother with 'y', it's too touchy feely (How many vowels are in the word my? why? any?) and subject to interpretation.\n\nOtherwise, this should work for *most* Latinate languages.\n\nApropos of nothing; reminds me of one of my favorite Between the Lions performances: Sloppy Pop - Sometimes Y\n\nSpec is 'Remove vowels from a string'; nothing about what they should be replaced with. I chose to replace them with spaces.\n\nStrings from http://mylanguages.org/. No affiliation, but it's a nice resource. (note: these are not all the same sentence but are all from the same paragraph. They frankly were picked based on their vowel load.)\n\n```\nmy @vowels = (0x20 .. 0x2fff).map: { .chr if .chr.samemark('x') ~~ m:i/<[aæeiıoœu]>/ }\n\nmy $text = q:to/END/;\n   Norwegian, Icelandic, German, Turkish, French, Spanish, English:\n   Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.\n   Skal hún veitt ókeypis, að minnsta kosti barnafræðsla og undirstöðummentu.\n   Hochschulunterricht muß allen gleichermaßen entsprechend ihren Fähigkeiten offenstehen.\n   Öğrenim hiç olmazsa ilk ve temel safhalarında parasızdır. İlk öğretim mecburidir.\n   L'éducation doit être gratuite, au moins en ce qui concerne l'enseignement élémentaire et fondamental.\n   La instrucción elemental será obligatoria. La instrucción técnica y profesional habrá de ser generalizada.\n   Education shall be free, at least in the elementary and fundamental stages.\n   END\n\nput $text.subst(/@vowels/, ' ', :g);\n\n```\n\nOutput:\n\n```\nN rw g  n,  c l nd c, G rm n, T rk sh, Fr nch, Sp n sh,  ngl sh:\n nd rv sn ng n sk l v r  gr t s,   d t m nst  p  d   l m nt r   g gr nnl gg nd  tr nn.\nSk l h n v  tt  k yp s,  ð m nnst  k st  b rn fr ðsl   g  nd rst ð mm nt .\nH chsch l nt rr cht m ß  ll n gl  ch rm ß n  ntspr ch nd  hr n F h gk  t n  ff nst h n.\n ğr n m h ç  lm zs   lk v  t m l s fh l r nd  p r s zd r.  lk  ğr t m m cb r d r.\nL' d c t  n d  t  tr  gr t  t ,    m  ns  n c  q   c nc rn  l' ns  gn m nt  l m nt  r   t f nd m nt l.\nL   nstr cc  n  l m nt l s r   bl g t r  . L   nstr cc  n t cn c  y pr f s  n l h br  d  s r g n r l z d .\n d c t  n sh ll b  fr  ,  t l  st  n th   l m nt ry  nd f nd m nt l st g s.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nRename:\n\n:   :   :   * a file called     **input.txt**     into     **output.txt**     and\n            * a directory called     **docs**     into     **mydocs**.\n\nThis should be done twice:  \nonce \"here\", i.e. in the current working directory and once in the filesystem root.\n\nIt can be assumed that the user has the rights to do so.\n\n(In unix-type systems, only the user root would have\nsufficient permissions in the filesystem root.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nrename 'input.txt', 'output.txt';\nrename 'docs', 'mydocs';\nrename '/input.txt', '/output.txt';\nrename '/docs', '/mydocs';\n\n```"}]}
{"messages": [{"role": "user", "content": "Demonstrate the “rendezvous” communications technique by implementing a printer monitor.\n\n## Detailed Description of Programming Task\n\nRendezvous is a synchronization mechanism based on procedural decomposition. Rendezvous is similar to a procedure call with the difference that the caller and the callee belong to different tasks. The called procedure is usually called an **entry point** of the corresponding task. A call to an entry point is synchronous, i.e. the caller is blocked until completion. For the caller a call to the entry point is indivisible. Internally it consists of:\n\n* Waiting for the callee ready to accept the rendezvous;\n* Engaging the rendezvous (servicing the entry point).\n\nThe caller may limit the waiting time to the callee to accept the rendezvous. I.e. a rendezvous request can be aborted if not yet accepted by the callee. When accepted the rendezvous is processed until its completion. During this time the caller and the callee tasks stay synchronized. Which context is used to process the rendezvous depends on the implementation which may wish to minimize context switching.\n\nThe callee task may accept several rendezvous requests:\n\n* Rendezvous to the same entry point from different tasks;\n* Rendezvous to different entry points.\n\nThe callee accepts one rendezvous at a time.\n\nLanguage mechanism of exceptions (if any) has to be consistent with the rendezvous. In particular when an exception is propagated out of a rendezvous it shall do in both tasks. The exception propagation is synchronous within the rendezvous and asynchronous outside it.\n\nAn engaged rendezvous can be requeued by the callee to another entry point of its task or to another task, transparently to the caller.\n\nDifferently to messages which are usually asynchronous, rendezvous are synchronous, as it was stated before. Therefore a rendezvous does not require marshaling the parameters and a buffer to keep them. Further, rendezvous can be implemented without context switch. This makes rendezvous a more efficient than messaging.\n\nRendezvous can be used to implement monitor synchronization objects. A monitor guards a shared resource. All users of the resource request a rendezvous to the monitor in order to get access to the resource. Access is granted by accepting the rendezvous for the time while the rendezvous is serviced.\n\n### Language task\n\nShow how rendezvous are supported by the language. If the language does not have rendezvous, provide an implementation of them based on other primitives.\n\n### Use case task\n\nImplement a printer monitor. The monitor guards a printer. There are two printers *main* and *reserve*. Each has a monitor that accepts a rendezvous Print with a text line to print of the printer. The standard output may serve for printing purpose. Each character of the line is printed separately in order to illustrate that lines are printed indivisibly. Each printer has ink for only 5 lines of text. When the *main* printer runs out of ink it redirects its requests to the *reserve* printer. When that runs out of ink too, Out\\_Of\\_Ink exception propagates back to the caller. Create two writer tasks which print their plagiarisms on the printer. One does *Humpty Dumpty*, another *Mother Goose*."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku has no built-in support for rendezvous. Simulated using message passing and a lock. May be slightly bogus.\n\n**Works with**: Rakudo version 2016.08\n\n```\nclass X::OutOfInk is Exception {\n    method message() { \"Printer out of ink\" }\n}\n\nclass Printer {\n    has Str      $.id;\n    has Int      $.ink = 5;\n    has Lock     $!lock .= new;\n    has ::?CLASS $.fallback;\n    \n    method print ($line) {\n        $!lock.protect: {\n            if    $!ink      { say \"$!id: $line\"; $!ink-- }\n            elsif $!fallback { $!fallback.print: $line }\n            else             { die X::OutOfInk.new }\n        }\n    }\n}\n\nmy $printer =\n    Printer.new: id => 'main', fallback =>\n    Printer.new: id => 'reserve';\n\nsub client ($id, @lines) {\n    start {\n        for @lines {\n            $printer.print: $_;\n            CATCH {\n                when X::OutOfInk { note \"<$id stops for lack of ink>\"; exit }\n            }\n        }\n        note \"<$id is done>\";\n    }\n}\n\nawait\n    client('Humpty', q:to/END/.lines),\n        Humpty Dumpty sat on a wall.\n        Humpty Dumpty had a great fall.\n        All the king's horses and all the king's men,\n        Couldn't put Humpty together again.\n        END\n    client('Goose', q:to/END/.lines);\n        Old Mother Goose,\n        When she wanted to wander,\n        Would ride through the air,\n        On a very fine gander.\n        Jack's mother came in,\n        And caught the goose soon,\n        And mounting its back,\n        Flew up to the moon.\n        END\n\n```\n\nOutput:\n\n```\nmain: Humpty Dumpty sat on a wall.\nmain: Old Mother Goose,\nmain: Humpty Dumpty had a great fall.\nmain: When she wanted to wander,\nmain: All the king's horses and all the king's men,\nreserve: Would ride through the air,\nreserve: Couldn't put Humpty together again.\nreserve: On a very fine gander.\n<Humpty is done>\nreserve: Jack's mother came in,\nreserve: And caught the goose soon,\n<Goose stops for lack of ink>\n\n```"}]}
{"messages": [{"role": "user", "content": "Given a series of ones and zeroes in a string, define a repeated string or *rep-string* as a string which is created by repeating a substring of the *first* N characters of the string *truncated on the right to the length of the input string, and in which the substring appears repeated at least twice in the original*.\n\nFor example, the string **10011001100** is a rep-string as the leftmost four characters of **1001** are repeated three times and truncated on the right to give the original string.\n\nNote that the requirement for having the repeat occur two or more times means that the repeating unit is *never* longer than half the length of the input string.\n\nTask\n\n* Write a function/subroutine/method/... that takes a string and returns an indication of if it is a rep-string and the repeated string.   (Either the string that is repeated, or the number of repeated characters would suffice).\n* There may be multiple sub-strings that make a string a rep-string - in that case an indication of all, or the longest, or the shortest would suffice.\n* Use the function to indicate the repeating substring if any, in the following:\n\n:   ```\n    1001110011\n    1110111011\n    0010010010\n    1010101010\n    1111111111\n    0100101101\n    0100100\n    101\n    11\n    00\n    1\n\n    ```\n\n* Show your output on this page.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nfor <1001110011 1110111011 0010010010 1010101010 1111111111 0100101101 0100100 101 11 00 1> {\n    if /^ (.+) $0+: (.*$) <?{ $0.substr(0,$1.chars) eq $1 }> / {\n\tmy $rep = $0.chars;\n\tsay .substr(0,$rep), .substr($rep,$rep).trans('01' => '𝟘𝟙'), .substr($rep*2);\n    }\n    else {\n\tsay \"$_ (no repeat)\";\n    }\n}\n\n```\n\nOutput:\n\n```\n10011𝟙𝟘𝟘𝟙𝟙\n1110𝟙𝟙𝟙𝟘11\n001𝟘𝟘𝟙0010\n1010𝟙𝟘𝟙𝟘10\n11111𝟙𝟙𝟙𝟙𝟙\n0100101101 (no repeat)\n010𝟘𝟙𝟘0\n101 (no repeat)\n1𝟙\n0𝟘\n1 (no repeat)\n```\n\nHere's a technique that relies on the fact that XORing the shifted binary number\nshould set all the lower bits to 0 if there are repeats.\n(The cool thing is that shift will automatically\nthrow away the bits on the right that you want thrown away.)\nThis produces the same output as above.\n\n```\nsub repstr(Str $s) {\n    my $bits = :2($s);\n    for reverse 1 .. $s.chars div 2 -> $left {\n\tmy $right = $s.chars - $left;\n\treturn $left if $bits +^ ($bits +> $left) == $bits +> $right +< $right;\n    }\n}\n\n\nfor '1001110011 1110111011 0010010010 1010101010 1111111111 0100101101 0100100 101 11 00 1'.words {\n    if repstr $_ -> $rep {\n\tsay .substr(0,$rep), .substr($rep,$rep).trans('01' => '𝟘𝟙'), .substr($rep*2);\n    }\n    else {\n\tsay \"$_ (no repeat)\";\n    }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a procedure which accepts as arguments another procedure and a positive integer.\n\nThe latter procedure is executed a number of times equal to the accepted integer."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub repeat (&f, $n) { f() xx $n };\n\nsub example { say rand }\n\nrepeat(&example, 3);\n\n```\n\nOutput:\n\n```\n0.435249779778396\n0.647701200726486\n0.279289335968417\n\n```\n\nOf course, we could have just written\n\n```\nexample() xx 3;\n```\n\nor even\n\n```\n(say rand) xx 3;\n```\n\ndirectly – the custom `repeat` subroutine is just here to satisfy the task description.\n\nNotes on the xx operator:\n\n* Unlike other operators, it evaluates its left-hand-side argument lazily - that's why we can simply call `f()` there rather than passing it as a function object.\n* The operator has a return value: A list consisting of the return values of the left-hand-side *(and building lists is in fact what `xx` is usually used for)*.\n\nGeneral notes:\n\n* The `&` sigil in the `repeat` subroutine signature restricts that parameter to types that implement the `Callable` role, and makes it available inside the `repeat` subroutine body as if it were a lexically scoped sub.\n* The parentheses in the last line are necessary to disambiguate it as a call to our custom subroutine, rather than an attempt to use the built-in `repeat { ... } while ...` construct."}]}
{"messages": [{"role": "user", "content": "Take a string and repeat it some number of times.\n\nExample: repeat(\"ha\", 5)   =>   \"hahahahaha\"\n\nIf there is a simpler/more efficient way to repeat a single “character” (i.e. creating a string filled with a certain character), you might want to show that as well (i.e. repeat-char(\"\\*\", 5) => \"\\*\\*\\*\\*\\*\").\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nprint \"ha\" x 5\n```\n\n(Note that the `x` operator isn't quite the same as in Perl 5: it now only creates strings. To create lists, use `xx`.)"}]}
{"messages": [{"role": "user", "content": "Repunit is a portmanteau of the words \"repetition\" and \"unit\", with unit being \"unit value\"... or in laymans terms, **1**. So 1, 11, 111, 1111 & 11111 are all repunits.\n\nEvery standard integer base has repunits since every base has the digit 1. This task involves finding the repunits in different bases that are prime.\n\nIn base two, the repunits 11, 111, 11111, 1111111, etc. are prime. (These correspond to the Mersenne primes.)\n\nIn base three: 111, 1111111, 1111111111111, etc.\n\n*Repunit primes, by definition, are also circular primes.*\n\nAny repunit in any base having a composite number of digits is necessarily composite. Only repunits (in any base) having a prime number of digits *might* be prime.\n\nRather than expanding the repunit out as a giant list of **1**s or converting to base 10, it is common to just list the *number* of **1**s in the repunit; effectively the digit count. The base two repunit primes listed above would be represented as: 2, 3, 5, 7, etc.\n\nMany of these sequences exist on OEIS, though they aren't specifically listed as \"repunit prime digits\" sequences.\n\nSome bases have very few repunit primes. Bases 4, 8, and likely 16 have only one. Base 9 has none at all. Bases above 16 may have repunit primes as well... but this task is getting large enough already.\n\nTask\n\n* For bases 2 through 16, Find and show, here on this page, the repunit primes as digit counts, up to a limit of 1000.\n\nStretch\n\n* Increase the limit to 2700 (or as high as you have patience for.)\n\nSee also\n\n* Wikipedia: Repunit primes * OEIS:A000043 - Mersenne exponents: primes p such that 2^p - 1 is prime. Then 2^p - 1 is called a Mersenne prime (base 2) * OEIS:A028491 - Numbers k such that (3^k - 1)/2 is prime (base 3) * OEIS:A004061 - Numbers n such that (5^n - 1)/4 is prime (base 5) * OEIS:A004062 - Numbers n such that (6^n - 1)/5 is prime (base 6) * OEIS:A004063 - Numbers k such that (7^k - 1)/6 is prime (base 7) * OEIS:A004023 - Indices of prime repunits: numbers n such that 11...111 (with n 1's) = (10^n - 1)/9 is prime (base 10) * OEIS:A005808 - Numbers k such that (11^k - 1)/10 is prime (base 11) * OEIS:A004064 - Numbers n such that (12^n - 1)/11 is prime (base 12) * OEIS:A016054 - Numbers n such that (13^n - 1)/12 is prime (base 13) * OEIS:A006032 - Numbers k such that (14^k - 1)/13 is prime (base 14) * OEIS:A006033 - Numbers n such that (15^n - 1)/14 is prime (base 15) * Related task: Circular primes"}, {"role": "assistant", "content": "```\nmy $limit = 2700;\n\nsay \"Repunit prime digits (up to $limit) in:\";\n\n.put for (2..16).hyper(:1batch).map: -> $base {\n    $base.fmt(\"Base %2d: \") ~ (1..$limit).grep(&is-prime).grep( (1 x *).parse-base($base).is-prime )\n}\n\n```\n\nOutput:\n\n```\nRepunit prime digits (up to 2700) in:\nBase  2: 2 3 5 7 13 17 19 31 61 89 107 127 521 607 1279 2203 2281\nBase  3: 3 7 13 71 103 541 1091 1367 1627\nBase  4: 2\nBase  5: 3 7 11 13 47 127 149 181 619 929\nBase  6: 2 3 7 29 71 127 271 509 1049\nBase  7: 5 13 131 149 1699\nBase  8: 3\nBase  9: \nBase 10: 2 19 23 317 1031\nBase 11: 17 19 73 139 907 1907 2029\nBase 12: 2 3 5 19 97 109 317 353 701\nBase 13: 5 7 137 283 883 991 1021 1193\nBase 14: 3 7 19 31 41 2687\nBase 15: 3 43 73 487 2579\nBase 16: 2\n```\n\n*And for my own amusement, also tested up to 2700.*\n\n```\nBase 17: 3 5 7 11 47 71 419\nBase 18: 2\nBase 19: 19 31 47 59 61 107 337 1061\nBase 20: 3 11 17 1487\nBase 21: 3 11 17 43 271\nBase 22: 2 5 79 101 359 857\nBase 23: 5\nBase 24: 3 5 19 53 71 653 661\nBase 25: \nBase 26: 7 43 347\nBase 27: 3\nBase 28: 2 5 17 457 1423\nBase 29: 5 151\nBase 30: 2 5 11 163 569 1789\nBase 31: 7 17 31\nBase 32: \nBase 33: 3 197\nBase 34: 13 1493\nBase 35: 313 1297\nBase 36: 2\n```"}]}
{"messages": [{"role": "user", "content": "Introduction\n\n* Calculate the resistance of a network of resistors.\n* The resistors can be connected in series or parallel.\n* Use infix or RPN to state the network.\n* Calculate resistance, voltage, current and power for every resistor and operation.\n\nBackground\n\n* Serial Resistors: the sum of the resistors gives the equivalent resistor\n* Parallel Resistors: the inverse of the sum of the inverse of the resistors\n* The voltage drops over the resistors\n* Current = Resistance / Voltage\n* Power = Current \\* Voltage\n\nInput\n\nResistance Calculator\n\n* Infix: ((((10 + 2) \\* 6 + 8) \\* 6 + 4) \\* 8 + 4) \\* 8 + 6\n* RPN: 10 2 + 6 \\* 8 + 6 \\* 4 + 8 \\* 4 + 8 \\* 6 +\n* Voltage = 18.0 V\n\nOutput\n\n* 10.000 ohms in the upper left corner is the equivalent resistance.\n* The first operation is 10 + 2 = 12 which can be found in the three middle rows.\n\n```\n    Ohm     Volt   Ampere     Watt  Network tree\n 10.000   18.000    1.800   32.400  +\n  4.000    7.200    1.800   12.960  | *\n  8.000    7.200    0.900    6.480  | | +\n  4.000    3.600    0.900    3.240  | | | *\n  8.000    3.600    0.450    1.620  | | | | +\n  4.000    1.800    0.450    0.810  | | | | | *\n 12.000    1.800    0.150    0.270  | | | | | | +\n  4.000    0.600    0.150    0.090  | | | | | | | *\n 12.000    0.600    0.050    0.030  | | | | | | | | +\n 10.000    0.500    0.050    0.025  | | | | | | | | | r\n  2.000    0.100    0.050    0.005  | | | | | | | | | r\n  6.000    0.600    0.100    0.060  | | | | | | | | r\n  8.000    1.200    0.150    0.180  | | | | | | | r\n  6.000    1.800    0.300    0.540  | | | | | | r\n  4.000    1.800    0.450    0.810  | | | | | r\n  8.000    3.600    0.450    1.620  | | | | r\n  4.000    3.600    0.900    3.240  | | | r\n  8.000    7.200    0.900    6.480  | | r\n  6.000   10.800    1.800   19.440  | r\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Infix\n\n**Translation of**: Nim\n\n```\nclass Resistor {\n    has Str        $.symbol;\n    has Numeric  ( $.voltage, $.resistance );\n    has Resistor ( $.a, $.b );\n\n    method res ( ) {\n        given $.symbol {\n            when '+' { return $.a.res + $.b.res }\n            when '*' { return 1 / (1 / $.a.res  +  1 / $.b.res) }\n            default  { return $.resistance }\n        }\n    }\n\n    method set-voltage ( Numeric $voltage ) {\n        given $.symbol {\n            when '+' {\n                my $ra = $.a.res;\n                my $rb = $.b.res;\n                $.a.set-voltage( $ra / ($ra+$rb) * $voltage );\n                $.b.set-voltage( $rb / ($ra+$rb) * $voltage );\n            }\n            when '*' {\n                $.a.set-voltage( $voltage );\n                $.b.set-voltage( $voltage );\n            }\n        }\n        $!voltage = $voltage;\n    }\n    method current ( ) { return $.voltage / self.res     }\n    method effect  ( ) { return $.voltage * self.current }\n\n    method report ( Int $level = 1 ) {\n        my $pad = '| ' x $level;\n        my $f = ( self.res, $.voltage, self.current, self.effect ).fmt('%8.3f');\n        say \"$f $pad$.symbol\";\n        $.a.report( $level+1 ) if $.a;\n        $.b.report( $level+1 ) if $.b;\n    }\n}\nmulti sub infix:<+> (Resistor $a, Resistor $b) { $a.new( symbol => '+', :$a, :$b ) }\nmulti sub infix:<*> (Resistor $a, Resistor $b) { $a.new( symbol => '*', :$a, :$b ) }\n\nmy Resistor ($R1, $R2, $R3, $R4, $R5, $R6, $R7, $R8, $R9, $R10) =\n    map { Resistor.new: symbol => 'r', resistance => $_ },\n    6, 8, 4, 8, 4, 6, 8, 10, 6, 2;\n\nmy $node = (((($R8 + $R10) * $R9 + $R7) * $R6 + $R5)\n                           * $R4 + $R3) * $R2 + $R1;\n$node.set-voltage(18);\n\nsay '     Ohm     Volt   Ampere     Watt  Network tree';\n$node.report;\n\n```\n\nOutput:\n\n```\n     Ohm     Volt   Ampere     Watt  Network tree\n  10.000   18.000    1.800   32.400 | +\n   4.000    7.200    1.800   12.960 | | *\n   8.000    7.200    0.900    6.480 | | | +\n   4.000    3.600    0.900    3.240 | | | | *\n   8.000    3.600    0.450    1.620 | | | | | +\n   4.000    1.800    0.450    0.810 | | | | | | *\n  12.000    1.800    0.150    0.270 | | | | | | | +\n   4.000    0.600    0.150    0.090 | | | | | | | | *\n  12.000    0.600    0.050    0.030 | | | | | | | | | +\n  10.000    0.500    0.050    0.025 | | | | | | | | | | r\n   2.000    0.100    0.050    0.005 | | | | | | | | | | r\n   6.000    0.600    0.100    0.060 | | | | | | | | | r\n   8.000    1.200    0.150    0.180 | | | | | | | | r\n   6.000    1.800    0.300    0.540 | | | | | | | r\n   4.000    1.800    0.450    0.810 | | | | | | r\n   8.000    3.600    0.450    1.620 | | | | | r\n   4.000    3.600    0.900    3.240 | | | | r\n   8.000    7.200    0.900    6.480 | | | r\n   6.000   10.800    1.800   19.440 | | r\n```"}]}
{"messages": [{"role": "user", "content": "Introduction\n\nCalculate the resistance of any resistor network.\n\n* The network is stated with a string.\n* The resistors are separated by a vertical dash.\n* Each resistor has\n  + a starting node\n  + an ending node\n  + a resistance\n\nBackground\n\nArbitrary Resistor Grid\n\nRegular 3x3 mesh, using twelve one ohm resistors\n\n```\n0 - 1 - 2\n|   |   | \n3 - 4 - 5\n|   |   |\n6 - 7 - 8 \n\n```\n\nBattery connection nodes: 0 and 8\n\n```\nassert 3/2 == network(9,0,8,\"0 1 1|1 2 1|3 4 1|4 5 1|6 7 1|7 8 1|0 3 1|3 6 1|1 4 1|4 7 1|2 5 1|5 8 1\")\n\n```\n\nRegular 4x4 mesh, using 24 one ohm resistors\n\n```\n 0 - 1 - 2 - 3\n |   |   |   |   \n 4 - 5 - 6 - 7\n |   |   |   |\n 8 - 9 -10 -11\n |   |   |   |\n12 -13 -14 -15\n\n```\n\nBattery connection nodes: 0 and 15\n\n```\nassert 13/7 == network(16,0,15,\"0 1 1|1 2 1|2 3 1|4 5 1|5 6 1|6 7 1|8 9 1|9 10 1|10 11 1|12 13 1|13 14 1|14 15 1|0 4 1|4 8 1|8 12 1|1 5 1|5 9 1|9 13 1|2 6 1|6 10 1|10 14 1|3 7 1|7 11 1|11 15 1\")\n\n```\n\nTen resistor network\n\nPicture\n\nBattery connection nodes: 0 and 1\n\n```\nassert 10 == network(7,0,1,\"0 2 6|2 3 4|3 4 10|4 5 2|5 6 8|6 1 4|3 5 6|3 6 6|3 1 8|2 1 8\")\n\n```\n\nWheatstone network\n\nPicture\n\nThis network is not possible to solve using the previous Resistance Calculator\nas there is no natural starting point.\n\n```\nassert 180 == network(4,0,3,\"0 1 150|0 2 50|1 3 300|2 3 250\")\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n```\nsub gauss ( @m is copy ) {\n    for @m.keys -> \\i {\n        my \\k = max |(i .. @m.end), :by({ @m[$_][i].abs });\n\n        @m[i, k] .= reverse if \\k != i;\n\n        .[i ^.. *] »/=» .[i] given @m[i];\n\n        for i ^.. @m.end -> \\j {\n            @m[j][i ^.. *] »-=« ( @m[j][i] «*« @m[i][i ^.. *] );\n        }\n    }\n    for @m.keys.reverse -> \\i {\n        @m[^i]».[*-1] »-=« ( @m[^i]».[i] »*» @m[i][*-1] );\n    }\n    return @m».[*-1];\n}\nsub network ( Int \\n, Int \\k0, Int \\k1, Str \\grid ) {\n    my @m = [0 xx n+1] xx n;\n\n    for grid.split('|') -> \\resistor {\n        my ( \\a, \\b, \\r_inv ) = resistor.split(/\\s+/, :skip-empty);\n        my \\r = 1 / r_inv;\n\n        @m[a][a] += r;\n        @m[b][b] += r;\n        @m[a][b] -= r if a > 0;\n        @m[b][a] -= r if b > 0;\n    }\n    @m[k0][k0]  = 1;\n    @m[k1][*-1] = 1;\n\n    return gauss(@m)[k1];\n}\nuse Test;\nmy @tests =\n    (   10,   7, 0,     1, '0 2 6|2 3 4|3 4 10|4 5 2|5 6 8|6 1 4|3 5 6|3 6 6|3 1 8|2 1 8' ),\n    (  3/2, 3*3, 0, 3*3-1, '0 1 1|1 2 1|3 4 1|4 5 1|6 7 1|7 8 1|0 3 1|3 6 1|1 4 1|4 7 1|2 5 1|5 8 1' ),\n    ( 13/7, 4*4, 0, 4*4-1, '0 1 1|1 2 1|2 3 1|4 5 1|5 6 1|6 7 1|8 9 1|9 10 1|10 11 1|12 13 1|13 14 1|14 15 1|0 4 1|4 8 1|8 12 1|1 5 1|5 9 1|9 13 1|2 6 1|6 10 1|10 14 1|3 7 1|7 11 1|11 15 1' ),\n    (  180,   4, 0,     3, '0 1 150|0 2 50|1 3 300|2 3 250' ),\n;\nplan +@tests;\nis .[0], network( |.[1..4] ), .[4].substr(0,10)~'…' for @tests;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven    10×10    grid nodes   (as shown in the image)   interconnected by    1Ω    resistors as shown,\n  \nfind the resistance between points   **A**   and   **B**.\n\nSee also\n\n* (humor, nerd sniping)   xkcd.com cartoon (you can solve that for extra credits)\n* An article on how to calculate this and an implementation in Mathematica"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: C\n\n```\nmy $*TOLERANCE = 1e-12;\n\nsub set-boundary(@mesh,@p1,@p2) {\n    @mesh[ @p1[0] ; @p1[1] ] =  1;\n    @mesh[ @p2[0] ; @p2[1] ] = -1;\n}\n\nsub solve(@p1, @p2, Int \\w, Int \\h) {\n    my @d     = [0 xx w] xx h;\n    my @V     = [0 xx w] xx h;\n    my @fixed = [0 xx w] xx h;\n    set-boundary(@fixed,@p1,@p2);\n\n    loop {\n        set-boundary(@V,@p1,@p2);\n        my $diff = 0;\n        for (flat ^h X ^w) -> \\i, \\j {\n            my @neighbors = (@V[i-1;j], @V[i;j-1], @V[i+1;j], @V[i;j+1]).grep: *.defined;\n            @d[i;j] = my \\v = @V[i;j] - @neighbors.sum / @neighbors;\n            $diff += v × v unless @fixed[i;j];\n        }\n        last if $diff =~= 0;\n\n        for (flat ^h X ^w) -> \\i, \\j {\n            @V[i;j] -= @d[i;j];\n        }\n    }\n\n    my @current;\n    for (flat ^h X ^w) -> \\i, \\j {\n        @current[ @fixed[i;j]+1 ] += @d[i;j] × (?i + ?j + (i < h-1) + (j < w-1) );\n    }\n    (@current[2] - @current[0]) / 2\n}\n\nsay 2 / solve (1,1), (6,7), 10, 10;\n\n```\n\nOutput:\n\n```\n1.60899124172989\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate how to make the object respond (sensibly/usefully) to an invocation of a method on it that it does not support through its class definitions.\n\nNote that this is not the same as just invoking a defined method whose name is given dynamically; the method named at the point of invocation must not be defined.\n\nThis task is intended only for object systems that use a dynamic dispatch mechanism without static checking.\n\nRelated task\n\n* Send an unknown method call."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\n```\nclass Farragut {\n    method FALLBACK ($name, *@rest) {\n        say \"{self.WHAT.raku}: $name.tc() the @rest[], full speed ahead!\";\n    }\n}\n\nclass Sparrow is Farragut { }\n\nFarragut.damn: 'torpedoes';\nSparrow.hoist: <Jolly Roger mateys>;\n\n```\n\nOutput:\n\n```\nFarragut: Damn the torpedoes, full speed ahead!\nSparrow: Hoist the Jolly Roger mateys, full speed ahead!\n```\n\nFALLBACK will be called for any method that is not defined. Since any class inherits from Any, there will be plenty of already defined methods. Those which are not defined can also be used as L-Values by the magic of is rw.\n\n```\nclass L-Value { \n    our $.value = 10;\n    method FALLBACK($name, |c) is rw { $.value }\n}\n\nmy $l = L-Value.new;\nsay $l.any-odd-name; # 10\n$l.some-other-name = 42;\nsay $l.i-dont-know; # 42\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n**Summary:** Find and print the mentions of a given string in the recent chat logs from a chatroom. Only use your programming language's standard library.\n\n**Details:**\n\nThe Tcl Chatroom is an online chatroom. Its conversations are logged. It's useful to know if someone has mentioned you or your project in the chatroom recently. You can find this out by searching the chat logs. The logs are publicly available at http://tclers.tk/conferences/tcl/. One log file corresponds to the messages from one day in Germany's current time zone. Each chat log file has the name YYYY-MM-DD.tcl where YYYY is the year, MM is the month and DD the day. The logs store one message per line. The messages themselves are human-readable and their internal structure doesn't matter.\n\nRetrieve the chat logs from the last 10 days via HTTP. Find the lines that include a particular substring and print them in the following format:\n\n```\n<log file URL>\n------\n<matching line 1>\n<matching line 2>\n...\n<matching line N>\n------\n\n\n```\n\nThe substring will be given to your program as a command line argument.\n\nYou need to account for the possible time zone difference between the client running your program and the chat log writer on the server to not miss any mentions. (For example, if you generated the log file URLs naively based on the local date, you could miss mentions if it was already April 5th for the logger but only April 4th for the client.) What this means in practice is that you should either generate the URLs in the time zone Europe/Berlin or, if your language can not do that, add an extra day (today + 1) to the range of dates you check, but then make sure to not print parts of a \"not found\" page by accident if a log file doesn't exist yet.\n\nThe code should be contained in a single-file script, with no \"project\" or \"dependency\" file (e.g., no requirements.txt for Python). It should only use a given programming language's standard library to accomplish this task and not rely on the user having installed any third-party packages.\n\nIf your language does not have an HTTP client in the standard library, you can speak raw HTTP 1.0 to the server. If it can't parse command line arguments in a standalone script, read the string to look for from the standard input."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.04\n\nNo dependencies or third party libraries huh? How about no modules, no requires, no libraries, no imports at all. Implemented using a bare compiler, strictly with built-ins. (Which makes it kind-of verbose, but thems the trade-offs.)\n\n```\nmy $needle = @*ARGS.shift // '';\nmy @haystack;\n\n# 10 days before today, Zulu time\nmy $begin = DateTime.new(time).utc.earlier(:10days);\nsay \"         Executed at: \", DateTime.new(time).utc;\nsay \"Begin searching from: $begin\";\n\n# Today - 10 days through today\nfor $begin.Date .. DateTime.now.utc.Date -> $date {\n\n    # connect to server, use a raw socket\n    my $http = IO::Socket::INET.new(:host('tclers.tk'), :port(80));\n\n    # request file\n    $http.print: \"GET /conferences/tcl/{$date}.tcl HTTP/1.0\\n\\n\";\n\n    # retrieve file\n    my @page = $http.lines;\n\n    # remove header\n    @page.splice(0, 8);\n\n    # concatenate multi-line entries to a single line\n    while @page {\n        if @page[0].substr(0, 13) ~~ m/^'m '\\d\\d\\d\\d'-'\\d\\d'-'\\d\\d'T'/ {\n            @haystack.push: @page.shift;\n        }\n        else {\n            @haystack.tail ~= '␤' ~ @page.shift;\n        }\n    }\n\n    # close socket\n    $http.close;\n}\n\n# ignore times before 10 days ago\n@haystack.shift while @haystack[0].substr(2, 22) lt $begin.Str;\n\n# print the first and last line of the haystack\nsay \"First and last lines of the haystack:\";\n.say for |@haystack[0, *-1];\nsay \"Needle: \", $needle;\nsay  '-' x 79;\n\n# find and print needle lines\n.say if .contains( $needle ) for @haystack;\n\n```\n\nOutput:\n\nSample output using a needle of 'github.com'\n\n```\n         Executed at: 2017-05-05T02:13:55Z\nBegin searching from: 2017-04-25T02:13:55Z\nFirst and last lines of the haystack:\nm 2017-04-25T02:25:17Z ijchain {*** TakinOver leaves}\nm 2017-05-05T02:14:52Z {} {rmax has become available}\nNeedle: github.com\n-------------------------------------------------------------------------------\nm 2017-04-28T07:33:59Z ijchain {<Napier> https://github.com/Dash-OS/tcl-modules/blob/master/react-0.5.tm}\nm 2017-04-28T07:35:40Z ijchain {<Napier> https://github.com/Dash-OS/tcl-modules/blob/master/react/reducer-0.5.tm}\nm 2017-04-28T08:25:39Z ijchain {<Napier> https://github.com/Dash-OS/tcl-modules/blob/master/examples/react.md}\nm 2017-04-28T08:45:01Z ijchain {<Napier> https://github.com/Dash-OS/tcl-modules/blob/master/examples/react.md}\nm 2017-04-28T09:21:22Z ijchain {<Napier> decorators damnit! :-P https://github.com/Dash-OS/tcl-modules/blob/master/decorator-1.0.tm}\nm 2017-04-28T15:42:28Z jima https://gist.github.com/antirez/6ca04dd191bdb82aad9fb241013e88a8\nm 2017-04-28T16:20:22Z ijchain {<dbohdan> Look at what I've just made: https://github.com/dbohdan/ptjd}\nm 2017-04-29T05:48:13Z ijchain {<dbohdan> The brackets, rather than braces, are there because the [catch] is used for metaprogramming: https://github.com/dbohdan/ptjd/blob/c0a77ecfb34c619e30ec7c5e9f448879d41282e2/tests.tcl#L48}\nm 2017-04-29T14:49:08Z ijchain {<dbohdan> If you want CI for Windows builds, it should possible to set it up relatively easily with AppVeyor and the Git mirror at https://github.com/tcltk/tcl}\nm 2017-04-29T14:50:58Z ijchain {<dbohdan> Here's an example: https://github.com/dbohdan/picol/blob/trunk/appveyor.yml}\nm 2017-04-29T20:33:25Z ijchain {<Napier> https://github.com/pfultz2/Cloak/wiki/C-Preprocessor-tricks,-tips,-and-idioms}\nm 2017-04-30T08:20:05Z ijchain {<bairui> AvL_42: fwiw, I like and use Apprentice: https://github.com/romainl/Apprentice}\nm 2017-04-30T21:35:22Z ijchain {<Napier> https://github.com/Dash-OS/tcl-modules#cswitch-flags-----expr-script-}\nm 2017-05-01T04:16:00Z ijchain {<bairui> avl42: https://github.com/dahu/DiffLine  --  see if that helps with your next long-line vimdiff. DISCLAIMER: It *shouldn't* eat your hard-drive, but buyer beware, check the code and test it on unimportant stuff first.}\nm 2017-05-01T07:08:26Z ijchain {<dbohdan> Do take a look at this one, though: https://github.com/dbohdan/sqawk/blob/master/lib/tabulate.tcl#L74}\nm 2017-05-01T07:09:28Z ijchain {<dbohdan> And at https://github.com/dbohdan/jimhttp/blob/master/arguments.tcl}\nm 2017-05-01T08:14:05Z ijchain {<dbohdan> I've reimplemented part of tcltest recently (with pretty colors!), and I'm pretty with this solution: https://github.com/dbohdan/ptjd/blob/master/tests.tcl#L49}\nm 2017-05-03T14:57:24Z ijchain {<dbohdan> I think Tcl is okay to pretty good for compilery things if you already know how to do them. For instance, I found writing this tokenizer in Tcl a breeze: https://github.com/dbohdan/jimhttp/blob/master/json.tcl#L380}\nm 2017-05-04T16:19:55Z stu {rkeene, files Makefile.in, itzev and spoto.conf are spotoconf: https://github.com/aryler/Tclarc4random/}\nm 2017-05-04T20:26:28Z dgp https://github.com/flightaware/Tcl-bounties/issues/25\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow how to return more than one value from a function."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nEach function officially returns one value, but by returning a List or Seq you can transparently return a list of arbitrary (even infinite) size. The calling scope can destructure the list using assignment, if it so chooses:\n\n```\nsub addmul($a, $b) {\n    $a + $b, $a * $b\n}\n\nmy ($add, $mul) = addmul 3, 7;\n\n```\n\nIn this example, the variable $add now holds the number 10, and $mul the number 21."}]}
{"messages": [{"role": "user", "content": "Task\n\nTake a string and reverse it.\n\nFor example, \"asdf\" becomes \"fdsa\".\n\nExtra credit\n\nPreserve Unicode combining characters.\n\nFor example, \"as⃝df̅\" becomes \"f̅ds⃝a\", not \"̅fd⃝sa\".\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.08\n\nRaku handles graphemes, multi-byte characters and emoji correctly by default.\n\n```\nsay \"hello world\".flip;\nsay \"as⃝df̅\".flip;\nsay 'ℵΑΩ 駱駝道 🤔 🇸🇧 🇺🇸 🇬🇧‍ 👨‍👩‍👧‍👦🆗🗺'.flip;\n```\n\nOutput:\n\n```\ndlrow olleh\nf̅ds⃝a\n🗺🆗👨‍👩‍👧‍👦 🇬🇧‍ 🇺🇸 🇸🇧 🤔 道駝駱 ΩΑℵ\n```"}]}
{"messages": [{"role": "user", "content": "The task is to create a function that reverses the gender of the text of a string.\n\nThe function should take one arguments being a string to undergo the gender change.\n\nThe returned string should contain this initial string, with all references to be gender switched.\n\n```\nprint rev_gender(\"She was a soul stripper. She took my heart!\")\nHe was a soul stripper. He took my heart!\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\nMechanically, this task is trivial. Raku provides several flexible and powerful methods to wrangle text. Linguistically, this task is impossible (and laughable). Mappings are non-regular and in many cases, non-deterministic without semantic analysis of the content and context, which is **WAY** beyond what anyone is going to invest in a Rosettacode task. Whatever.\n\nFor extremely limited circumstances such as this example, this should suffice. Notice case matching and replication. Handles contractions, but ignores embedded matching text.\n\n```\nsay S:g:ii/«'she'»/he/ given \"She was a soul stripper. She took my heart! They say she's going to put me on a shelf.\";\n\n```\n\nOutput:\n\n```\nHe was a soul stripper. He took my heart! They say he's going to put me on a shelf.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n:   * Read an entire (input) file   (into memory or buffers).\n    * Display the lines/records of the entire file in reverse order.\n    * Show the results here, on this page.\n\nFor the input file, use the following **five** lines (records):\n\n```\n \"Diplomacy is the art of                                    ◄■■■■■■ starts in column 3.\n   saying  'Nice Doggy'                                      ◄■■■■■■ starts in column 5,\nuntil you can find a rock.\"                                  ◄■■■■■■ starts in column 2,\n                                                             ◄■■■■■■ (a blank line),\n                            --- Will Rodgers                 ◄■■■■■■ starts in column 30.\n\n```\n\nYou can (or may) assume there are no superfluous trailing blanks,   and that line four has one blank.\n\nAlso, don't include the rightmost informative comments   (◄■■■■■■),   as they are not meant to be part of the file.\n\nReference: Bash tac command"}, {"role": "assistant", "content": "Not going to bother testing with the task recommended file. It demonstrates nothing to do with file handling, record separators, memory conservation or anything useful. May as well just be \"Reverse this list\" for all the good it does.\n\n### Lots of assumptions\n\nSimplest thing that could possibly satisfy the extremely vague task description and completely glossing over all of the questions raised on the discussion page.\n\nASSUMPTIONS:\n\n* File is redirected into STDIN from command line.\n* Is a Unix or Windows format text file.\n* Is in UTF8 encoding or some subset thereof.\n* May hold entire file in memory.\n\n```\n.put for reverse lines\n\n```\n\n### Few assumptions\n\nProcesses a small (configurable) number of bytes at a time so file can be multi-terabyte and it will handle with ease. *Does* assume Latin 1 for reduced complexity.\n\nNo assumptions were made concerning line/record termination, full stop.\n\nRun the following to generate nul.txt. (digits 1 through 6 repeated 8 times with double null as record separators):\n\n```\n   raku -e'print join \"\\x00\\x00\", (1..6).map: * x 8' > nul.txt\n\n```\n\n```\nmy $input-record-separator = \"\\x00\\x00\";\n\nmy $fh = open(\"nul.txt\".IO, :r, :bin);\n$fh.seek(0, SeekFromEnd); # start at the end of the file\n\nmy $bytes = 5 min $fh.tell - 1; # read in file 5 bytes at a time (or whatever)\n\n$fh.seek(-$bytes, SeekFromCurrent);\n\nmy $buffer = $fh.read($bytes).decode('Latin1'); # assume Latin1 for reduced complexity\n\nloop {\n    my $seek = ($fh.tell < $bytes * 2) ?? -$fh.tell !! -$bytes * 2;\n    $fh.seek($seek, SeekFromCurrent);\n    $buffer = $buffer R~ $fh.read((-$seek - $bytes) max 0).decode('Latin1');\n    if $buffer.contains: $input-record-separator {\n        my @rest;\n        ($buffer, @rest) = $buffer.split: $input-record-separator;\n        .say for reverse @rest; # emit any full records that have been processed\n    }\n    last if $fh.tell < $bytes;\n}\n\nsay $buffer; # emit any remaining record\n\n```\n\nOutput:\n\n```\n66666666\n55555555\n44444444\n33333333\n22222222\n11111111\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nReverse the order of all tokens in each of a number of strings and display the result;   the order of characters within a token should not be modified.\n\nExample\n\n`Hey you, Bub!`    would be shown reversed as:    `Bub! you, Hey`\n\nTokens are any non-space characters separated by spaces (formally, white-space);   the visible punctuation form part of the word within which it is located and should not be modified.\n\nYou may assume that there are no significant non-visible characters in the input.   Multiple or superfluous spaces may be compressed into a single space.\n\nSome strings have no tokens, so an empty string   (or one just containing spaces)   would be the result.\n\n**Display** the strings in order   (1st, 2nd, 3rd, ···),   and one string per line.\n\n(You can consider the ten strings as ten lines, and the tokens as words.)\n\nInput data\n\n```\n             (ten lines within the box)\n line\n     ╔════════════════════════════════════════╗\n   1 ║  ---------- Ice and Fire ------------  ║\n   2 ║                                        ║  ◄─── a blank line here.\n   3 ║  fire, in end will world the say Some  ║\n   4 ║  ice. in say Some                      ║\n   5 ║  desire of tasted I've what From       ║\n   6 ║  fire. favor who those with hold I     ║\n   7 ║                                        ║  ◄─── a blank line here.\n   8 ║  ... elided paragraph last ...         ║\n   9 ║                                        ║  ◄─── a blank line here.\n  10 ║  Frost Robert -----------------------  ║\n     ╚════════════════════════════════════════╝\n\n```\n\nCf.\n\n* Phrase reversals"}, {"role": "assistant", "content": "(formerly Perl 6)\nWe'll read input from stdin\n\n```\nsay ~.words.reverse for lines\n\n```\n\nOutput:\n\n```\n------------ Fire and Ice ----------\n\nSome say the world will end in fire,\nSome say in ice.\nFrom what I've tasted of desire\nI hold with those who favor fire.\n\n... last paragraph elided ...\n\n----------------------- Robert Frost\n```"}]}
{"messages": [{"role": "user", "content": "A positive integer ***n*** is said to be a Rhonda number to base ***b*** if the product of the base ***b*** digits of ***n*** is equal to ***b*** times the sum of ***n'***s prime factors.\n\n*These numbers were named by Kevin Brown after an acquaintance of his whose residence number was 25662, a member of the base 10 numbers with this property.*\n\n**25662** is a Rhonda number to base-**10**. The prime factorization is **2 × 3 × 7 × 13 × 47**; the product of its base-**10** digits is equal to the base times the sum of its prime factors:\n\n2 × 5 × 6 × 6 × 2 = 720 = 10 × (2 + 3 + 7 + 13 + 47)\n\nRhonda numbers only exist in bases that are not a prime.\n\n*Rhonda numbers to base 10 **always** contain at least 1 digit 5 and **always** contain at least 1 even digit.*\n\nTask\n\n* For the non-prime bases ***b*** from **2** through **16** , find and display here, on this page, at least the first **10** **Rhonda numbers** to base ***b***. Display the found numbers at least in base **10**.\n\nStretch\n\n* Extend out to base **36**.\n\nSee also\n\n* Wolfram Mathworld - Rhonda numbers * Numbers Aplenty - Rhonda numbers * OEIS:A100968 - Integers n that are Rhonda numbers to base 4 * OEIS:A100969 - Integers n that are Rhonda numbers to base 6 * OEIS:A100970 - Integers n that are Rhonda numbers to base 8 * OEIS:A100973 - Integers n that are Rhonda numbers to base 9 * OEIS:A099542 - Rhonda numbers to base 10 * OEIS:A100971 - Integers n that are Rhonda numbers to base 12 * OEIS:A100972 - Integers n that are Rhonda numbers to base 14 * OEIS:A100974 - Integers n that are Rhonda numbers to base 15 * OEIS:A100975 - Integers n that are Rhonda numbers to base 16\n\n* OEIS:A255735 - Integers n that are Rhonda numbers to base 18 * OEIS:A255732 - Rhonda numbers in vigesimal number system (base 20) * OEIS:A255736 - Integers that are Rhonda numbers to base 30\n\n* Related Task: Smith numbers"}, {"role": "assistant", "content": "Find and show the first 15 so as to display the namesake Rhonda number 25662.\n\n```\nuse Prime::Factor;\n\nmy @factor-sum;\n\n@factor-sum[1000000] = 42; # Sink a large index to make access thread safe \n\nsub rhonda ($base) {\n    (1..∞).hyper.map: { $_ if $base * (@factor-sum[$_] //= .&prime-factors.sum) == [×] .polymod($base xx *) }\n}\n\nfor (flat 2..16, 17..36).grep: { !.&is-prime }  -> $b {\n    put \"\\nFirst 15 Rhonda numbers to base $b:\";\n    my @rhonda = rhonda($b)[^15];\n    my $ch = @rhonda[*-1].chars max @rhonda[*-1].base($b).chars;\n    put \"In base 10: \" ~ @rhonda».fmt(\"%{$ch}s\").join: ', ';\n    put $b.fmt(\"In base %2d: \") ~ @rhonda».base($b)».fmt(\"%{$ch}s\").join: ', ';\n}\n\n```\n\nOutput:\n\n```\nFirst 15 Rhonda numbers to base 4:\nIn base 10:      10206,      11935,      12150,      16031,      45030,      94185,     113022,     114415,     191149,     244713,     259753,     374782,     392121,     503773,     649902\nIn base  4:    2133132,    2322133,    2331312,    3322133,   22333212,  112333221,  123211332,  123323233,  232222231,  323233221,  333122221, 1123133332, 1133232321, 1322333131, 2132222232\n\nFirst 15 Rhonda numbers to base 6:\nIn base 10:     855,    1029,    3813,    5577,    7040,    7304,   15104,   19136,   35350,   36992,   41031,   42009,   60368,   65536,   67821\nIn base  6:    3543,    4433,   25353,   41453,   52332,   53452,  153532,  224332,  431354,  443132,  513543,  522253, 1143252, 1223224, 1241553\n\nFirst 15 Rhonda numbers to base 8:\nIn base 10:   1836,   6318,   6622,  10530,  14500,  14739,  17655,  18550,  25398,  25956,  30562,  39215,  39325,  50875,  51429\nIn base  8:   3454,  14256,  14736,  24442,  34244,  34623,  42367,  44166,  61466,  62544,  73542, 114457, 114635, 143273, 144345\n\nFirst 15 Rhonda numbers to base 9:\nIn base 10:  15540,  21054,  25331,  44360,  44660,  44733,  47652,  50560,  54944,  76857,  77142,  83334,  83694,  96448,  97944\nIn base  9:  23276,  31783,  37665,  66758,  67232,  67323,  72326,  76317,  83328, 126376, 126733, 136273, 136723, 156264, 158316\n\nFirst 15 Rhonda numbers to base 10:\nIn base 10:  1568,  2835,  4752,  5265,  5439,  5664,  5824,  5832,  8526, 12985, 15625, 15698, 19435, 25284, 25662\nIn base 10:  1568,  2835,  4752,  5265,  5439,  5664,  5824,  5832,  8526, 12985, 15625, 15698, 19435, 25284, 25662\n\nFirst 15 Rhonda numbers to base 12:\nIn base 10:   560,   800,  3993,  4425,  4602,  4888,  7315,  8296,  9315, 11849, 12028, 13034, 14828, 15052, 16264\nIn base 12:   3A8,   568,  2389,  2689,  27B6,  29B4,  4297,  4974,  5483,  6A35,  6B64,  7662,  86B8,  8864,  94B4\n\nFirst 15 Rhonda numbers to base 14:\nIn base 10:  11475,  18655,  20565,  29631,  31725,  45387,  58404,  58667,  59950,  63945,  67525,  68904,  91245,  99603, 125543\nIn base 14:   4279,   6B27,   76CD,   AB27,   B7C1,  1277D,  173DA,  17547,  17BC2,  19437,  1A873,  1B17A,  25377,  28427,  33A75\n\nFirst 15 Rhonda numbers to base 15:\nIn base 10:  2392,  2472, 11468, 15873, 17424, 18126, 19152, 20079, 24388, 30758, 31150, 33004, 33550, 37925, 39483\nIn base 15:   A97,   AEC,  35E8,  4A83,  5269,  5586,  5A1C,  5E39,  735D,  91A8,  936A,  9BA4,  9E1A,  B385,  BA73\n\nFirst 15 Rhonda numbers to base 16:\nIn base 10:  1000,  1134,  6776, 15912, 19624, 20043, 20355, 23946, 26296, 29070, 31906, 32292, 34236, 34521, 36465\nIn base 16:   3E8,   46E,  1A78,  3E28,  4CA8,  4E4B,  4F83,  5D8A,  66B8,  718E,  7CA2,  7E24,  85BC,  86D9,  8E71\n\nFirst 15 Rhonda numbers to base 18:\nIn base 10:  1470,  3000,  8918, 17025, 19402, 20650, 21120, 22156, 26522, 36549, 38354, 43281, 46035, 48768, 54229\nIn base 18:   49C,   94C,  1998,  2G9F,  35FG,  39D4,  3B36,  3E6G,  49F8,  64E9,  6A6E,  77A9,  7G19,  8696,  956D\n\nFirst 15 Rhonda numbers to base 20:\nIn base 10:  1815, 11050, 15295, 21165, 22165, 30702, 34510, 34645, 42292, 44165, 52059, 53416, 65945, 78430, 80712\nIn base 20:   4AF,  17CA,  1I4F,  2CI5,  2F85,  3GF2,  465A,  46C5,  55EC,  5A85,  6A2J,  6DAG,  84H5,  9G1A,  A1FC\n\nFirst 15 Rhonda numbers to base 21:\nIn base 10:  1632,  5390,  8512, 12992, 15678, 25038, 29412, 34017, 39552, 48895, 49147, 61376, 85078, 89590, 91798\nIn base 21:   3EF,   C4E,   J67,  189E,  1EBC,  2EG6,  33EC,  3E2I,  45E9,  55I7,  5697,  6D3E,  93J7,  9E34,  9J37\n\nFirst 15 Rhonda numbers to base 22:\nIn base 10:   2695,   4128,   7865,  28800,  31710,  37030,  71875,  74306, 117760, 117895, 121626, 126002, 131427, 175065, 192753\nIn base 22:    5CB,    8BE,    G5B,   2FB2,   2LB8,   3AB4,   6GB1,   6LBC,   B16G,   B1CJ,   B96A,   BI78,   C7BL,   G9FB,   I25B\n\nFirst 15 Rhonda numbers to base 24:\nIn base 10:  2080,  2709,  3976,  5628,  5656,  7144,  8296,  9030, 10094, 17612, 20559, 24616, 26224, 29106, 31458\nIn base 24:   3EG,   4GL,   6LG,   9IC,   9JG,   C9G,   E9G,   FG6,   HCE,  16DK,  1BGF,  1IHG,  1LCG,  22CI,  26EI\n\nFirst 15 Rhonda numbers to base 25:\nIn base 10:   6764,   9633,  13260,  22022,  53382,  57640,  66015,  69006,  97014, 140130, 142880, 144235, 159724, 162565, 165504\nIn base 25:    AKE,    FA8,    L5A,   1A5M,   3AA7,   3H5F,   45FF,   4AA6,   655E,   8O55,   93F5,   95JA,   A5DO,   AA2F,   AEK4\n\nFirst 15 Rhonda numbers to base 26:\nIn base 10:   7788,   9322,   9374,  11160,  22165,  27885,  34905,  44785,  47385,  49257,  62517,  72709,  74217, 108745, 132302\nIn base 26:    BDE,    DKE,    DME,    GD6,   16KD,   1F6D,   1PGD,   2E6D,   2I2D,   2KMD,   3ECD,   43ED,   45KD,   64MD,   7DIE\n\nFirst 15 Rhonda numbers to base 27:\nIn base 10:  4797, 11844, 12078, 13200, 14841, 17750, 24320, 26883, 27477, 46455, 52750, 58581, 61009, 61446, 61500\nIn base 27:   6FI,   G6I,   GF9,   I2O,   K9I,   O9B,  169K,  19NI,  1AII,  29JF,  2I9J,  2Q9I,  32IG,  337L,  339L\n\nFirst 15 Rhonda numbers to base 28:\nIn base 10:  3094,  5808,  5832,  7462, 11160, 13671, 27270, 28194, 28638, 39375, 39550, 49500, 50862, 52338, 52938\nIn base 28:   3QE,   7BC,   7C8,   9EE,   E6G,   HC7,  16LQ,  17QQ,  18EM,  1M67,  1MCE,  273O,  28OE,  2AL6,  2BEI\n\nFirst 15 Rhonda numbers to base 30:\nIn base 10:  3024,  3168,  5115,  5346,  5950,  6762,  7750,  7956,  8470,  9476,  9576,  9849, 10360, 11495, 13035\nIn base 30:   3AO,   3FI,   5KF,   5S6,   6IA,   7FC,   8IA,   8P6,   9CA,   AFQ,   AJ6,   AS9,   BFA,   CN5,   EEF\n\nFirst 15 Rhonda numbers to base 32:\nIn base 10:  1944,  3600, 13520, 15876, 16732, 16849, 25410, 25752, 28951, 47472, 49610, 50968, 61596, 64904, 74005\nIn base 32:   1SO,   3GG,   D6G,   FG4,   GAS,   GEH,   OQ2,   P4O,   S8N,  1EBG,  1GEA,  1HOO,  1S4S,  1VC8,  288L\n\nFirst 15 Rhonda numbers to base 33:\nIn base 10:    756,   7040,   7568,  13826,  24930,  30613,  59345,  63555,  64372, 131427, 227840, 264044, 313709, 336385, 344858\nIn base 33:     MU,    6FB,    6VB,    CMW,    MTF,    S3M,   1LGB,   1PBU,   1Q3M,   3LML,   6B78,   7BFB,   8O2B,   9BTG,   9JM8\n\nFirst 15 Rhonda numbers to base 34:\nIn base 10:   5661,  14161,  15620,  16473,  22185,  37145, 125579, 134692, 135405, 138472, 140369, 177086, 250665, 255552, 295614\nIn base 34:    4UH,    C8H,    DHE,    E8H,    J6H,    W4H,   36LH,   3EHI,   3F4H,   3HQO,   3JEH,   4H6E,   6CSH,   6H28,   7HOI\n\nFirst 15 Rhonda numbers to base 35:\nIn base 10:   8232,   9476,   9633,  18634,  30954,  41905,  52215,  52440,  56889,  61992,  62146,  66339,  98260, 102180, 103305\nIn base 35:    6P7,    7PQ,    7U8,    F7E,    P9E,    Y7A,   17LU,   17SA,   1BFE,   1FL7,   1FPL,   1J5E,   2A7F,   2DEF,   2EBK\n\nFirst 15 Rhonda numbers to base 36:\nIn base 10:  1000,  4800,  5670,  8190, 10998, 12412, 13300, 15750, 16821, 23016, 51612, 52734, 67744, 70929, 75030\nIn base 36:    RS,   3PC,   4DI,   6BI,   8HI,   9KS,   A9G,   C5I,   CZ9,   HRC,  13TO,  14OU,  1G9S,  1IQ9,  1LW6\n```"}]}
{"messages": [{"role": "user", "content": "**Rice coding** is a variant of Golomb coding where the parameter is a power of two. This makes it easier to encode the remainder of the euclidean division.\n\nImplement Rice coding in your programming language and verify that you can consistently encode and decode a list of examples (for instance numbers from 0 to 10 or something).\n\nRice coding is initially meant to encode natural numbers, but since relative numbers are countable, it is fairly easy to modify Rice coding to encode them too. You can do that for extra credit."}, {"role": "assistant", "content": "```\npackage Rice {\n\n  our sub encode(Int $n, UInt :$k = 2) {\n    my $d = 2**$k;\n    my $q = $n div $d;\n    my $b = sign(1 + sign($q));\n    my $m = abs($q) + $b;\n    flat\n      $b xx $m, 1 - $b,\n      ($n mod $d).polymod(2 xx $k - 1).reverse\n  }\n\n  our sub decode(@bits is copy, UInt :$k = 2) {\n    my $d = 2**$k;\n    my $b = @bits.shift;\n    my $m = 1;\n    $m++ while @bits and @bits.shift == $b;\n    my $q = $b ?? $m - 1 !! -$m;\n    $q*$d + @bits.reduce(2 * * + *);\n  }\n\n}\n\nCHECK {\n  use Test;\n  constant N = 100;\n  plan 2*N + 1;\n  is $_, Rice::decode Rice::encode $_ for -N..N;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Riordan numbers show up in several places in set theory. They are closely related to Motzkin numbers, and may be used to derive them.\n\nRiordan numbers comprise the sequence **a** where:\n\n```\n   a(0) = 1, a(1) = 0, for subsequent terms, a(n) = (n-1)*(2*a(n-1) + 3*a(n-2))/(n+1)\n\n```\n\nThere are other generating functions, and you are free to use one most convenient for your language.\n\nTask\n\n* Find and display the first 32 Riordan numbers.\n\nStretch\n\n* Find and display the **digit count** of the 1,000th Riordan number.\n* Find and display the **digit count** of the 10,000th Riordan number.\n\nSee also\n\n* OEIS:A005043 - Riordan numbers"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\n\nmy @riordan = 1, 0, { state $n = 1; (++$n - 1) / ($n + 1) × (3 × $^a + 2 × $^b) } … *;\n\nmy $upto = 32;\nsay \"First {$upto.&cardinal} Riordan numbers:\\n\" ~ @riordan[^$upto]».&comma».fmt(\"%17s\").batch(4).join(\"\\n\") ~ \"\\n\";\n\nsub abr ($_) { .chars < 41 ?? $_ !! .substr(0,20) ~ '..' ~ .substr(*-20) ~ \" ({.chars} digits)\" }\n\nsay \"The {.Int.&ordinal}: \" ~ abr @riordan[$_ - 1] for 1e3, 1e4\n\n```\n\nOutput:\n\n```\nFirst thirty-two Riordan numbers:\n                1                 0                 1                 1\n                3                 6                15                36\n               91               232               603             1,585\n            4,213            11,298            30,537            83,097\n          227,475           625,992         1,730,787         4,805,595\n       13,393,689        37,458,330       105,089,229       295,673,994\n      834,086,421     2,358,641,376     6,684,761,125    18,985,057,351\n   54,022,715,451   154,000,562,758   439,742,222,071 1,257,643,249,140\n\nThe one thousandth: 51077756867821111314..79942013897484633052 (472 digits)\nThe ten thousandth: 19927418577260688844..71395322020211157137 (4765 digits)\n```"}]}
{"messages": [{"role": "user", "content": "**RIPEMD-160** is another hash function; it computes a 160-bit message digest.\n\nThere is a RIPEMD-160 home page, with test vectors and pseudocode for RIPEMD-160.\nFor padding the message, RIPEMD-160 acts like MD4 (RFC 1320).\n\nFind the RIPEMD-160 message digest of a string of octets.\nUse the ASCII encoded string “Rosetta Code”.\nYou may either call an RIPEMD-160 library, or implement RIPEMD-160 in your language."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# https://github.com/grondilu/libdigest-raku/blob/master/lib/Digest/RIPEMD.rakumod\n\nsay rmd160 \"Rosetta Code\";\n\n=begin CREDITS\nCrypto-JS v2.0.0\nhttp:#code.google.com/p/crypto-js/\nCopyright (c) 2009, Jeff Mott. All rights reserved.\n=end CREDITS\n\nproto rmd160($) returns Blob is export {*}\nmulti rmd160(Str $str) { samewith $str.encode }\n \nmulti rmd160(Blob $data) {\n\n  sub rotl(uint32 $n, $b) { $n +< $b +| $n +> (32 - $b) }\n\n  blob8.new:\n    map |*.polymod(256 xx 3),\n    |reduce\n      -> blob32 $h, @words {\n        blob32.new: [Z+] map {$_[[^5].rotate(++$)]}, $h, |await \n          map -> [&f, $r, @K, $s] {\n            start {\n              reduce -> $A, $j {\n                $A[4],\n                rotl(\n                  ($A[0] + (BEGIN [\n                    * +^ * +^ *,\n                    { $^x +& $^y +| +^$x +& $^z },\n                    (* +| +^*) +^ *,\n                    { $^x +& $^z +| $^y +& +^$^z },\n                    { $^x +^ ($^y +| +^$^z) }\n                  ])[&f($j) div 16](|$A[1..3])\n                  + @words[$r[$j]] + @K[$j]) mod 2**32,\n                  $s[$j]\n                ) + $A[4],\n                $A[1],\n                rotl($A[2], 10),\n                $A[3]\n              }, $h, |^80\n            }\n          },\n          BEGIN Array.new:\n            map -> [ &a,$b,@c,$d ] {\n              [&a,.($b),(flat @c »xx» 16),.($d)] given *.comb».parse-base(16)\n            },\n            (  +*,\n              \"0123456789ABCDEF74D1A6F3C0952EB83AE49F812706DB5C19BA08C4D37FE56240597C2AE138B6FD\",\n              <0x00000000 0x5a827999 0x6ed9eba1 0x8f1bbcdc 0xa953fd4e>,\n              \"BEFC5879BDEF6798768DB97F7CF9B7DCBD67E9DFE8D65C75BCEFEF989E56865C9F5B68DC5CDEB856\"\n            ),\n            (79-*,\n              \"5E7092B4D6F81A3C6B370D5AEF8C4912F5137E69B8C2A04D86413BF05C2D97AECFA4158762DE039B\",\n              <0x50a28be6 0x5c4dd124 0x6d703ef3 0x7a6d76e9 0x00000000>,\n              \"899BDFF5778BEEC69DF7C89B77C76FDB97FB866ECD5EDD75F58BEE6E69C9C5F885C9C5E68D65FDBB\"\n            )\n          ; \n      },\n      (BEGIN blob32.new: 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0),\n      |blob32.new(\n        blob8.new(\n          $data.list,\n          0x80,\n          0 xx (-($data.elems + 1 + 8) % 64),\n          |(8 * $data).polymod: 256 xx 7\n        ).rotor(4).map: { :256[@^x.reverse] }\n      ).rotor(16);\n}\n\n```\n\nOutput:\n\n```\nBuf:0x<b3 be 15 98 60 84 2c eb aa 71 74 c8 ff f0 aa 9e 50 a5 19 9f>\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Robots\\_(1984\\_video\\_game). The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThe task is to implement a clone of Ken Arnold's turn-based game Robots.\n\nSimple game where its only objective is to escape from a number of robots, which have been programmed to kill the player."}, {"role": "assistant", "content": "(formerly Perl 6)\nThe bots single-mindedly chase you, taking the shortest path, ignoring obstacles. Use arrow keys to navigate your character(╂) around the board. Avoid bots(☗) and hazards(☢). \"Kill\" bots by causing them to crash into hazards or other bots. A dead bot creates another hazard. If you eliminate all of the bots on the board, another wave will spawn in random positions. If you touch a hazard or are touched by a bot, you die(†).\n\n```\nuse Term::termios;\n\nconstant $saved   = Term::termios.new(fd => 1).getattr;\nconstant $termios = Term::termios.new(fd => 1).getattr;\n# raw mode interferes with carriage returns, so\n# set flags needed to emulate it manually\n$termios.unset_iflags(<BRKINT ICRNL ISTRIP IXON>);\n$termios.unset_lflags(< ECHO ICANON IEXTEN ISIG>);\n$termios.setattr(:DRAIN);\n\n# reset terminal to original settings and clean up on exit\nEND { $saved.setattr(:NOW);  print \"\\e[?25h\\n\" }\n\nprint \"\\e[?25l\"; # hide cursor\n\nmy %dir = (\n   \"\\e[A\" => 'up',\n   \"\\e[B\" => 'down',\n   \"\\e[C\" => 'right',\n   \"\\e[D\" => 'left',\n);\n\nmy $x = 100; # nominal \"board\" width\nmy $y = 40;  # nominal \"board\" height\n\nmy $human = \"\\e[0;92m╂\\e[0m\"; # various\nmy $robot = \"\\e[0;91m☗\\e[0m\"; # entity\nmy $block = \"\\e[0;93m☢\\e[0m\"; # sprite\nmy $dead  = \"\\e[1;37m†\\e[0m\"; # characters\nmy $wall  = \"\\e[1;96m█\\e[0m\";\nmy $blank = ' ';\n\nmy $numbots = 10; # number of bots in each round\n\n# blank playing field\nmy @scr = flat $wall xx $x, ($wall, $blank xx $x - 2, $wall) xx $y - 2, $wall xx $x;\n\n# put player on board\nmy $me;\nloop {\n    $me = ($x+2 .. ($x - 1 ) * $y).roll;\n    last if @scr[$me] eq $blank;\n}\n@scr[$me] = $human;\n\n# Put an assortment of hazards on board\nfor ^20 {\n    my $s = (^$x*$y).pick;\n    if @scr[$s] eq $blank { @scr[$s] = $block } else { redo }\n}\n\nmy $info  = 0;\nmy $score = 0;\n\nnewbots(); # populate board with a fresh wave of bots\n\nloop {\n    print \"\\e[H\\e[J\";\n    print \"\\e[H\";\n    print join \"\\n\", @scr.rotor($x)».join;\n    print \"\\nSurvived \" , $info , ' bots';\n\n    # Read up to 4 bytes from keyboard buffer.\n    # Page navigation keys are 3-4 bytes each.\n    # Specifically, arrow keys are 3.\n    my $key = $*IN.read(4).decode;\n\n    move %dir{$key} if so %dir{$key};\n    movebots();\n    last if $key eq 'q'; # (q)uit\n}\n\nproto sub move (|) {*};\n\nmulti move ('up') {\n    if @scr[$me - $x] ne $wall {\n        expire() if @scr[$me - $x] ne $blank;\n        @scr[$me] = $blank;\n        $me = $me - $x;\n        @scr[$me] = $human;\n    }\n}\nmulti move ('down') {\n    if @scr[$me + $x] ne $wall {\n        expire() if @scr[$me + $x] ne $blank;\n        @scr[$me] = $blank;\n        $me = $me + $x;\n        @scr[$me] = $human;\n    }\n}\nmulti move ('left') {\n   if @scr[$me - 1] ne $wall {\n        expire() if @scr[$me - 1] ne $blank;\n        @scr[$me] = $blank;\n        $me = $me - 1;\n        @scr[$me] = $human;\n    }\n}\n\nmulti move ('right') {\n    if @scr[$me + 1] ne $wall {\n        expire() if @scr[$me + 1] ne $blank;\n        @scr[$me] = $blank;\n        $me = $me + 1;\n        @scr[$me] = $human;\n    }\n}\n\nsub newbots {\n    for ^$numbots {\n        my $s = (^$x*$y).pick;\n        if @scr[$s] eq $blank {\n            @scr[$s] = $robot;\n        } else {\n            redo\n        }\n    }\n}\n\nsub movebots {\n    my $mx = $me % $x;\n    my $my = $me div $x;\n    my @bots = @scr.grep: * eq $robot, :k;\n    for @bots -> $b {\n        my $bx = $b % $x;\n        my $by = $b div $x ;\n        if ($mx - $bx).abs < ($my - $by).abs {\n            $by += ($my - $by) < 0 ?? -1 !! 1;\n        } else {\n            $bx += ($mx - $bx) < 0 ?? -1 !! 1;\n        }\n        my $n = $by * $x + $bx;\n        if @scr[$n] eq $robot {\n            @scr[$b] = @scr[$n] = $block;\n        } elsif @scr[$n] eq $block {\n            @scr[$b] = $block;\n        } elsif $n == $me {\n            expire()\n        } else {\n            @scr[$b] = $blank;\n            @scr[$n] = $robot;\n        }\n    }\n    unless +@bots > 0 {\n        newbots();\n        $score += $numbots;\n    }\n    $info = $score + $numbots - @scr.grep: * eq $robot;\n}\n\nsub expire {\n    @scr[$me] = $dead;\n    print \"\\e[H\\e[J\";\n    print \"\\e[H\";\n    print join \"\\n\", @scr.rotor($x)».join;\n    print \"\\nSurvived \" , $info , ' bots, but succumbed in the end.';\n    exit\n}\n\n```\n\nSample game:\n\n```\n████████████████████████████████████████████████████████████████████████████████████████████████████\n█                                                                                                  █\n█                                               ☗                                                  █\n█                                 ☢☢                                                               █\n█                             †    ☢       ☢                                  ☢                    █\n█          ☢                  ☢☢☢☢☢☢                                                               █\n█       ☢☢☢☢☢☢☢                ☢☢☢☢☢☢☢                                                             █\n█               ☢☢☢☢           ☢  ☢☢                              ☢☢☢                              █\n█             ☢☢☢☢☢               ☢☢                                                               █\n█            ☢☢☢☢☢☢☢☢             ☢☢☢                        ☢☢☢                                   █\n█             ☢ ☢☢☢☢                ☢                                                              █\n█              ☢☢☢                                                                                 █\n█                                              ☗                                                   █\n█               ☢☢☢ ☢                                                                              █\n█               ☢☢☢☢☢☢                                                                             █\n█                ☢☢☢☢☢☢☢☢                                                                          █\n█               ☢☢☢☢☢☢ ☢☢                                                                          █\n█               ☢☢☢☢☢☢☢☢                   ☗                                                       █\n█               ☢☢☢☢☢☢☢      ☢                                 ☢                                   █\n█                 ☢☢ ☢       ☢☢                                                                    █\n█                  ☢ ☢       ☢         ☢☢                                                          █\n█                 ☢☢                   ☢                                                           █\n█           ☢                          ☢                                                           █\n█           ☢                                                                                      █\n█           ☢                                                                                      █\n█                                                                                                  █\n█                                                                        ☢                      ☢  █\n█                                                                                                  █\n█                                                                                                  █\n█                                                                                                  █\n█                                                                                             ☢    █\n█                                                                             ☢             ☢      █\n█                                                        ☢                                         █\n█                                                                                                  █\n█                                                                                                  █\n█                                           ☢☢                                                     █\n█                                           ☢                                                      █\n█                                                                                                  █\n█            ☢☢                                                                                    █\n████████████████████████████████████████████████████████████████████████████████████████████████████\nSurvived 117 bots, but succumbed in the end.\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement the classic children's game Rock-paper-scissors, as well as a simple predictive   **AI**   (artificial intelligence)   player.\n\nRock Paper Scissors is a two player game.\n\nEach player chooses one of rock, paper or scissors, without knowing the other player's choice.\n\nThe winner is decided by a set of rules:\n\n:   :   :   * Rock beats scissors\n            * Scissors beat paper\n            * Paper beats rock\n\nIf both players choose the same thing, there is no winner for that round.\n\nFor this task, the computer will be one of the players.\n\nThe operator will select Rock, Paper or Scissors and the computer will keep a record of the choice frequency, and use that information to make a weighted random choice in an attempt to defeat its opponent.\n\nExtra credit\n\nSupport additional choices   additional weapons."}, {"role": "assistant", "content": "(formerly Perl 6)\nThis is slightly more complicated than it could be; it is a general case framework with input filtering. It weights the computers choices based on your previous choices. Type in at least the first two characters of your choice, or just hit enter to quit. Customize it by supplying your own %vs options/outcomes.\n\nHere is standard Rock-Paper-Scissors.\n\n```\nmy %vs = (\n    options => [<Rock Paper Scissors>],\n    ro => {\n        ro => [ 2, ''                        ],\n        pa => [ 1, 'Paper covers Rock: '     ],\n        sc => [ 0, 'Rock smashes Scissors: ' ]\n    },\n    pa => {\n        ro => [ 0, 'Paper covers Rock: '    ],\n        pa => [ 2, ''                       ],\n        sc => [ 1, 'Scissors cut Paper: '   ]\n    },\n    sc => {\n        ro => [ 1, 'Rock smashes Scissors: '],\n        pa => [ 0, 'Scissors cut Paper: '   ],\n        sc => [ 2, ''                       ]\n    }\n);\n\nmy %choices = %vs<options>.map({; $_.substr(0,2).lc => $_ });\nmy $keys    = %choices.keys.join('|');\nmy $prompt  = %vs<options>.map({$_.subst(/(\\w\\w)/, -> $/ {\"[$0]\"})}).join(' ')~\"? \";\nmy %weight  = %choices.keys »=>» 1;\n\nmy @stats = 0,0,0;\nmy $round;\n\nwhile my $player = (prompt \"Round {++$round}: \" ~ $prompt).lc {\n    $player.=substr(0,2);\n    say 'Invalid choice, try again.' and $round-- and next\n      unless $player.chars == 2 and $player ~~ /<$keys>/;\n    my $computer = (flat %weight.keys.map( { $_ xx %weight{$_} } )).pick;\n    %weight{$_.key}++ for %vs{$player}.grep( { $_.value[0] == 1 } );\n    my $result = %vs{$player}{$computer}[0];\n    @stats[$result]++;\n    say \"You chose %choices{$player},  Computer chose %choices{$computer}.\";\n    print %vs{$player}{$computer}[1];\n    print ( 'You win!', 'You Lose!','Tie.' )[$result];\n    say \" - (W:{@stats[0]} L:{@stats[1]} T:{@stats[2]})\\n\",\n};\n\n```\n\nExample output:\n\n```\nRound 1: [Ro]ck [Pa]per [Sc]issors? ro\nYou chose Rock,  Computer chose Paper.\nPaper covers Rock: You Lose! - (W:0 L:1 T:0)\n\nRound 2: [Ro]ck [Pa]per [Sc]issors? pa\nYou chose Paper,  Computer chose Scissors.\nScissors cut Paper: You Lose! - (W:0 L:2 T:0)\n\nRound 3: [Ro]ck [Pa]per [Sc]issors? pa\nYou chose Paper,  Computer chose Scissors.\nScissors cut Paper: You Lose! - (W:0 L:3 T:0)\n\nRound 4: [Ro]ck [Pa]per [Sc]issors? ro\nYou chose Rock,  Computer chose Rock.\nTie. - (W:0 L:3 T:1)\n\nRound 5: [Ro]ck [Pa]per [Sc]issors? sc\nYou chose Scissors,  Computer chose Scissors.\nTie. - (W:0 L:3 T:2)\n...\n```\n\nHere is example output from the same code only with a different %vs data structure implementing Rock-Paper-Scissors-Lizard-Spock.\n\n```\nmy %vs = (\n    options => [<Rock Paper Scissors Lizard Spock>],\n    ro => {\n        ro => [ 2, ''                            ],\n        pa => [ 1, 'Paper covers Rock: '         ],\n        sc => [ 0, 'Rock smashes Scissors: '     ],\n        li => [ 0, 'Rock crushes Lizard: '       ],\n        sp => [ 1, 'Spock vaporizes Rock: '      ]\n    },\n    pa => {\n        ro => [ 0, 'Paper covers Rock: '         ],\n        pa => [ 2, ''                            ],\n        sc => [ 1, 'Scissors cut Paper: '        ],\n        li => [ 1, 'Lizard eats Paper: '         ],\n        sp => [ 0, 'Paper disproves Spock: '     ]\n    },\n    sc => {\n        ro => [ 1, 'Rock smashes Scissors: '     ],\n        pa => [ 0, 'Scissors cut Paper: '        ],\n        sc => [ 2, ''                            ],\n        li => [ 0, 'Scissors decapitate Lizard: '],\n        sp => [ 1, 'Spock smashes Scissors: '    ]\n    },\n    li => {\n        ro => [ 1, 'Rock crushes Lizard: '       ],\n        pa => [ 0, 'Lizard eats Paper: '         ],\n        sc => [ 1, 'Scissors decapitate Lizard: '],\n        li => [ 2, ''                            ],\n        sp => [ 0, 'Lizard poisons Spock: '      ]\n    },\n    sp => {\n        ro => [ 0, 'Spock vaporizes Rock: '      ],\n        pa => [ 1, 'Paper disproves Spock: '     ],\n        sc => [ 0, 'Spock smashes Scissors: '    ],\n        li => [ 1, 'Lizard poisons Spock: '      ],\n        sp => [ 2, ''                            ]\n    }\n);\n\n```\n\n```\nRound 1: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? li\nYou chose Lizard,  Computer chose Scissors.\nScissors decapitate Lizard: You Lose! - (W:0 L:1 T:0)\n\nRound 2: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? sp\nYou chose Spock,  Computer chose Paper.\nPaper disproves Spock: You Lose! - (W:0 L:2 T:0)\n\nRound 3: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? ro\nYou chose Rock,  Computer chose Lizard.\nRock crushes Lizard: You Win! - (W:1 L:2 T:0)\n\nRound 4: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? ro\nYou chose Rock,  Computer chose Scissors.\nRock smashes Scissors: You win! - (W:2 L:2 T:0)\n\nRound 5: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? li\nYou chose Lizard,  Computer chose Paper.\nLizard eats Paper: You win! - (W:3 L:2 T:0)\n...\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nRotate a point about some axis by some angle using Rodrigues' rotation formula.\n\nReference\n\n* Wikipedia: Rodrigues' rotation formula"}, {"role": "assistant", "content": "```\nsub infix:<⋅> { [+] @^a »×« @^b }\nsub norm      (@v) { sqrt @v⋅@v }\nsub normalize (@v) { @v X/ @v.&norm }\nsub getAngle  (@v1,@v2) { 180/π × acos (@v1⋅@v2) / (@v1.&norm × @v2.&norm) }\n\nsub crossProduct ( @v1, @v2 ) {\n    my \\a = <1 2 0>; my \\b = <2 0 1>;\n    (@v1[a] »×« @v2[b]) »-« (@v1[b] »×« @v2[a])\n}\n\nsub aRotate ( @p, @v, $a ) {\n    my \\ca = cos $a/180×π;\n    my \\sa = sin $a/180×π;\n    my \\t = 1 - ca;\n    my (\\x,\\y,\\z) = @v;\n    map { @p⋅$_ },\n        [   ca + x×x×t, x×y×t -  z×sa, x×z×t +  y×sa],\n        [x×y×t +  z×sa,    ca + y×y×t, y×z×t -  x×sa],\n        [z×x×t -  y×sa, z×y×t +  x×sa,    ca + z×z×t]\n}\n\nmy @v1 = [5,-6,  4];\nmy @v2 = [8, 5,-30];\nsay join ' ', aRotate @v1, normalize(crossProduct @v1, @v2), getAngle @v1, @v2;\n\n```\n\nOutput:\n\n```\n2.232221073308229 1.3951381708176411 -8.370829024905852\n```\n\nAlternately, differing mostly in style:\n\n```\nsub infix:<•> { sum @^v1 Z× @^v2 } # dot product\n\nsub infix:<❌> (@v1, @v2) {         # cross product\n    my \\a = <1 2 0>; my \\b = <2 0 1>;\n    @v1[a] »×« @v2[b] »-« @v1[b] »×« @v2[a]\n}\n\nsub norm (*@v) { sqrt @v • @v }\n\nsub normal (*@v) { @v X/ @v.&norm }\n\nsub angle-between (@v1, @v2) { acos( (@v1 • @v2) / (@v1.&norm × @v2.&norm) ) }\n\nsub infix:<⁢> is equiv(&infix:<×>) { $^a × $^b } # invisible times\n\nsub postfix:<°> (\\d) { d × τ / 360 } # degrees to radians\n\nsub rodrigues-rotate( @point, @axis, $θ ) {\n    my ( \\cos𝜃, \\sin𝜃 ) = cis($θ).reals;\n    my ( \\𝑥, \\𝑦, \\𝑧 )   = @axis;\n    my \\𝑡 = 1 - cos𝜃;\n\n    map @point • *, [\n       [ 𝑥²⁢𝑡 + cos𝜃, 𝑦⁢𝑥⁢𝑡 - 𝑧⁢sin𝜃, 𝑧⁢𝑥⁢𝑡 + 𝑦⁢sin𝜃 ],\n       [ 𝑥⁢𝑦⁢𝑡 + 𝑧⁢sin𝜃, 𝑦²⁢𝑡 + cos𝜃, 𝑧⁢𝑦⁢𝑡 - 𝑥⁢sin𝜃 ],\n       [ 𝑥⁢𝑧⁢𝑡 - 𝑦⁢sin𝜃, 𝑦⁢𝑧⁢𝑡 + 𝑥⁢sin𝜃, 𝑧²⁢𝑡 + cos𝜃 ]\n    ]\n}\n\nsub point-vector (@point, @vector) {\n    rodrigues-rotate @point, normal(@point ❌ @vector), angle-between @point, @vector\n}\n\nput qq:to/TESTING/;\nTask example - Point and composite axis / angle:\n{ point-vector [5, -6, 4], [8, 5, -30] }\n\nPerhaps more useful, (when calculating a range of motion for a robot appendage,\nfor example), feeding a point, axis of rotation and rotation angle separately;\nsince theoretically, the point vector and axis of rotation should be constant:\n\n{\n(0, 10, 20 ... 180).map( { # in degrees\n    sprintf \"Rotated %3d°: %.13f, %.13f, %.13f\", $_,\n    rodrigues-rotate [5, -6, 4], ([5, -6, 4] ❌ [8, 5, -30]).&normal, .°\n}).join: \"\\n\"\n}\nTESTING\n\n```\n\nOutput:\n\n```\nTask example - Point and composite axis / angle:\n2.232221073308228 1.3951381708176427 -8.370829024905852\n\nPerhaps more useful, (when calculating a range of motion for a robot appendage,\nfor example), feeding a point, axis of rotation and rotation angle directly;\nsince theoretically, the point vector and axis of rotation should be constant:\n\nRotated   0°: 5.0000000000000, -6.0000000000000, 4.0000000000000\nRotated  10°: 5.7240554466526, -6.0975296976939, 2.6561853906284\nRotated  20°: 6.2741883650704, -6.0097890410223, 1.2316639322573\nRotated  30°: 6.6336832449081, -5.7394439854392, -0.2302810114435\nRotated  40°: 6.7916170161550, -5.2947088286573, -1.6852289831393\nRotated  50°: 6.7431909410900, -4.6890966233686, -3.0889721249495\nRotated  60°: 6.4898764214992, -3.9410085899762, -4.3988584118384\nRotated  70°: 6.0393702908772, -3.0731750048240, -5.5750876118134\nRotated  80°: 5.4053609500356, -2.1119645522518, -6.5819205958338\nRotated  90°: 4.6071124519719, -1.0865831254651, -7.3887652531624\nRotated 100°: 3.6688791733663, -0.0281864202486, -7.9711060171693\nRotated 110°: 2.6191688576205, 1.0310667150840, -8.3112487584187\nRotated 120°: 1.4898764214993, 2.0589914100238, -8.3988584118384\nRotated 130°: 0.3153148442246, 3.0243546928699, -8.2312730024418\nRotated 140°: -0.8688274150348, 3.8978244887705, -7.8135845280911\nRotated 150°: -2.0265707929363, 4.6528608599741, -7.1584842417190\nRotated 160°: -3.1227378427887, 5.2665224084086, -6.2858770340300\nRotated 170°: -4.1240220834695, 5.7201633384526, -5.2222766334692\nRotated 180°: -5.0000000000000, 6.0000000000000, -4.0000000000000\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a function taking a positive integer as its parameter and returning a string containing the Roman numeral representation of that integer. Modern Roman numerals are written by expressing each digit separately, starting with the left most digit and skipping any digit with a value of zero.\n\nIn Roman numerals:\n\n* 1990 is rendered: 1000=M, 900=CM, 90=XC; resulting in MCMXC\n* 2008 is written as 2000=MM, 8=VIII; or MMVIII\n* 1666 uses each Roman symbol in descending order: MDCLXVI"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy %symbols =\n    1 => \"I\", 5 => \"V\", 10 => \"X\", 50 => \"L\", 100 => \"C\",\n    500 => \"D\", 1_000 => \"M\";\n\nmy @subtractors =\n    1_000, 100,  500, 100,  100, 10,  50, 10,  10, 1,  5, 1,  1, 0;\n\nmulti sub roman (0) { '' }\nmulti sub roman (Int $n) {\n    for @subtractors -> $cut, $minus {\n        $n >= $cut\n            and return %symbols{$cut} ~ roman($n - $cut);\n        $n >= $cut - $minus\n            and return %symbols{$minus} ~ roman($n + $minus);\n     }\n}\n\n# Sample usage\n\nfor 1 .. 2_010 -> $x {\n    say roman($x);\n}\n```"}]}
{"messages": [{"role": "user", "content": "Find all eigenvalues of a real 3x3 matrix and estimate their errors.\n\nSee Wikipedia Cubic equation. [1]\nExample.\n\na\\*x\\*\\*3 + b\\*x\\*\\*2 + c\\*x + d = 0\n\nmatrix: [[1,-1,0], [0,1,-1],[0,0,1]]\n\npolynomial: [a,b,c,d] =[1, -3,+3, -1]\n\nroots: [1,1,1]"}, {"role": "assistant", "content": "```\nmy \\r = 1/sqrt(2);\nmy Pair @m = [[\n      triple       => [[ 1, -1,  0], [ 0,  1, -1], [ 0,  0,  1] ],\n      double       => [[ 2,  0,  0], [ 0, -1,  0], [ 0,  0, -1] ],\n      distinct     => [[ 2,  0,  0], [ 0,  3,  4], [ 0,  4,  9] ],\n      rotation     => [[ 1,  0,  0], [ 0,  r, -r], [ 0,  r,  r] ],\n   ]];\nfor ^@m {\n   my Pair $pair = @m[$_];                  print \"\\n  {1+$_}:  {$pair.key} \";\n   my @t = $pair.value.[];                  say 'matrix: \t  ', @t.raku;\n   my @poly = polynomial( @t );             say 'polynomial:  ', @poly.raku;\n   my @reduction = reduction( |@poly );     say 'reduction :  ', @reduction.raku;\n   my ( $s, $e ) = spectrum( @t );          say 'eigenvalues: ', @$s.raku;\n                                            say 'errors: \t  ', @$e.raku;\n}\nsub horner( \\x, \\a, \\b, \\c, \\d ) {          # cubic polynomial using horner's method\n    ((a * x + b) * x + c) * x + d\n}\nsub polynomial( @t ) {\n    my \\a = 1;                                  # create characteristic polynomial\n    my \\b = -(@t[0;0] + @t[1;1] + @t[2;2]);                     # = -trace\n    my \\c = ( @t[0;0]*@t[1;1] + @t[1;1]*@t[2;2] + @t[2;2]*@t[0;0] )\n            -(@t[1;2]*@t[2;1] + @t[2;0]*@t[0;2] + @t[0;1]*@t[1;0] );\n    my \\d = - @t[0;0] * @t[1;1] * @t[2;2]\n            - @t[0;1] * @t[1;2] * @t[2;0]\n            - @t[0;2] * @t[1;0] * @t[2;1]\n            + @t[0;0] * @t[2;1] * @t[1;2]\n            + @t[0;1] * @t[1;0] * @t[2;2]\n            + @t[0;2] * @t[1;1] * @t[2;0];                  # = -determinant\n    return [ a, b, c, d]>>.narrow;\n}\nsub reduction( \\a, \\b, \\c, \\d ) {\n    my \\delta = 18 * a * b * c * d - 4 * b **3 * d + b**2 * c**2 - 4 * a * c**3 - 27 * a**2 * d**2;\n    my \\p = (3 * a * c - b * b) / (3 * a * a);\n    my \\q = (2 * b ** 3 - 9 * a * b * c + 27 * a ** 2 * d) / (27 * a ** 3);\n    my \\d0 = b*b - 3 * a * c;\n    my \\d1 = 2*b**3 - 9*a*b*c + 27 * a**2 * d;\n    return [ delta, p, q, d0, d1 ];\n}\nsub solution( \\a, \\b, \\c, \\d, \\delta, \\p, \\q, \\d0, \\d1 ) {\n    my @x;\n    if abs(delta) =~= 0 {           # say \" multiple real roots \", p.raku ;\n        if abs(p) =~= 0 {           # say \" triple equal real roots: \";;\n            @x[$_] = 0 for ^3;\n        }\n        else {                      # say ' double real root:';\n            @x[0] = 3 * q / p;\n            @x[1] = -3 * q /(2 * p);\n            @x[2] = @x[1];\n        }\n    }\n    elsif delta > 0 {               # say \" three distinct real roots:\";\n        @x[$_] = 2*sqrt(-p/3) * cos( acos( sqrt( -3 / p ) * 3 * q /( 2 * p ) )/3 - 2*pi * $_/ 3 ) for ^3;\n    }\n    else {      # delta < 0;        say \" one real root and two complex conjugate roots:\";\n        my $g = do {\n            if d0 == 0 and d1 < 0 {\n                -(-d1)**⅓;\n            }\n            elsif d0 < 0 and d1 == 0 {\n                -sqrt(-d0);\n            }\n            else {\n                my \\s = Complex( d1**2 - 4 * d0**3 ).sqrt;\n                my \\g1 = (( d1 + s )/2)**⅓;\n                my \\g2 = (( d1 - s )/2)**⅓;\n                g1 == 0 ?? g2 !! g1\n            }\n        }\n        my Complex $z = $g * ( -1 + Complex(-3).sqrt )/2;\n        @x[0] = -⅓ * ( $g + d0 / $g );\n        @x[1] = -⅓ * ( $z + d0 / $z );\n        @x[2] = @x[1].conj;\n    }\n    @x[$_] -= ⅓ * b / a for ^3;\n    return @x;\n}\nsub spectrum( @mat ) {\n    my ( \\a, \\b, \\c, \\d )         = polynomial( @mat );\n    my (\\delta, \\p, \\q, \\d0, \\d1) = reduction( a, b, c, d );\n    my @s = solution( a, b, c, d, delta, p, q, d0, d1 )>>.narrow;\n    my @e = @s.map( { horner( $_, a, b, c, d ) })>>.narrow;\n    return ( @s, @e );\n}\n\n```\n\nOutput:\n\n```\n 1:  triple matrix: [[1, -1, 0], [0, 1, -1], [0, 0, 1]]\npolynomial:  [1, -3, 3, -1]\nreduction :  [0, 0.0, 0.0, 0, 0]\neigenvalues: [1, 1, 1]\nerrors:      [0, 0, 0]\n\n  2:  double matrix: [[2, 0, 0], [0, -1, 0], [0, 0, -1]]\npolynomial:  [1, 0, -3, -2]\nreduction :  [0, -3.0, -2.0, 9, -54]\neigenvalues: [2, -1, -1]\nerrors:      [0, 0, 0]\n\n  3:  distinct matrix: [[2, 0, 0], [0, 3, 4], [0, 4, 9]]\npolynomial:  [1, -14, 35, -22]\nreduction :  [8100, <-91/3>, <-1672/27>, 91, -1672]\neigenvalues: [11, 2, 0.9999999999999991e0]\nerrors:      [0, 0, -1.0658141036401503e-14]\n\n  4: rotation matrix: [[1, 0, 0], [0, 0.7071067811865475e0, -0.7071067811865475e0], [0, 0.7071067811865475e0, 0.7071067811865475e0]]\npolynomial:  [1, -2.414213562373095e0, 2.414213562373095e0, -0.9999999999999998e0]\nreduction :  [-0.6862915010152442e0, 0.4714045207910316e0, -0.0994922778153789e0, -1.414213562373095e0, -2.68629150101523e0]\neigenvalues: [0.9999999999999992e0, <0.7071067811865478-0.7071067811865472i>, <0.7071067811865478+0.7071067811865472i>]\nerrors:      [0, <-3.3306690738754696e-16-3.885780586188048e-16i>, <-3.3306690738754696e-16+3.885780586188048e-16i>]\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a program that finds and outputs the roots of a given function, range and (if applicable) step width.\n\nThe program should identify whether the root is exact or approximate.\n\nFor this task, use:      ƒ(x)   =   x3 - 3x2 + 2x"}, {"role": "assistant", "content": "(formerly Perl 6)\nUses exact arithmetic.\n\n```\nsub f(\\x) { x³ - 3*x² + 2*x }\n\nmy $start = -1;\nmy $stop = 3;\nmy $step = 0.001;\n\nfor $start, * + $step ... $stop -> $x {\n    state $sign = 0;\n    given f($x) {\n        my $next = .sign;\n        when 0.0 {\n            say \"Root found at $x\";\n        }\n        when $sign and $next != $sign {\n            say \"Root found near $x\";\n        }\n        NEXT $sign = $next;\n    }\n}\n\n```\n\nOutput:\n\n```\nRoot found at 0\nRoot found at 1\nRoot found at 2\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nWrite a program to find the roots of a quadratic equation, i.e., solve the equation \n\na\n\nx\n\n2\n+\nb\nx\n+\nc\n=\n0\n{\\displaystyle {\\displaystyle ax^{2}+bx+c=0}}\n.\nYour program must correctly handle non-real roots, but it need not check that \n\na\n≠\n0\n{\\displaystyle {\\displaystyle a\\neq 0}}\n.\n\nThe problem of solving a quadratic equation is a good example of how dangerous it can be to ignore the peculiarities of floating-point arithmetic.\nThe obvious way to implement the quadratic formula suffers catastrophic loss of accuracy when one of the roots to be found is much closer to 0 than the other.\nIn their classic textbook on numeric methods *Computer Methods for Mathematical Computations*, George Forsythe, Michael Malcolm, and Cleve Moler suggest trying the naive algorithm with \n\na\n=\n1\n{\\displaystyle {\\displaystyle a=1}}\n, \n\nb\n=\n−\n\n10\n\n5\n{\\displaystyle {\\displaystyle b=-10^{5}}}\n, and \n\nc\n=\n1\n{\\displaystyle {\\displaystyle c=1}}\n.\n(For double-precision floats, set \n\nb\n=\n−\n\n10\n\n9\n{\\displaystyle {\\displaystyle b=-10^{9}}}\n.)\nConsider the following implementation in Ada:\n\n```\nwith Ada.Text_IO;                        use Ada.Text_IO;\nwith Ada.Numerics.Elementary_Functions;  use Ada.Numerics.Elementary_Functions;\n\nprocedure Quadratic_Equation is\n   type Roots is array (1..2) of Float;\n   function Solve (A, B, C : Float) return Roots is\n      SD : constant Float := sqrt (B**2 - 4.0 * A * C);\n      AA : constant Float := 2.0 * A;\n   begin\n      return ((- B + SD) / AA, (- B - SD) / AA);\n   end Solve;\n\n   R : constant Roots := Solve (1.0, -10.0E5, 1.0);\nbegin\n   Put_Line (\"X1 =\" & Float'Image (R (1)) & \" X2 =\" & Float'Image (R (2)));\nend Quadratic_Equation;\n\n```\n\nOutput:\n\n```\nX1 = 1.00000E+06 X2 = 0.00000E+00\n```\n\nAs we can see, the second root has lost all significant figures. The right answer is that `X2` is about \n\n10\n\n−\n6\n{\\displaystyle {\\displaystyle 10^{-6}}}\n. The naive method is numerically unstable.\n\nSuggested by Middlebrook (D-OA), a better numerical method: to define two parameters \n\nq\n=\n\n\na\nc\n\n/\nb\n{\\displaystyle {\\displaystyle q={\\sqrt {ac}}/b}}\n and \n\nf\n=\n1\n\n/\n2\n+\n\n\n1\n−\n4\n\nq\n\n2\n\n/\n2\n{\\displaystyle {\\displaystyle f=1/2+{\\sqrt {1-4q^{2}}}/2}}\n\nand the two roots of the quardratic are: \n\n−\nb\na\nf\n{\\displaystyle {\\displaystyle {\\frac {-b}{a}}f}}\n and \n\n−\nc\n\nb\nf\n{\\displaystyle {\\displaystyle {\\frac {-c}{bf}}}}\n\n**Task**: do it better. This means that given \n\na\n=\n1\n{\\displaystyle {\\displaystyle a=1}}\n, \n\nb\n=\n−\n\n10\n\n9\n{\\displaystyle {\\displaystyle b=-10^{9}}}\n, and \n\nc\n=\n1\n{\\displaystyle {\\displaystyle c=1}}\n, both of the roots your program returns should be greater than \n\n10\n\n−\n11\n{\\displaystyle {\\displaystyle 10^{-11}}}\n. Or, if your language can't do floating-point arithmetic any more precisely than single precision, your program should be able to handle \n\nb\n=\n−\n\n10\n\n6\n{\\displaystyle {\\displaystyle b=-10^{6}}}\n. Either way, show what your program gives as the roots of the quadratic in question. See page 9 of\n\"What Every Scientist Should Know About Floating-Point Arithmetic\" for a possible algorithm."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2022.12\n\n*Works with previous versions also but will return slightly less precise results.*\n\nRaku has complex number handling built in.\n\n```\nfor\n[1, 2, 1],\n[1, 2, 3],\n[1, -2, 1],\n[1, 0, -4],\n[1, -10⁶, 1]\n-> @coefficients {\n    printf \"Roots for %d, %d, %d\\t=> (%s, %s)\\n\",\n    |@coefficients, |quadroots(@coefficients);\n}\n\nsub quadroots (*[$a, $b, $c]) {\n    ( -$b + $_ ) / (2 × $a),\n    ( -$b - $_ ) / (2 × $a) \n    given\n    ($b² - 4 × $a × $c ).Complex.sqrt.narrow\n}\n\n```\n\nOutput:\n\n```\nRoots for 1, 2, 1\t=> (-1, -1)\nRoots for 1, 2, 3\t=> (-1+1.4142135623730951i, -1-1.4142135623730951i)\nRoots for 1, -2, 1\t=> (1, 1)\nRoots for 1, 0, -4\t=> (2, -2)\nRoots for 1, -1000000, 1\t=> (999999.999999, 1.00000761449337e-06)\n```"}]}
{"messages": [{"role": "user", "content": "The purpose of this task is to explore working with   complex numbers.\n\nTask\n\nGiven   **n**,   find the   **n**th   roots of unity."}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku has a built-in function cis which returns a unitary complex number given its phase. Raku also defines the tau = 2\\*pi constant. Thus the k-th n-root of unity can simply be written cis(k\\*τ/n).\n\n```\nconstant n = 10;\nfor ^n -> \\k {\n    say cis(k*τ/n);\n}\n\n```\n\nOutput:\n\n```\n1+0i\n0.809016994374947+0.587785252292473i\n0.309016994374947+0.951056516295154i\n-0.309016994374947+0.951056516295154i\n-0.809016994374947+0.587785252292473i\n-1+1.22464679914735e-16i\n-0.809016994374948-0.587785252292473i\n-0.309016994374948-0.951056516295154i\n0.309016994374947-0.951056516295154i\n0.809016994374947-0.587785252292473i\n```\n\nAlternately, you could use the built-in .roots method to find the nth roots of any number.\n\n```\n.say for 1.roots(9)\n\n```\n\nOutput:\n\n```\n1+0i\n0.766044443118978+0.6427876096865393i\n0.17364817766693041+0.984807753012208i\n-0.4999999999999998+0.8660254037844387i\n-0.9396926207859083+0.3420201433256689i\n-0.9396926207859084-0.34202014332566866i\n-0.5000000000000004-0.8660254037844384i\n0.17364817766692997-0.9848077530122081i\n0.7660444431189778-0.6427876096865396i\n```"}]}
{"messages": [{"role": "user", "content": "Find the total number of programming examples for each task and the total for all tasks.\n\nEssentially, count the number of occurrences of =={{header| on each task page.\n\nOutput:\n\n```\n100 doors: 20 examples.\n99 Bottles of Beer: 29 examples.\nAbstract type: 10 examples.\n\nTotal: X examples.\n```\n\nFor a full output, updated periodically, see Rosetta Code/Count examples/Full list.\n\nYou'll need to use the Media Wiki API, which you can find out about locally, here, or in Media Wiki's API documentation at, API:Query"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nRetrieves counts for both Tasks and Draft Tasks. Save / Display results as a sortable wikitable rather than a static list. Click on a column header to sort on that column. To do a secondary sort, hold down the shift key and click on a second column header. Tasks have a gray (default) background, Draft Tasks have a yellow background.\n\nThis example tracks the top 50 languages by number of examples completed but only generates reports in tiers of 10. More than 10 gets too heavy and difficult to navigate.\n\nFeed it parameters to control behaviour:\n\n* :nf or :no-fetch to use saved information to generate the different reports. Recommended for the second, third, fourth, whatever report you are generating at any one time as fetching from the site is *by far* the most time consuming part.\n* :t=1 (or :tier=1). :t=2, :t=3, whatever, up to :t=5 to control which tier of results to generate.\n\nLanguage names with spaces will have underscores inserted to make the results uniform. Some oddball languages (lookin' at you Icon and Unicon) make it very difficult to obtain accurate results. The whole \"conglomerate all of the Basic dialects together\" movement of a few years ago also complicates things, but this should be pretty close.\n\nFor a full output, see Top tier, Second tier, Third tier, Fourth tier\n\n```\nuse HTTP::UserAgent;\nuse URI::Escape;\nuse JSON::Fast;\nuse Lingua::EN::Numbers :short;\n\nunit sub MAIN ( Bool :nf(:$no-fetch) = False, :t(:$tier) = 1 );\n\n# Friendlier descriptions for task categories\nmy %cat = (\n    'Programming_Tasks' => 'Task',\n    'Draft_Programming_Tasks' => 'Draft'\n);\n\nmy $client = HTTP::UserAgent.new;\n$client.timeout = 10;\n\nmy $url = 'https://rosettacode.org/w';\n\nmy $hashfile  = './RC_Task_count.json';\nmy $tablefile = \"./RC_Task_count-{$tier}.txt\";\n\nmy %tasks;\n\nmy @places = <① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ⑪ ⑫ ⑬ ⑭ ⑮ ⑯ ⑰ ⑱ ⑲ ⑳ ㉑ ㉒ ㉓ ㉔ ㉕\n      ㉖ ㉗ ㉘ ㉙ ㉚ ㉛ ㉜ ㉝ ㉞ ㉟ ㊱ ㊲ ㊳ ㊴ ㊵ ㊶ ㊷ ㊸ ㊹ ㊺ ㊺ ㊻ ㊼ ㊽ ㊾ ㊿>;\n\n# clear screen\nrun($*DISTRO.is-win ?? 'cls' !! 'clear') unless $no-fetch;\n\nmy %counts =\n    mediawiki-query(\n        $url, 'pages',\n        :generator<categorymembers>,\n        :gcmtitle<Category:Programming Languages>,\n        :gcmlimit<350>,\n        :rawcontinue(),\n        :prop<categoryinfo>\n    )\n    .map({ .<title>.subst(/^'Category:'/, '') => .<categoryinfo><pages> || 0 });\n\nmy $per-tier = 10;\n\nmy $which = (^$per-tier) »+» $per-tier * ($tier - 1);\n\nmy @top-n = %counts.sort( {-.value, .key} )[|$which].map: *.key.trans(' ' => '_');\n\n# dump a copy to STDOUT, mostly for debugging purposes\nsay \"<pre>{tc $tier.&ord-n} {$per-tier.&card} programming languages by number of task examples completed:\";\nsay '    ', join ' ', .map( {(\"{(@places[|$which])[$_]} {@top-n[$_]}\").fmt(\"%-15s\")} ) for (^@top-n).batch(5);\nsay \"</pre>\\n\";\n\nunless $no-fetch {\n\n    note 'Retrieving task information...';\n\n    mkdir('./pages') unless './pages'.IO.e;\n\n    @top-n = %counts.sort( {-.value, .key} )[^@places].map: *.key.trans(' ' => '_');;\n\n    for %cat.keys.sort -> $cat {\n        mediawiki-query(\n            $url, 'pages',\n            :generator<categorymembers>,\n            :gcmtitle(\"Category:$cat\"),\n            :gcmlimit<350>,\n            :rawcontinue(),\n            :prop<title>\n        ).map({\n            my $page;\n            my $response;\n\n            loop {\n                $response = $client.get(\"{ $url }/index.php?title={ uri-escape .<title> }&action=raw\");\n                if $response.is-success {\n                    $page = $response.content;\n                    last;\n                } else {\n                    redo;\n                }\n            }\n\n            \"./pages/{ uri-escape .<title>.subst(/' '/, '_', :g) }\".IO.spurt($page);\n            my $lc = $page.lc.trans(' ' => '_');\n            my $count = +$lc.comb(/ ^^'==' <-[\\n=]>* '{{header|' <-[}]>+? '}}==' \\h* $$ /);\n            %tasks{.<title>} = {'cat' => %cat{$cat}, :$count};\n            %tasks{.<title>}<top-n> = (^@top-n).map( {\n                ($lc.contains(\"==\\{\\{header|{@top-n[$_].lc}}}\") or\n                 # Deal with 3 part headers - {{header|F_Sharp|F#}}, {{header|C_Sharp|C#}}, etc.\n                 $lc.contains(\"==\\{\\{header|{@top-n[$_].lc}|\")  or\n                 # Icon and Unicon are their own special flowers\n                 $lc.contains(\"}}_and_\\{\\{header|{@top-n[$_].lc}}}==\") or\n                 # Language1 / Language2 for shared entries (e.g. C / C++)\n                 $lc.contains(rx/'}}''_'*'/''_'*'{{header|'$(@top-n[$_].lc)'}}=='/)) ??\n                (@places[$_]) !!\n                 # Check if the task was omitted\n                 $lc.contains(\"\\{\\{omit_from|{@top-n[$_].lc}\") ?? 'O' !!\n                 # The task is neither done or omitted\n                 ' '\n            } ).join;\n            print clear, 1 + $++, ' ', %cat{$cat}, ' ', .<title>;\n        })\n    }\n\n    print clear;\n\n    note \"\\nTask information saved to local file: {$hashfile.IO.absolute}\";\n    $hashfile.IO.spurt(%tasks.&to-json);\n\n}\n\n# Load information from local file\n%tasks = $hashfile.IO.e ?? $hashfile.IO.slurp.&from-json !! ( );\n\n@top-n = %counts.sort( {-.value, .key} )[|$which].map: *.key.trans(' ' => '_');\n\n# Convert saved task info to a table\nnote \"\\nBuilding table...\";\nmy $count    = +%tasks;\nmy $taskcnt  = +%tasks.grep: *.value.<cat> eq %cat<Programming_Tasks>;\nmy $draftcnt = $count - $taskcnt;\nmy $total    = sum %tasks{*}»<count>;\n\n# Dump table to a file\nmy $out = open($tablefile, :w)  or die \"$!\\n\";\n\n$out.say: \"<pre>{tc $tier.&ord-n} {$per-tier.&card} programming languages by number of task examples completed:\";\n$out.say: '    ', join ' ', .map( {(\"{(@places[|$which])[$_]} {@top-n[$_]}\").fmt(\"%-15s\")} ) for (^@top-n).batch(5);\n$out.say: \"</pre>\\n\\n<div style=\\\"height:40em;overflow:scroll;\\\">\";\n\n# Add table boilerplate and caption\n$out.say:\n    '{|class=\"wikitable sortable\"', \"\\n\",\n    \"|+ As of { DateTime.new(time) } :: Tasks: { $taskcnt } ::<span style=\\\"background-color:#ffd\\\"> Draft Tasks:\",\n    \"{ $draftcnt } </span>:: Total Tasks: { $count } :: Total Examples: { $total }\\n\",\n    \"!Count!!Task!!{(@places[|$which]).join('!!')}\"\n;\n\n# Sort tasks by count then add row\nfor %tasks.sort: { [-.value<count>, .key] } -> $task {\n    $out.say:\n      ( $task.value<cat> eq 'Draft'\n        ?? \"|- style=\\\"background-color: #ffc\\\"\\n\"\n        !! \"|-\\n\"\n      ),\n      \"| { $task.value<count> }\\n\",\n      ( $task.key ~~ /\\d/\n        ?? \"|data-sort-value=\\\"{ $task.key.&naturally }\\\"| [[{uri-escape $task.key}|{$task.key}]]\\n\"\n        !! \"| [[{uri-escape $task.key}|{$task.key}]]\\n\"\n      ),\n      \"|{ $task.value<top-n>.comb[|$which].join('||') }\"\n}\n\n$out.say( \"|}\\n</div>\" );\n$out.close;\n\nnote \"Table file saved as: {$tablefile.IO.absolute}\";\n\nsub mediawiki-query ($site, $type, *%query) {\n    my $url = \"$site/api.php?\" ~ uri-query-string(\n        :action<query>, :format<json>, :formatversion<2>, |%query);\n    my $continue = '';\n\n    gather loop {\n        my $response = $client.get(\"$url&$continue\");\n        my $data = from-json($response.content);\n        take $_ for $data.<query>.{$type}.values;\n        $continue = uri-query-string |($data.<query-continue>{*}».hash.hash or last);\n    }\n}\n\nsub uri-query-string (*%fields) { %fields.map({ \"{.key}={uri-escape .value}\" }).join(\"&\") }\n\nsub naturally ($a) { $a.lc.subst(/(\\d+)/, ->$/ {0~(65+$0.chars).chr~$0},:g) }\n\nsub clear { \"\\r\" ~ ' ' x 116 ~ \"\\r\" }\n\n```\n\nAbridged output:\n\n```\nTop ten programming language by number of task examples completed:\n① Go\n② Perl 6\n③ Kotlin\n④ Python\n⑤ Phix\n⑥ Racket\n⑦ Perl\n⑧ C\n⑨ Julia\n⑩ Tcl\n\n```\n\nAs of 2019-01-21T22:41:28Z :: Tasks: 924 :: Draft Tasks:215 :: Total Tasks: 1139 :: Total Examples: 59984\n\n| Count | Task | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| 405 | Hello world/Text | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ |\n| 283 | 99 Bottles of Beer | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ |\n| 276 | FizzBuzz | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ |\n| 273 | 100 doors | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ |\n| 251 | Fibonacci sequence | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ |\n| 246 | Comments | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ |\n| 239 | Factorial | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ |\n| 223 | Empty program | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ |\n| 222 | A+B | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ |\n| 214 | Function definition | ① | ② | ③ | ④ | ⑤ | ⑥ | ⑦ | ⑧ | ⑨ | ⑩ |"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind all    <lang>    tags without a language specified in the text of a page.\n\nDisplay counts by language section:\n\n```\nDescription\n\n<lang>Pseudocode</lang>\n\n=={{header|C}}==\n<lang C>printf(\"Hello world!\\n\");</lang>\n\n=={{header|Perl}}==\n<lang>print \"Hello world!\\n\"</lang>\n\n```\n\nshould display something like\n\n```\n2 bare language tags.\n\n1 in perl\n1 in no language\n\n```\n\nExtra credit\n\nAllow multiple files to be read.   Summarize all results by language:\n\n```\n5 bare language tags.\n\n2 in c ([[Foo]], [[Bar]])\n1 in perl ([[Foo]])\n2 in no language ([[Baz]])\n\n```\n\nExtra extra credit\n\nUse the   Media Wiki API   to test actual RC tasks."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\nThe only tricky thing here is the use of the ms form of match, short for m:sigspace. This causes whitespace in the regex to be considered \"significant\", that is, it matches optional whitespace at those positions, as if you'd put \\s\\* there. Of course, the regexes themselves are in Raku syntax, which is quite different from Perl 5 regex syntax (and arguably much cleaner). Regex syntax is perhaps the area in which Raku diverges most from Perl 5.\n\n```\nmy $lang = '(no language)';\nmy $total = 0;\nmy %blanks;\n\nfor lines() {\n  when / '<lang>' / {\n    %blanks{$lang}++;\n    $total++;\n  }\n  when ms/ '==' '{{' 'header' '|' ( <-[}]>+? ) '}}' '==' / {\n    $lang = $0.lc;\n  }\n}\n\nsay \"$total bare language tag{ 's' if $total != 1 }\\n\";\nsay .value, ' in ', .key for %blanks.sort;\n\n```\n\nOutput:\n\n```\n2 bare language tags\n\n1 in (no language)\n1 in perl\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven the name of a language on Rosetta Code, find all tasks which are not implemented in that language.\n\nNote: Implementations should allow for fetching more data than can be returned in one request to Rosetta Code.\n\nYou'll need to use the Media Wiki API, which you can find out about locally, here, or in Media Wiki's API documentation at, API:Query"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.04.1\n\n```\nuse HTTP::UserAgent;\nuse URI::Escape;\nuse JSON::Fast;\nuse Sort::Naturally;\n\nunit sub MAIN( Str :$lang = 'Raku' );\n\nmy $client = HTTP::UserAgent.new;\nmy $url = 'https://rosettacode.org/w';\n\nmy @total;\nmy @impl;\n\n@total.append: .&get-cat for 'Programming_Tasks', 'Draft_Programming_Tasks';\n@impl = get-cat $lang;\n\nsay \"Unimplemented tasks in $lang:\";\nmy @unimplemented = (@total (-) @impl).keys.sort: *.&naturally;\n.say for @unimplemented;\nsay \"{+@unimplemented} unimplemented tasks\";\n\nsub get-cat ($category) {\n    flat mediawiki-query(\n        $url, 'pages',\n        :generator<categorymembers>,\n        :gcmtitle(\"Category:$category\"),\n        :gcmlimit<350>,\n        :rawcontinue(),\n        :prop<title>\n    ).map({ .<title> });\n}\n\nsub mediawiki-query ($site, $type, *%query) {\n    my $url = \"$site/api.php?\" ~ uri-query-string(\n        :action<query>, :format<json>, :formatversion<2>, |%query);\n    my $continue = '';\n\n    gather loop {\n        my $response = $client.get(\"$url&$continue\");\n        my $data = from-json($response.content);\n        take $_ for $data.<query>.{$type}.values;\n        $continue = uri-query-string |($data.<query-continue>{*}».hash.hash or last);\n    }\n}\n\nsub uri-query-string (*%fields) { %fields.map({ \"{.key}={uri-escape .value}\" }).join(\"&\") }\n\n```\n\nOutput:\n\n*As of Sept. 2, 2022*\n\n```\nUnimplemented tasks in Raku:\n3d turtle graphics\n15 puzzle game in 3D\nAddition-chain exponentiation\nAudio alarm\nAudio frequency generator\nAudio overlap loop\nBinary coded decimal\nBlack box\nBlackjack strategy\nBoids\nCatmull–Clark subdivision surface\nChess player\nCLI-based maze-game\nCompare sorting algorithms' performance\nCompiler/AST interpreter\nCompiler/Preprocessor\nCompiler/syntax analyzer\nCreate an executable for a program in an interpreted language\nCross compilation\nCycles of a permutation\nDiophantine linear system solving\nDominoes\nElevator simulation\nExecute Computer/Zero\nFree polyominoes enumeration\nGeneralised floating point multiplication\nHexapawn\nHoneycombs\nIRC gateway\nMorpion solitaire\nNumber triplets game\nOLE automation\nOpenGL pixel shader\nP-Adic square roots\nPlay recorded sounds\nRed black tree sort\nRemote agent/Agent interface\nRemote agent/Agent logic\nRemote agent/Simulation\nSimple turtle graphics\nSolve a Rubik's cube\nSolving coin problems\nSorting algorithms/Tree sort on a linked list\nTamagotchi emulator\nTetris\nUkkonen’s suffix tree construction\nUnicode polynomial equation\nUno (card game)\nUse a REST API\nWaveform analysis/Top and tail\nWeather routing\nWebGL rotating F\n52 unimplemented tasks\n```"}]}
{"messages": [{"role": "user", "content": "This task has been *revised* for the hosting change Rosetta Code has had in August 2022.\n\nSee the Python example for a new example to fit the revised task.\n\nTask\n\nFix Rosetta Code deprecated code tags, with these rules:\n\n```\nChange <lang %s> to <syntaxhighlight lang=%s>\nChange </lang> to </syntaxhighlight>\nChange <lang> to <syntaxhighlight lang=text>\n\n```\n\nDemonstrate the task on these examples\n\n```\n<lang AutoHotkey>; usage: > fixtags.ahk input.txt ouput.txt\nFileRead, text, %1%\nlangs = ada,awk,autohotkey,etc\nslang = /lang\nslang := \"<\" . slang . \"/>\"\nLoop, Parse, langs, `,\n{\n  tag1 = <%A_LoopField%>\n  tag2 = </%A_LoopField%>\n  text := RegExReplace(text, tag1, \"<lang \" . A_LoopField . \">\")\n  text := RegExReplace(text, tag2, slang)\n  text := RegExReplace(text, \"<code (.+?)>(.*?)</code>\"\n          , \"<lang $1>$2\" . slang)\n}\nFileAppend, % text, %2%\n</lang>\n\n```\n\n```\n<lang perl>my @langs = qw(ada cpp-qt pascal lscript z80 visualprolog\nhtml4strict cil objc asm progress teraterm hq9plus genero tsql\nemail pic16 tcl apt_sources io apache vhdl avisynth winbatch\nvbnet ini scilab ocaml-brief sas actionscript3 qbasic perl bnf\ncobol powershell php kixtart visualfoxpro mirc make javascript\ncpp sdlbasic cadlisp php-brief rails verilog xml csharp\nactionscript nsis bash typoscript freebasic dot applescript\nhaskell dos oracle8 cfdg glsl lotusscript mpasm latex sql klonec\nruby ocaml smarty python oracle11 caddcl robots groovy smalltalk\ndiff fortran cfm lua modula3 vb autoit java text scala\nlotusformulas pixelbender reg _div whitespace providex asp css\nlolcode lisp inno mysql plsql matlab oobas vim delphi xorg_conf\ngml prolog bf per scheme mxml d basic4gl m68k gnuplot idl abap\nintercal c_mac thinbasic java5 xpp boo klonecpp blitzbasic eiffel\npovray c gettext);\n\nmy $text = join \"\", <STDIN>;\nmy $slang=\"/lang\";\nfor (@langs) {\n    $text =~ s|<$_>|<lang $_>|g;\n    $text =~ s|</$_>|<$slang>|g;\n}\n\n$text =~ s|<code (.+?)>(.*?)</code>|<lang $1>$2<$slang>|sg;\n\nprint $text;</lang>\n\n```\n\n```\n<lang>HAI 1.3\n\nI HAS A bottles ITZ 99 I HAS A plural ITZ \"Z\" I HAS A lyric ITZ \"99 BOTTLZ OV BEER\"\n\nIM IN YR song\n\n   VISIBLE lyric \" ON TEH WALL\"\n   VISIBLE lyric\n   VISIBLE \"TAEK 1 DOWN, PAZ IT AROUN\"\n   bottles R DIFF OF bottles AN 1\n   NOT bottles, O RLY?\n       YA RLY, VISIBLE \"NO MOAR BOTTLZ OV BEER ON TEH WALL\", GTFO\n   OIC\n   BOTH SAEM bottles AN 1, O RLY?\n       YA RLY, plural R \"\"\n   OIC\n   lyric R SMOOSH bottles \" BOTTL\" plural \" OV BEER\" MKAY\n   VISIBLE lyric \" ON TEH WALL:)\"\nIM OUTTA YR song\n\nKTHXBYE</lang>\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @langs = <\n    abap actionscript actionscript3 ada apache applescript apt_sources\n    asm asp autoit avisynth bash basic4gl bf blitzbasic bnf boo c caddcl\n    cadlisp cfdg cfm cil c_mac cobol cpp cpp-qt csharp css d delphi\n    diff _div dos dot eiffel email fortran freebasic genero gettext\n    glsl gml gnuplot groovy haskell hq9plus html4strict idl ini inno\n    intercal io java java5 javascript kixtart klonec klonecpp latex lisp\n    lolcode lotusformulas lotusscript lscript lua m68k make matlab mirc\n    modula3 mpasm mxml mysql nsis objc ocaml ocaml-brief oobas oracle11\n    oracle8 pascal per perl php php-brief pic16 pixelbender plsql povray\n    powershell progress prolog providex python qbasic rails reg robots\n    ruby sas scala scheme scilab sdlbasic smalltalk smarty sql tcl teraterm\n    text thinbasic tsql typoscript vb vbnet verilog vhdl vim visualfoxpro\n    visualprolog whitespace winbatch xml xorg_conf xpp z80\n>;\n\n$_ = slurp;\n\nfor @langs -> $l {\n    s:g:i [ '<' 'lang '?  $l '>' ] = \"<lang $l>\";\n    s:g [ '</' $l '>' ] = '</' ~ 'lang>';\n}\n\ns:g [ '<code '(.+?) '>' (.*?) '</code>' ] = \"<lang $0>{$1}</\"~\"lang>\";\n\n.say;\n\n```\n\n```\nuse v6;\n\nconstant @langs = < abap actionscript actionscript3 ada  … >;\n\nslurp().subst(\n    rx:r{\n        | '<' <( $<need-add-space>=<?> )> @langs '>'\n        | '</' <( @langs )> '>'\n        | '<' '/'? <( code )> [<.ws> @langs]? '>'\n    },\n    'lang' ~ \" \" x *<need-add-space>.so,\n    :g,\n).print\n\n```"}]}
{"messages": [{"role": "user", "content": "In this task, the goal is to compile an authorship list for task descriptions. A pseudocode example (in imperative style) that should accomplish this is as follows:\n\n```\nfor each task page\n  grab page source, discard everything after the first ==section==.\nCache as $previous. Note $author.\n  for each revision\n    grab page source, discard everything after first ==section==.\nCache as $previous2. Note $author2\n    compare $previous2 to $previous. If different, record $author to $list.\n    replace $previous with $previous2\n    replace $author with $author2\n```\n\nThe following resources for HTTP interface information for MediaWiki may prove to be useful:\n\n* https://www.mediawiki.org/wiki/Index.php#Raw\n* https://www.mediawiki.org/wiki/Index.php#History\n* https://www.mediawiki.org/wiki/API:Main\\_page\n\nConversely, some languages have libraries which abstract these interfaces into language-native idioms. Use of these abstractions is perfectly fine.\n\nPlease **DO NOT** add a full output for *each* programming language; just show a representative sample. For an full listing, see Rosetta\\_Code/List\\_authors\\_of\\_task\\_descriptions/Full\\_list."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nThe pseudocode above is no longer really useful as the page format has changed significantly since this task was written. Rather than checking **every** edit to see if it was a change to the task description, we'll just assume the user that created the page is the task author. This isn't 100% accurate; a very few pages got renamed and recreated by someone other than the original author without preserving the history, so they are misreported (15 Puzzle Game for instance,) but is as good as it is likely to get without extensive manual intervention. Subsequent edits to the task description are not credited. As it is, we must still make *thousands* of requests and pound the server pretty hard. Checking **every** edit would make the task several of orders of magnitude more abusive of the server (and my internet connection.)\n\n```\nuse HTTP::UserAgent;\nuse URI::Escape;\nuse JSON::Fast;\nuse Sort::Naturally;\n\n# Friendlier descriptions for task categories\nmy %cat = (\n    'Programming_Tasks' => 'Task',\n    'Draft_Programming_Tasks' => 'Draft'\n);\n\nmy $client = HTTP::UserAgent.new;\n\nmy $url = 'https://rosettacode.org/w';\n\nmy $tablefile = './RC_Authors.txt';\nmy $hashfile  = './RC_Authors.json';\n\nmy %tasks;\n\n# clear screen\nrun($*DISTRO.is-win ?? 'cls' !! 'clear');\n\n%tasks = $hashfile.IO.e ?? $hashfile.IO.slurp.&from-json !! ( );\nsleep 1;\n\n#=begin update\n\nnote 'Retrieving task information...';\n\nmy %filter;\nfor %cat.keys.sort -> $category {\n    mediawiki-query(\n        $url, 'pages',\n        :generator<categorymembers>,\n        :gcmtitle(\"Category:$category\"),\n        :gcmlimit<350>,\n        :rawcontinue(),\n        :prop<title>\n    ).map( { %filter{.<title>} = %cat{$category} } )\n}\n\nmy $delete = %tasks.keys (-) %filter.keys;\n\n%tasks.delete($_) for $delete.keys; #Tasks that have changed names or been removed\n\nmy @add;\nfor %filter.keys -> $title {\n    if %tasks{$title}:exists {\n        %tasks{$title}<category> = %filter{$title} # update status\n    } else {\n        @add.push: $title => %filter{$title} # New Tasks\n    }\n}\n\nif @add {\n    .say for 'Adding new tasks:', |@add;\n}\n\nfor @add -> $task {\n    mediawiki-query(\n        $url, 'pages',\n        :titles($task.key),\n        :prop<revisions>,\n        :rvprop<user|timestamp>,\n        :rvstart<2000-01-01T01:01:01Z>,\n        :rvdir<newer>,\n        :rvlimit<1>\n    ).map: {\n        print clear, 1 + $++, ' ', .[0]<title>;\n        %tasks{.[0]<title>}<category> = $task.value;\n        %tasks{.[0]<title>}<author> = .[0]<revisions>[0]<user>;\n        %tasks{.[0]<title>}<date> = .[0]<revisions>[0]<timestamp>.subst(/'T'.+$/, '')\n    }\n}\n\nprint clear;\n\n# Save information to a local file\nnote \"\\nTask information saved to local file: {$hashfile.IO.absolute}\";\n$hashfile.IO.spurt(%tasks.&to-json);\n\n#=end update\n\n# Load information from local file\n%tasks = $hashfile.IO.e ?? $hashfile.IO.slurp.&from-json !! ( );\n\n# Convert saved task / author info to a table\nnote \"\\nBuilding table...\";\nmy $count    = +%tasks;\nmy $taskcnt  = +%tasks.grep: *.value.<category> eq %cat<Programming_Tasks>;\nmy $draftcnt = $count - $taskcnt;\n\n# Open a file handle to dump table in\nmy $out = open($tablefile, :w)  or die \"$!\\n\";\n\n# Add table boilerplate and header\n$out.say:\n    \"\\{|class=\\\"wikitable sortable\\\"\\n\",\n    \"|+ As of { Date.today } :: Total Tasks: { $count }:: Tasks: { $taskcnt }\",\n    \" ::<span style=\\\"background-color:#ffd\\\"> Draft Tasks: { $draftcnt } </span>\",\n    \":: By {+%tasks{*}».<author>.unique} Authors\\n\",\n    \"! Author !! Tasks !! Authored\"\n;\n\n# Get sorted unique list of task authors\nfor %tasks{*}».<author>.unique.sort(&naturally) -> $author {\n\n    # Get list of tasks by this author\n    my @these = %tasks.grep( { $_.value.<author> eq $author } );\n    my $s = +@these == 1 ?? '' !! 's';\n\n    # Add author and contributions link to the first two cells\n    $out.say:\n    $author ~~ /\\d/\n      ?? \"|- id=\\\"$author\\\"\\n|data-sort-value=\\\"{ sort-key $author }\\\"|[[User:$author|$author]]\\n\"~\n         \"|data-sort-value=\\\"{ +@these }\\\"|[[Special:Contributions/$author|\"~\n         \"{ +@these } task{ $s }]]\"\n      !! \"|- id=\\\"$author\\\"\\n|[[User:$author|$author]]\\n\"~\n         \"|data-sort-value=\\\"{ +@these }\\\"|[[Special:Contributions/$author|\"~\n         \"{ +@these } task{ $s }]]\"\n    ;\n\n    if +@these > 2 {\n        $out.say: \"|style=\\\"padding: 0px;\\\"|\\n\",\n          \"\\{|class=\\\"broadtable sortable\\\" style=\\\"width: 100%;\\\"\\n\",\n          \"! Task Name !! Date Added !! Status\";\n    }\n    else {\n        $out.say: \"|style=\\\"padding: 0px;\\\"|\\n\",\n          \"\\{|class=\\\"broadtable\\\" style=\\\"width: 100%;\\\"\";\n   }\n\n    # Tasks by this author, sorted by name\n    for @these.sort({.key.&naturally}) -> $task {\n\n        my $color = $task.value.<category> eq 'Draft' ?? '#ffd' !! '#fff';\n\n        # add the task link, date and status to the table in the second cell\n        $out.say: \"|-\\n|style=\\\"background-color: $color;\\\"\",\n          ( $task.key ~~ /\\d/\n            ?? \" data-sort-value=\\\"{ sort-key $task.key }\\\"| [[{uri-escape $task.key}|{$task.key}]]\\n\"\n            !! \"| [[{uri-escape $task.key}|{$task.key}]]\\n\"\n          ),\n          \"|style=\\\"width: 10em; background-color: $color;\\\"| {$task.value.<date>}\\n\",\n          \"|style=\\\"width: 6em; background-color: $color;\\\"| {$task.value.<category>}\",\n    }\n     $out.say: '|}'\n}\n$out.say( \"|}\\n\" );\n$out.close;\n\n\nnote \"Table file saved as: {$tablefile.IO.absolute}\";\n\nsub mediawiki-query ($site, $type, *%query) {\n    my $url = \"$site/api.php?\" ~ uri-query-string(\n        :action<query>, :format<json>, :formatversion<2>, |%query);\n    my $continue = '';\n\n    gather loop {\n        my $response = $client.get(\"$url&$continue\");\n        my $data = from-json($response.content);\n        take $_ for $data.<query>.{$type}.values;\n        $continue = uri-query-string |($data.<query-continue>{*}».hash.hash or last);\n    }\n}\n\nsub uri-query-string (*%fields) { %fields.map({ \"{.key}={uri-escape .value}\" }).join(\"&\") }\n\nsub sort-key ($a) { $a.lc.subst(/(\\d+)/, ->$/ {0~(65+($0.chars)).chr~$0},:g) }\n\nsub clear { \"\\r\" ~ ' ' x 100 ~ \"\\r\" }\n\n```\n\nSample output:\n\nSee full output at Rosetta\\_Code/List\\_authors\\_of\\_task\\_descriptions/Full\\_list\n\nAs of 2018-04-10 :: Total Tasks: 1080:: Tasks: 871 :: Draft Tasks: 209 :: By 251 Authors\n\n| Author | Tasks | Authored |\n| --- | --- | --- |\n| 2Powers | 2 tasks | |  |  |  | | --- | --- | --- | | Names to numbers | 2013-05-16 | Draft | | Solving coin problems | 2013-05-16 | Draft | |\n| 12.175.32.19 | 1 task | |  |  |  | | --- | --- | --- | | Soundex | 2009-11-12 | Task | |\n| 12Me21 | 1 task | |  |  |  | | --- | --- | --- | | Draw a rotating cube | 2015-05-04 | Task | |\n| many rows omitted... | | |\n| Zorro1024 | 2 tasks | |  |  |  | | --- | --- | --- | | Perfect shuffle | 2015-04-16 | Task | | Vector | 2015-03-21 | Draft | |\n| Zzo38 | 1 task | |  |  |  | | --- | --- | --- | | Thue-Morse | 2015-09-20 | Task | |\n| Русский | 3 tasks | | Task Name | Date Added | Status | | --- | --- | --- | | Main step of GOST 28147-89 | 2012-08-31 | Task | | Old Russian measure of length | 2013-01-09 | Draft | | Transportation problem | 2013-05-24 | Draft | |"}]}
{"messages": [{"role": "user", "content": "Task\n\nSort most popular programming languages based on the number of users on Rosetta Code.\n\nShow the languages with at least 100 users.\n\nA method to solve the task\n\nUsers of a computer programming language   **X**   are those referenced in the page:\n\n```\n https://rosettacode.org/wiki/Category:X_User,     or preferably: \n https://rosettacode.org/mw/index.php?title=Category:X_User&redirect=no to avoid re-directions. \n\n```\n\nIn order to find the list of such categories,   it's possible to first parse the entries of:\n\n```\n http://rosettacode.org/mw/index.php?title=Special:Categories&limit=5000. \n\n```\n\nThen download and parse each computer language   *users*   category to find the number of users of that computer language.\n\nSample output on 18 February 2019:\n\n```\nLanguage             Users\n--------------------------\nC                      391\nJava                   276\nC++                    275\nPython                 262\nJavaScript             238\nPerl                   171\nPHP                    167\nSQL                    138\nUNIX Shell             131\nBASIC                  120\nC sharp                118\nPascal                 116\nHaskell                102\n```\n\nA Rosetta Code user usually declares using a language with the mylang template. This template is expected to appear on the User page. However, in some cases it appears in a user Talk page. It's not necessary to take this into account. For instance, among the 373 C users in the table above, 3 are actually declared in a Talk page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.11\n\nUse the mediawiki API rather than web scraping since it is much faster and less resource intensive. Show languages with more than 25 users since that is still a pretty short list and to demonstrate how tied rankings are handled. Change the **$minimum** parameter to adjust what the cut-off point will be.\n\nThis is all done in a single pass; ties are not detected until a language has the same count as a previous one, so ties are marked by a **T** next to the count indicating that **this** language has the same count as the **previous**.\n\n```\nuse HTTP::UserAgent;\nuse URI::Escape;\nuse JSON::Fast;\n\nmy $client = HTTP::UserAgent.new;\n\nmy $url = 'https://rosettacode.org/w';\n\nmy $start-time = now;\n\nsay \"========= Generated: { DateTime.new(time) } =========\";\n\nmy $lang = 1;\nmy $rank = 0;\nmy $last = 0;\nmy $tie = ' ';\nmy $minimum = 25;\n\n.say for\n    mediawiki-query(\n        $url, 'pages',\n        :generator<categorymembers>,\n        :gcmtitle<Category:Language users>,\n        :gcmlimit<350>,\n        :rawcontinue(),\n        :prop<categoryinfo>\n    )\n\n    .map({ %( count => .<categoryinfo><pages> || 0,\n              lang  => .<title>.subst(/^'Category:' (.+) ' User'/, ->$/ {$0}) ) })\n\n    .sort( { -.<count>, .<syntaxhighlight lang=\"text\"> } )\n\n    .map( { last if .<count> < $minimum; display(.<count>, .<syntaxhighlight lang=\"text\">) } );\n\nsay \"========= elapsed: {(now - $start-time).round(.01)} seconds =========\";\n\nsub display ($count, $which) {\n    if $last != $count { $last = $count; $rank = $lang; $tie = ' ' } else { $tie = 'T' };\n    sprintf \"#%3d  Rank: %2d %s  with %-4s users:  %s\", $lang++, $rank, $tie, $count, $which;\n}\n\nsub mediawiki-query ($site, $type, *%query) {\n    my $url = \"$site/api.php?\" ~ uri-query-string(\n        :action<query>, :format<json>, :formatversion<2>, |%query);\n    my $continue = '';\n\n    gather loop {\n        my $response = $client.get(\"$url&$continue\");\n        my $data = from-json($response.content);\n        take $_ for $data.<query>.{$type}.values;\n        $continue = uri-query-string |($data.<query-continue>{*}».hash.hash or last);\n    }\n}\n\nsub uri-query-string (*%fields) {\n    join '&', %fields.map: { \"{.key}={uri-escape .value}\" }\n}\n\n```\n\nOutput:\n\n```\n========= Generated: 2022-09-02T20:59:20Z =========\n#  1  Rank:  1    with 441  users:  C\n#  2  Rank:  2    with 321  users:  Java\n#  3  Rank:  3    with 319  users:  Python\n#  4  Rank:  4    with 314  users:  C++\n#  5  Rank:  5    with 291  users:  JavaScript\n#  6  Rank:  6    with 190  users:  PHP\n#  7  Rank:  7    with 186  users:  Perl\n#  8  Rank:  8    with 167  users:  SQL\n#  9  Rank:  9    with 151  users:  UNIX Shell\n# 10  Rank: 10    with 133  users:  Pascal\n# 11  Rank: 11    with 132  users:  BASIC\n# 12  Rank: 11 T  with 132  users:  C sharp\n# 13  Rank: 13    with 115  users:  Haskell\n# 14  Rank: 14    with 107  users:  Ruby\n# 15  Rank: 15    with 94   users:  Fortran\n# 16  Rank: 16    with 75   users:  Visual Basic\n# 17  Rank: 17    with 72   users:  Scheme\n# 18  Rank: 18    with 70   users:  Prolog\n# 19  Rank: 19    with 68   users:  AWK\n# 20  Rank: 19 T  with 68   users:  Lua\n# 21  Rank: 21    with 66   users:  Common Lisp\n# 22  Rank: 22    with 61   users:  HTML\n# 23  Rank: 23    with 55   users:  X86 Assembly\n# 24  Rank: 24    with 50   users:  Forth\n# 25  Rank: 25    with 49   users:  Batch File\n# 26  Rank: 26    with 47   users:  Assembly\n# 27  Rank: 27    with 45   users:  Bash\n# 28  Rank: 27 T  with 45   users:  MATLAB\n# 29  Rank: 29    with 42   users:  Lisp\n# 30  Rank: 30    with 41   users:  APL\n# 31  Rank: 30 T  with 41   users:  Erlang\n# 32  Rank: 32    with 40   users:  Delphi\n# 33  Rank: 32 T  with 40   users:  R\n# 34  Rank: 34    with 39   users:  J\n# 35  Rank: 34 T  with 39   users:  Visual Basic .NET\n# 36  Rank: 36    with 38   users:  Go\n# 37  Rank: 36 T  with 38   users:  Tcl\n# 38  Rank: 38    with 37   users:  COBOL\n# 39  Rank: 39    with 36   users:  Smalltalk\n# 40  Rank: 40    with 35   users:  Brainf***\n# 41  Rank: 40 T  with 35   users:  Objective-C\n# 42  Rank: 42    with 34   users:  Clojure\n# 43  Rank: 43    with 33   users:  Mathematica\n# 44  Rank: 44    with 30   users:  OCaml\n# 45  Rank: 45    with 28   users:  LaTeX\n# 46  Rank: 46    with 27   users:  AutoHotkey\n# 47  Rank: 46 T  with 27   users:  Emacs Lisp\n# 48  Rank: 46 T  with 27   users:  PostScript\n# 49  Rank: 46 T  with 27   users:  REXX\n# 50  Rank: 50    with 26   users:  Perl 6\n# 51  Rank: 50 T  with 26   users:  Sed\n# 52  Rank: 52    with 25   users:  CSS\n# 53  Rank: 52 T  with 25   users:  Scala\n# 54  Rank: 52 T  with 25   users:  VBScript\n========= elapsed: 1.48 seconds =========\n\n========= elapsed: 1.45 seconds =========\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSort the most popular computer programming languages based in number of members in Rosetta Code categories.\n\nSample output on 02 August 2022 at 09:50 +02\n\n```\nRank:  1 (1,565 entries) Phix\nRank:  2 (1,558 entries) Wren\nRank:  3 (1,531 entries) Julia\nRank:  4 (1,507 entries) Raku\nRank:  5 (1,500 entries) Go\nRank:  6 (1,466 entries) Perl\nRank:  7 (1,409 entries) Python\nRank:  8 (1,402 entries) Nim\nRank:  9 (1,254 entries) J\nRank: 10 (1,211 entries) C\n...\n```\n\nNotes\n\n* Each language typically demonstrates one or two methods of accessing the data:\n\n:   :   :   * with web scraping   (via http://www.rosettacode.org/mw/index.php?title=Special:Categories&limit=5000)\n            * with the API method   (examples below for Awk, Perl, Ruby, Tcl, etc).\n\n* The scraping and API solutions can be separate subsections, see the Tcl example.\n* Filtering wrong results is optional.   You can check against Special:MostLinkedCategories (if using web scraping)\n\n:   :   If you use the API, and do elect to filter, you may check your results against this complete, accurate, sortable, wikitable listing of all **971** programming languages, updated periodically, *typically weekly*.\n\n* A complete ranked listing of all   **813**   languages (from the REXX example) is included here   ──►   output from the REXX program."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Raku: Using the API\n\nNote that this counts **only** the tasks. It does not include other non-task categories in the counts yielding more realistic, non-inflated numbers. Raku is Unicode aware and handles non-ASCII names natively. This does not attempt to 'unify' different language names that are the same behind the scenes as a result of Rosettacodes' capitalization peculiarities. (E.G. μC++, UC++ & ΜC++)\n\n```\nuse HTTP::UserAgent;\nuse URI::Escape;\nuse JSON::Fast;\nuse Sort::Naturally;\n\nmy $client = HTTP::UserAgent.new;\n\nmy $url = 'https://rosettacode.org/w';\n\nmy $tablefile = './RC_Popularity.txt';\n\nmy %cat = (\n    'Programming_Tasks' => 'Task',\n    'Draft_Programming_Tasks' => 'Draft'\n);\nmy %tasks;\n\nfor %cat.keys.sort -> $cat {\n    mediawiki-query(\n        $url, 'pages',\n        :generator<categorymembers>,\n        :gcmtitle(\"Category:$cat\"),\n        :gcmlimit<350>,\n        :rawcontinue(),\n        :prop<title>\n    ).map({ %tasks{%cat{$cat}}++ });\n}\n\nmy %counts =\n    mediawiki-query(\n        $url, 'pages',\n        :generator<categorymembers>,\n        :gcmtitle<Category:Programming Languages>,\n        :gcmlimit<350>,\n        :rawcontinue(),\n        :prop<categoryinfo>\n    )\n    .map({\n        my $title = .<title>.subst(/^'Category:'/, '');\n        my $tasks = (.<categoryinfo><pages> || 0);\n        my $categories = (.<categoryinfo><subcats> || 0);\n        my $total = (.<categoryinfo><size> || 0);\n       $title  => [$tasks ,$categories, $total]\n   });\n\nmy $out = open($tablefile, :w)  or die \"$!\\n\";\n\n# Add table boilerplate and header\n$out.say:\n    \"\\{|class=\\\"wikitable sortable\\\"\\n\",\n    \"|+ As of { Date.today } :: {+%counts} Languages\\n\",\n    '!Rank!!Language!!Task<br>Entries!!Tasks<br>done %!!Non-task<br>Subcate-<br>gories!!Total<br>Categories'\n;\n\nmy @bg = <#fff; #ccc;>;\nmy $ff = 0;\nmy $rank = 1;\nmy $ties = 0;\n\n# Get sorted unique task counts\nfor %counts.values»[0].unique.sort: -* -> $count {\n    $ff++;\n    # Get list of tasks with this count\n    my @these = %counts.grep( *.value[0] == $count )».keys.sort: *.&naturally;\n\n    for @these {\n        $ties++;\n        $out.say:\n          \"|- style=\\\"background-color: { @bg[$ff % 2] }\\\"\\n\"~\n          \"|$rank\\n\"~\n          \"|[[:Category:$_|]]\\n\"~\n          \"|$count\\n\"~\n          \"|{(100 * $count/%tasks<Draft Task>.sum).round(.01)} %\\n\"~\n          \"|{%counts{$_}[1]}\\n\"~\n          \"|{%counts{$_}[2]}\"\n    }\n    $rank += $ties;\n    $ties = 0;\n}\n$out.say( \"|}\" );\n$out.say('=' x 5, \" query, download & processing: {(now - INIT now).round(.01)} seconds \", '=' x 5);\n$out.close;\n\nsub mediawiki-query ($site, $type, *%query) {\n    my $url = \"$site/api.php?\" ~ uri-query-string(\n        :action<query>, :format<json>, :formatversion<2>, |%query);\n    my $continue = '';\n\n    gather loop {\n        my $response = $client.get(\"$url&$continue\");\n        my $data = from-json($response.content);\n        take $_ for $data.<query>.{$type}.values;\n        $continue = uri-query-string |($data.<query-continue>{*}».hash.hash or last);\n    }\n}\n\nsub uri-query-string (*%fields) {\n    join '&', %fields.map: { \"{.key}={uri-escape .value}\" }\n}\n\n```\n\nAbridged output:\n\nSee full output here.\n\nAs of 2019-02-10 :: 715 Languages\n\n| Rank | Language | Task Entries | Tasks done % | Non-task Subcate- gories | Total Categories |\n| --- | --- | --- | --- | --- | --- |\n| 1 | Go | 1100 | 96.15 % | 4 | 1104 |\n| 2 | Perl 6 | 1046 | 91.43 % | 4 | 1050 |\n| 3 | Kotlin | 1029 | 89.95 % | 1 | 1030 |\n| 4 | Python | 1017 | 88.9 % | 17 | 1034 |\n| 5 | Phix | 991 | 86.63 % | 3 | 994 |\n| 6 | Racket | 986 | 86.19 % | 3 | 989 |\n| 7 | Perl | 963 | 84.18 % | 5 | 968 |\n| 8 | Julia | 958 | 83.74 % | 3 | 961 |\n| 9 | C | 940 | 82.17 % | 3 | 943 |\n| 10 | Tcl | 925 | 80.86 % | 4 | 929 |\n| 11 | Zkl | 918 | 80.24 % | 1 | 919 |\n| 12 | J | 901 | 78.76 % | 3 | 904 |\n| 13 | Java | 897 | 78.41 % | 3 | 900 |\n| 14 | REXX | 886 | 77.45 % | 4 | 890 |\n| 15 | D | 871 | 76.14 % | 3 | 874 |\n| 16 | Ruby | 866 | 75.7 % | 3 | 869 |\n| 17 | Haskell | 849 | 74.21 % | 3 | 852 |\n| 18 | Scala | 789 | 68.97 % | 3 | 792 |\n| 19 | Sidef | 787 | 68.79 % | 1 | 788 |\n| 20 | PicoLisp | 772 | 67.48 % | 3 | 775 |\n\n### Raku: Using web scraping\n\nScraping the languages and categories pages. Raku automatically handles Unicode names correctly.\n\n```\nmy $languages =  qx{wget -O - 'http://rosettacode.org/wiki/Category:Programming_Languages'};\nmy $categories = qx{wget -O - 'http://www.rosettacode.org/mw/index.php?title=Special:Categories&limit=5000'};\n \nmy @lines = $languages.lines;\nshift @lines until @lines[0] ~~ / '<h2>Subcategories</h2>' /;\nmy \\languages = set gather for @lines {\n    last if / '/bodycontent' /;\n    take ~$0 if\n        / '<li><a href=\"/wiki/Category:' .*? '\" title=\"Category:' .*? '\">' (.*?) '</a></li>' /;\n}\n \n@lines = $categories.lines;\nmy @results = sort -*.[0], gather for @lines {\n    take [+$1.subst(',', ''), ~$0] if\n        / '<li><a href=\"/wiki/Category:' .*? '\" title=\"Category:' .*? '\">'\n        (.*?) <?{ ~$0 ∈ languages }>\n        '</a>' .*? '(' (<[, 0..9]>+) ' member' /;\n}\n \nfor @results.kv -> $i, @l {\n    printf \"%d:\\t%4d - %s\\n\", $i+1, |@l;\n}\n\n```\n\nOutput:\n\n(As of 2018-10-28) Here we show only the top 10.\n\n```\n1:\t1036 - Go\n2:\t1029 - Kotlin\n3:\t1014 - Python\n4:\t 998 - Perl 6\n5:\t 980 - Racket\n6:\t 929 - Tcl\n7:\t 926 - C\n8:\t 910 - Perl\n9:\t 904 - Zkl\n10:\t 901 - J\n```"}]}
{"messages": [{"role": "user", "content": "This task is based on an idea hatched from this C1R Implementation.\n\nWrite a program that will accept as input the name of a task from Rosetta Code and the name of a language. The program should then download the solution for the specified task in the specified language, present the source to the user and prompt the user to confirm running the example.\n\nThe program should verify that the tools needed to compile or run the solution are present before running it.\nIf the solution can not be run, a graceful exit should happen. (i.e. the program should not crash)\n\nBesides its own language, the program should support at least two other languages. (Ideally it would support most of the languages available, but that is too much to ask. Though some languages are simple, e.g. python, pike, perl, bash and several more only need the solution saved in a file and given to the language as argument to run, so it should be easy to support many languages like that).\n\nIf you know what is needed to support a particular language, please help to add support for that language to implementations in other languages.\n\nExtra credit: add a function to get a list of all solutions of a given language and run them to create a report on which solutions failed to run.\n\nMore credit: also test if the output of a solution compares to a given result. The expected output should be loaded from a file with the name of the task. (This way all implementations can share the same set of files, and anyone can add more files. In the future the content of these files could be stored directly in a section of the task on Rosetta Code itself.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nThis is a fairly comprehensive task code runner. It is set up to work for Raku by default, but has basic configurations to run Perl, Python, Tcl and Go tasks as well. It can be easily tweaked to work with other languages by adding a load-lang('whatever'){} routine similar to the Raku, Perl, Python, Tcl and Go ones. (And ensuring that the appropriate compiler is installed and accessible.) There is so much variation to the task requirements and calling conventions that it would be problematic to make a general purpose, language agnostic code runner so some configuration is necessary to make it work with other languages.\n\n(Note that there is no dependency download code nor resource hash for Python and Go, though they can run a remarkable number of tasks without.)\n\nBy default, this will download the Raku section of any (every) task that has a Raku example, extract the code blocks and attempt to run them. Many tasks require files or user interaction to proceed, others are not complete runnable code blocks (example code fragments), some tasks run forever. To try to deal with and compensate for this, this implementation can load a %resource hash that will: supply input files where necessary, skip unrunnable code fragments, limit long and/or infinite running blocks, supply user interaction code where possible, and skip blocks where user interaction is unavoidable.\n\nThere are several command line options to control its actions. See the README in the repository for details.\n\nThe complete implementation is too large and cumbersome to post in it's entirety here, only the main task retrieval and execution code is included.\n\nFor the whole ball of wax see the rc-run github repository.\n\nRun with no parameters to run every implemented task on Rosetta Code. Feed it a task name to only download / run that task. Give it command line switches to adjust its behaviour.\n\nNote: This is set up to run under Linux. It could be adapted for Windows (or OSX I suppose) fairly easily but I don't have access to those OSs, nor do I care to seek it.\n\n```\nuse HTTP::UserAgent;\nuse URI::Escape;\nuse JSON::Fast;\nuse Text::Levenshtein::Damerau;\nuse MONKEY-SEE-NO-EVAL;\n\n#####################################\nsay \"Version = 2020-03-15T12:15:31\";\n#####################################\n\nsleep 1;\n\nmy %*SUB-MAIN-OPTS = :named-anywhere;\n\nunit sub MAIN(\n    Str $run = '',        #= Task or file name\n    Str :$lang = 'raku',  #= Language, default raku - used to load configuration settings\n    Int :$skip = 0,       #= Skip # to continue partially into a list\n    Bool :f(:$force),     #= Override any task skip parameter in %resource hash\n    Bool :l(:$local),     #= Only use code from local cache\n    Bool :r(:$remote),    #= Only use code from remote server (refresh local cache)\n    Bool :q(:$quiet),     #= Less verbose, don't display source code\n    Bool :d(:$deps),      #= Load dependencies\n    Bool :p(:$pause),     #= pause after each task\n    Bool :b(:$broken),    #= pause after each task which is broken or fails in some way\n    Int  :$sleep = 0,     #= sleep for $sleep after each task\n    Bool :t(:$timer),     #= save timing data for each task\n);\n\ndie 'You can select local or remote, but not both...' if $local && $remote;\n\n## INITIALIZATION\n\nmy $client   = HTTP::UserAgent.new;\nmy $url      = 'https://rosettacode.org/w';\n\nmy %c = ( # text colors\n    code  => \"\\e[0;92m\", # green\n    delim => \"\\e[0;93m\", # yellow\n    cmd   => \"\\e[1;96m\", # cyan\n    bad   => \"\\e[0;91m\", # red\n    warn  => \"\\e[38;2;255;155;0m\", # orange\n    dep   => \"\\e[38;2;248;24;148m\", # pink\n    clr   => \"\\e[0m\",    # clear formatting\n);\n\nmy $view      = 'xdg-open';       # image viewer, this will open default under Linux\nmy %l         = load-lang($lang); # load language parameters\nmy %resource  = load-resources($lang);\nmy $get-tasks = True;\n\nmy @tasks;\n\nrun('clear');\n\n## FIGURE OUT WHICH TASKS TO RUN\n\nif $run {\n    if $run.IO.e and $run.IO.f {# is it a file?\n        @tasks = $run.IO.lines; # yep, treat each line as a task name\n    } else {                    # must be a single task name\n        @tasks = ($run);        # treat it so\n    }\n    $get-tasks = False;         # don't need to retrieve task names from web\n}\n\nif $get-tasks { # load tasks from web if cache is not found, older than one day or forced\n    if !\"%l<dir>.tasks\".IO.e or (now - \"%l<dir>.tasks\".IO.modified) > 86400 or $remote {\n        note 'Retrieving task list from site.';\n        @tasks = mediawiki-query( # get tasks from web\n        $url, 'pages',\n        :generator<categorymembers>,\n        :gcmtitle(\"Category:%l<language>\"),\n        :gcmlimit<350>,\n        :rawcontinue(),\n        :prop<title>\n        )»<title>.grep( * !~~ /^'Category:'/ ).sort;\n        \"%l<dir>.tasks\".IO.spurt: @tasks.sort.join(\"\\n\");\n    } else {\n        note 'Using cached task list.';\n        @tasks = \"%l<dir>.tasks\".IO.slurp.lines; # load tasks from file\n    }\n}\n\nmy $tfile;\nif $timer {\n    $tfile = open :w, \"{$lang}-time.txt\";\n    $tfile.close;\n}\n\nnote \"Skipping first $skip tasks...\" if $skip;\nmy $redo;\n\n## MAIN LOOP\n\nfor @tasks -> $title {\n    $redo = False;\n    next if $++ < $skip;\n    next unless $title ~~ /\\S/; # filter blank lines (from files)\n    say my $tasknum = $skip + ++$, \")  $title\";\n\n    my $name = $title.subst(/<-[-0..9A..Za..z]>/, '_', :g);\n    my $taskdir = \"./rc/%l<dir>/$name\";\n\n    my $modified = \"$taskdir/$name.txt\".IO.e ?? \"$taskdir/$name.txt\".IO.modified !! 0;\n\n    my $entry;\n    if $remote or !\"$taskdir/$name.txt\".IO.e or ((now - $modified) > 86400 * 7) {\n        my $page = $client.get(\"{ $url }/index.php?title={ uri-escape $title }&action=raw\").content;\n\n        uh-oh(\"Whoops, can't find page: $url/$title :check spelling.\\n\\n{fuzzy-search($title)}\", 'warn')\n            and next if $page.elems == 0;\n        say \"Getting code from: https://rosettacode.org/wiki/{ $title.subst(' ', '_', :g) }#%l<language>\";\n\n        $entry = $page.comb(rx:i/'=={{header|' $(%l<header>) '}}==' .+? [<?before \\n'=='<-[={]>*'{{header'> || $] /).Str //\n          uh-oh(\"No code found\\nMay be bad markup\", 'warn');\n\n        if $entry ~~ /^^ 'See [[' (.+?) '/' $(%l<language>) / { # no code on main page, check sub page\n            $entry = $client.get(\"{ $url }/index.php?title={ uri-escape $/[0].Str ~ '/' ~ %l<language> }&action=raw\").content;\n        }\n        mkdir $taskdir unless $taskdir.IO.d;\n        spurt( \"$taskdir/$name.txt\", $entry );\n    } else {\n        if \"$taskdir/$name.txt\".IO.e {\n            $entry = \"$taskdir/$name.txt\".IO.slurp;\n            say \"Loading code from: $taskdir/$name.txt\";\n        } else {\n            uh-oh(\"Task code $taskdir/$name.txt not found, check spelling or run remote.\", 'warn');\n            next;\n        }\n    }\n\n    my @blocks = $entry.comb: %l<tag>;\n\n    unless @blocks {\n        uh-oh(\"No code found\\nMay be bad markup\", 'warn') unless %resource{\"$name\"}<skip> ~~ /'ok to skip'/;\n        say \"Skipping $name: \", %resource{\"$name\"}<skip>, \"\\n\" if %resource{\"$name\"}<skip>\n    }\n\n    for @blocks.kv -> $k, $v {\n        my $n = +@blocks == 1 ?? '' !! $k;\n        spurt( \"$taskdir/$name$n%l<ext>\", $v );\n        if %resource{\"$name$n\"}<skip> && !$force {\n            dump-code (\"$taskdir/$name$n%l<ext>\");\n            if %resource{\"$name$n\"}<skip> ~~ /'broken'/ {\n                uh-oh(%resource{\"$name$n\"}<skip>, 'bad');\n                pause if $broken;\n            } else {\n                say \"{%c<warn>}Skipping $name$n: \", %resource{\"$name$n\"}<skip>, \"{%c<clr>}\\n\";\n            }\n            next;\n        }\n        say \"\\nTesting $name$n\";\n        run-it($taskdir, \"$name$n\", $tasknum);\n    }\n    say  %c<delim>, '=' x 79, %c<clr>;\n    redo if $redo;\n    sleep $sleep if $sleep;\n    pause if $pause;\n}\n\n## SUBROUTINES\n\nsub mediawiki-query ($site, $type, *%query) {\n    my $url = \"$site/api.php?\" ~ uri-query-string(\n        :action<query>, :format<json>, :formatversion<2>, |%query);\n    my $continue = '';\n\n    gather loop {\n        my $response = $client.get(\"$url&$continue\");\n        my $data = from-json($response.content);\n        take $_ for $data.<query>.{$type}.values;\n        $continue = uri-query-string |($data.<query-continue>{*}».hash.hash or last);\n    }\n}\n\nsub run-it ($dir, $code, $tasknum) {\n    my $current = $*CWD;\n    chdir $dir;\n    if %resource{$code}<file> -> $fn {\n        copy \"$current/rc/resources/{$_}\", \"./{$_}\" for $fn[]\n    }\n    dump-code (\"$code%l<ext>\") unless $quiet;\n    check-dependencies(\"$code%l<ext>\", $lang) if $deps;\n    my @cmd = %resource{$code}<cmd> ?? |%resource{$code}<cmd> !! \"%l<exe> $code%l<ext>\\n\";\n    if $timer {\n        $tfile = open :a, \"{$current}/{$lang}-time.txt\";\n    }\n    my $time = 'NA: not run or killed before completion';\n    for @cmd -> $cmd {\n        say \"\\nCommand line: {%c<cmd>}$cmd\",%c<clr>;\n        if $timer { $tfile.say: \"Command line: $cmd\".chomp }\n        my $start = now;\n        try shell $cmd;\n        $time = (now - $start).round(.001);\n        CATCH {\n            when /'exit code: 137'/ { }\n            default {\n                .resume unless $broken;\n                uh-oh($_, 'bad');\n                if %resource{$code}<fail-by-design> {\n                    say %c<warn>, 'Fails by design, (or at least, it\\'s not unexpected).', %c<clr>;\n                } else {\n                    if pause.lc eq 'r' {\n                       unlink \"$code.txt\";\n                       $redo = True;\n                    }\n                }\n             }\n        }\n    if $timer { $tfile.say(\"#$tasknum - Wallclock seconds: $time\\n\") }\n    }\n    chdir $current;\n    say \"\\nDone task #$tasknum: $code - wallclock seconds: $time\\e[?25h\";\n    $tfile.close if $timer;\n}\n\nsub pause {\n    prompt \"Press enter to procede:> \";\n    # or\n    # sleep 5;\n}\n\nsub dump-code ($fn) {\n    say \"\\n\", %c<delim>, ('vvvvvvvv' xx 7).join(' CODE '), %c<clr>, \"\\n\", %c<code>;\n    print $fn.IO.slurp;\n    say %c<clr>,\"\\n\\n\",%c<delim>,('^^^^^^^^' xx 7).join(' CODE '),%c<clr>;\n}\n\nsub uri-query-string (*%fields) { %fields.map({ \"{.key}={uri-escape .value}\" }).join('&') }\n\nsub clear { \"\\r\" ~ ' ' x 100 ~ \"\\r\" }\n\nsub uh-oh ($err, $class='warn') { put %c{$class}, \"{'#' x 79}\\n\\n $err \\n\\n{'#' x 79}\", %c<clr> }\n\nsub fuzzy-search ($title) {\n    my @tasknames;\n    if \"%l<dir>.tasks\".IO.e {\n        @tasknames = \"%l<dir>.tasks\".IO.slurp.lines;\n    }\n    return '' unless @tasknames.elems;\n    \" Did you perhaps mean:\\n\\n\\t\" ~\n    @tasknames.grep( {.lc.contains($title.lc) or dld($_, $title) < (5 min $title.chars)} ).join(\"\\n\\t\");\n}                # Damerau Levenshtein distance  ^^^\n\nmulti check-dependencies ($fn, 'raku') {\n    my @use = $fn.IO.slurp.comb(/<?after ^^ \\h* 'use '> \\N+? <?before \\h* ';'>/);\n    if +@use {\n        say %c<dep>, 'Checking dependencies...', %c<clr>;\n        for @use -> $module {\n            if $module eq any('v6', 'v6.c', 'v6.d', 'nqp', 'NativeCall', 'Test') or $module.contains('MONKEY')\n              or $module.contains('experimental') or $module.starts-with('lib') or $module.contains('from<Perl5>') {\n                print %c<dep>;\n                say 'ok, no installation necessary: ', $module;\n                print %c<clr>;\n                next;\n            }\n            my $installed = $*REPO.resolve(CompUnit::DependencySpecification.new(:short-name($module)));\n            my @mods = $module;\n            if './../../../raku-modules.txt'.IO.e {\n                my $fh = open( './../../../perl6-modules.txt', :r ) or die $fh;\n                @mods.append: $fh.lines;\n                $fh.close;\n            }\n            my $fh = open( './../../../raku-modules.txt', :w ) or die $fh;\n            $fh.spurt: @mods.Bag.keys.sort.join: \"\\n\";\n            $fh.close;\n            print %c<dep>;\n            if $installed {\n                say 'ok, installed: ', $module\n            } else {\n                say 'not installed: ', $module;\n                shell(\"zef install $module\");\n            }\n            print %c<clr>;\n        }\n    }\n}\n\nmulti check-dependencies ($fn, 'perl') {\n    my @use = $fn.IO.slurp.comb(/<?after ^^ \\h* 'use '> \\N+? <?before \\h* ';'>/);\n    if +@use {\n        for @use -> $module {\n            next if $module eq $module.lc;\n            next if $module.starts-with(any('constant','bignum'));\n            my $installed = shell( \"%l<exe> -e 'eval \\\"use {$module}\\\"; exit 1 if \\$@'\" );\n            print %c<dep>;\n            if $installed {\n                say 'ok:            ', $module\n            } else {\n                say 'not installed: ', $module;\n                try shell(\"sudo cpan $module\");\n            }\n            print %c<clr>;\n        }\n    }\n}\n\nmulti check-dependencies  ($fn, $unknown) {\n    note \"Sorry, don't know how to handle dependencies for $unknown language.\"\n};\n\nmulti load-lang ('raku') { ( # Language specific variables. Adjust to suit.\n    language => 'Raku',  # language category name\n    exe      => 'raku',  # executable name to run perl6 in a shell\n    ext      => '.raku', # file extension for perl6 code (optional, but nice to have)\n    dir      => 'raku',  # directory to save tasks to\n    header   => 'Raku',  # header text (=={{header|Raku}}==)\n    # tags marking blocks of code - spaced out to placate wiki formatter\n    # and to avoid getting tripped up when trying to run _this_ task.\n    # note that this tag only selects the syntax highlighting, continue to\n    # leave 'perl6' as an option, 'raku' is now live on the site.\n    tag => rx/:i <?after '<syntaxhighlight lang=\"' ['perl6'|'raku'] '\"' ' line'? '>' > .*? <?before '</' 'syntaxhighlight>'>/,\n) }\n\nmulti load-lang ('perl') { (\n    language => 'Perl',\n    exe      => 'perl',\n    ext      => '.pl',\n    dir      => 'perl',\n    header   => 'Perl',\n    tag => rx/:i <?after '<syntaxhighlight lang=\"' 'perl' '\"' ' line'? '>' > .*? <?before '</' 'lang>'>/,\n) }\n\nmulti load-lang ('python') { (\n    language => 'Python',\n    exe      => 'python',\n    ext      => '.py',\n    dir      => 'python',\n    header   => 'Python',\n    tag => rx/:i <?after '<syntaxhighlight lang=\"' 'python' '\"' ' line'? '>' > .*? <?before '</' 'lang>'>/,\n) }\n\nmulti load-lang ('go') { (\n    language => 'Go',\n    exe      => 'go run',\n    ext      => '.go',\n    dir      => 'go',\n    header   => 'Go',\n    tag => rx/:i <?after '<syntaxhighlight lang=\"' 'go'  '\"' ' line'? '>' > .*? <?before '</' 'lang>'>/,\n) }\n\nmulti load-lang ('tcl') { (\n    language => 'Tcl',\n    exe      => 'tclsh',\n    ext      => '.tcl',\n    dir      => 'tcl',\n    header   => 'Tcl',\n    tag => rx/:i <?after '<syntaxhighlight lang=\"' 'tcl'  '\"' ' line'? '>' > .*? <?before '</' 'lang>'>/,\n) }\n\nmulti load-lang ($unknown) { die \"Sorry, don't know how to handle $unknown language.\" };\n\nmulti load-resources ($unknown) { () };\n\n```\n\nOutput:\n\nwith command line\n\n:   **raku RC-run.p6 -q \"Determine if a string is numeric\"**\n\n```\nRetrieving tasks\n1)  Determine if a string is numeric\nGetting code from: http://rosettacode.org/wiki/Determine_if_a_string_is_numeric#Raku\n\nTesting Determine_if_a_string_is_numeric\n\nCommand line: raku Determine_if_a_string_is_numeric.p6\n\n               Coerce     Don't coerce\n    String   whitespace    whitespace\n       <1>      True         True\n     <1.2>      True         True\n   <1.2.3>     False        False\n      <-6>      True         True\n     <1/2>      True         True\n     <12e>     False        False\n     <B17>     False        False\n <1.3e+12>      True         True\n  <1.3e12>      True         True\n <-2.6e-3>      True         True\n    <zero>     False        False\n      <0x>     False        False\n   <0xA10>      True         True\n  <0b1001>      True         True\n    <0o16>      True         True\n    <0o18>     False        False\n    <2+5i>      True         True\n    <True>     False        False\n   <False>     False        False\n     <Inf>      True         True\n     <NaN>      True         True\n <0x10.50>      True         True\n   <0b102>     False        False\n  <0o_5_3>      True         True\n      <௫௯>      True         True\n  <  12  >      True         True\n   <1 1 1>     False        False\n        <>      True        False\n       < >      True        False\n\nDone task #1: Determine_if_a_string_is_numeric - wallclock seconds: 0.171\n===============================================================================\n```\n\nOr, if the full %resource hash is loaded it will automatically feed input parameters to tasks that require them:  \n**raku RC-run.p6 Lucky\\_and\\_even\\_lucky\\_numbers** -q\n\n```\nRetrieving tasks\n1 Lucky_and_even_lucky_numbers\nGetting code from: http://rosettacode.org/wiki/Lucky_and_even_lucky_numbers#Raku\n\nTesting Lucky_and_even_lucky_numbers\n\nCommand line: raku Lucky_and_even_lucky_numbers.p6 20 , lucky\n\n79\n\nCommand line: raku Lucky_and_even_lucky_numbers.p6 1 20\n\n(1 3 7 9 13 15 21 25 31 33 37 43 49 51 63 67 69 73 75 79)\n\nCommand line: raku Lucky_and_even_lucky_numbers.p6 1 20 evenlucky\n\n(2 4 6 10 12 18 20 22 26 34 36 42 44 50 52 54 58 68 70 76)\n\nCommand line: raku Lucky_and_even_lucky_numbers.p6 6000 -6100\n\n(6009 6019 6031 6049 6055 6061 6079 6093)\n\nCommand line: raku Lucky_and_even_lucky_numbers.p6 6000 -6100 evenlucky\n\n(6018 6020 6022 6026 6036 6038 6050 6058 6074 6090 6092)\n\nDone Lucky_and_even_lucky_numbers\n===============================================================================\n```\n\nTry running a Go task - Command line: **raku RC-run.p6 -q --lang=go \"Determine if a string is numeric\"**\n\nFinds two task entries, downloads both and runs each:\n\n```\n1)  Determine if a string is numeric\nGetting code from: http://rosettacode.org/wiki/Determine_if_a_string_is_numeric#Go\n\nTesting Determine_if_a_string_is_numeric0\n\nCommand line: go run Determine_if_a_string_is_numeric0.go\n\nAre these strings numeric?\n     1 -> true\n  3.14 -> true\n  -100 -> true\n   1e2 -> true\n   NaN -> true\n  rose -> false\n\nDone task #1: Determine_if_a_string_is_numeric0 - wallclock seconds: 0.16\n\nTesting Determine_if_a_string_is_numeric1\n\nCommand line: go run Determine_if_a_string_is_numeric1.go\n\nAre these strings integers?\n    1 -> true\n  one -> false\n\nDone task #1: Determine_if_a_string_is_numeric1 - wallclock seconds: 0.147\n===============================================================================\n```"}]}
{"messages": [{"role": "user", "content": "A RosettaCode contributor is going on a long journey.\n\nTo ease the boredom of a long flight he takes his favourite programming language manual and a list of RosettaCode tasks,   but there's a catch:   the tasks have to be description only and not include all the solutions already supplied by other programmers.\n\nTask\n:   * Scrape   http://rosettacode.org/wiki/Category:Programming\\_Tasks   for all the tasks.\n    * Traverse the links.\n    * Extract the text or HTML between a tag with a class of   \"infobox\"   and the beginning of the table with the id of   \"toc\"."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.10\n\n```\nuse HTTP::UserAgent;\nuse Gumbo;\n\nmy $ua = HTTP::UserAgent.new;\nmy $taskfile = './RC_tasks.html';\n\n# Get list of Tasks\nsay \"Updating Programming_Tasks list...\";\nmy $page   = \"https://rosettacode.org/wiki/Category:Programming_Tasks\";\nmy $html   = $ua.get($page).content;\nmy $xmldoc = parse-html($html, :TAG<div>, :id<mw-pages>);\nmy @tasks  = parse-html($xmldoc[0].Str, :TAG<li>).Str.comb( /'/wiki/' <-[\"]>+ / )».substr(6); #\"\nmy $f      = open(\"./RC_Programming_Tasks.txt\", :w)  or die \"$!\\n\";\nnote \"Writing Programming_Tasks file...\";\n$f.print( @tasks.join(\"\\n\") );\n$f.close;\n\nsleep .5;\n\nfor 'Programming_Tasks' -> $category\n{ # Scrape info from each page.\n\n    note \"Loading $category file...\";\n    note \"Retreiving tasks...\";\n    my @entries = \"./RC_{$category}.txt\".IO.slurp.lines;\n\n    for @entries -> $title {\n        note $title;\n\n        # Get the raw page\n        my $html = $ua.get: \"https://rosettacode.org/wiki/{$title}\";\n\n        # Filter out the actual task description\n        $html.content ~~ m|'<div id=\"mw-content-text\" lang=\"en\" dir=\"ltr\" class=\"mw-content-ltr\"><div'\n                            .+? 'using any language you may know.</div>' (.+?) '<div id=\"toc\"'|;\n\n        my $task = cleanup $0.Str;\n\n        # save to a file\n        my $fh = $taskfile.IO.open :a;\n\n        $fh.put: \"<hr>\\n     $title\\n<hr>\\n$task\";\n\n        $fh.close;\n\n        sleep 3; # Don't pound the server\n    }\n}\n\nsub cleanup ( $string ) {\n    $string.subst( /^.+ '</div>'/, '' )\n}\n\n```\n\nAbridged sample output:\n\n---\n\n```\n    100_doors\n\n```\n\n---\n\nThere are 100 doors in a row that are all initially closed.\n\nYou make 100 <a href=\"/wiki/Rosetta\\_Code:Multiple\\_passes\" title=\"Rosetta Code:Multiple passes\">passes</a> by the doors.\n\nThe first time through, visit every door and  *toggle*  the door  (if the door is closed,  open it;   if it is open,  close it).\n\nThe second time, only visit every 2nd door   (door #2, #4, #6, ...),   and toggle it.\n\nThe third time, visit every 3rd door   (door #3, #6, #9, ...), etc,   until you only visit the 100th door.\n\nTask\n\nAnswer the question:   what state are the doors in after the last pass?   Which are open, which are closed?\n\n**<a href=\"/wiki/Rosetta\\_Code:Extra\\_credit\" title=\"Rosetta Code:Extra credit\">Alternate</a>:**\nAs noted in this page's   <a href=\"/wiki/Talk:100\\_doors\" title=\"Talk:100 doors\">discussion page</a>,   the only doors that remain open are those whose numbers are perfect squares.\n\nOpening only those doors is an   <a href=\"/wiki/Rosetta\\_Code:Optimization\" title=\"Rosetta Code:Optimization\">optimization</a>   that may also be expressed;\n\nhowever, as should be obvious, this defeats the intent of comparing implementations across programming languages.\n\n---\n\n```\n    15_Puzzle_Game\n\n```\n\n---\n\nTask\n\nImplement the <a href=\"http://en.wikipedia.org/wiki/15\\_puzzle\" class=\"extiw\" title=\"wp:15 puzzle\">Fifteen Puzzle Game</a>.\n\nRelated Task\n\n* <a href=\"/wiki/15\\_puzzle\\_solver\" title=\"15 puzzle solver\">15 Puzzle Solver</a>\n\n---\n\n```\n    15_puzzle_solver\n\n```\n\n---\n\nYour task is to write a program that finds a solution in the fewest single moves (no multimoves) possible to a random <a href=\"http://en.wikipedia.org/wiki/15\\_puzzle\" class=\"extiw\" title=\"wp:15 puzzle\">Fifteen Puzzle Game</a>.  \nFor this task you will be using the following puzzle:\n\n```\n15 14  1  6\n 9 11  4 12\n 0 10  7  3\n13  8  5  2\n```\n\nSolution:\n\n```\n 1  2  3  4\n 5  6  7  8\n 9 10 11 12\n13 14 15  0\n\n```\n\nThe output must show the moves' directions, like so: left, left, left, down, right... and so on.  \nThere are 2 solutions with 52 moves:  \nrrrulddluuuldrurdddrullulurrrddldluurddlulurruldrdrd  \nrrruldluuldrurdddluulurrrdlddruldluurddlulurruldrrdd  \nfinding either one, or both is an acceptable result.  \nsee: <a rel=\"nofollow\" class=\"external text\" href=\"http://www.rosettacode.org/wiki/15\\_puzzle\\_solver/Optimal\\_solution\">Pretty Print of Optimal Solution</a>\n\nExtra credit.\n\nSolve the following problem:\n\n```\n  0 12  9 13\n 15 11 10 14\n  3  7  2  5\n  4  8  6  1\n\n```\n\nRelated Task\n\n* <a href=\"/wiki/15\\_Puzzle\\_Game\" title=\"15 Puzzle Game\">15 puzzle game</a>\n\n**...and so on...**"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a   **rot-13**   function   (or procedure, class, subroutine, or other \"callable\" object as appropriate to your programming environment).\n\nOptionally wrap this function in a utility program   (like tr,   which acts like a common UNIX utility, performing a line-by-line rot-13 encoding of every line of input contained in each file listed on its command line,   or (if no filenames are passed thereon) acting as a filter on its   \"standard input.\"\n\n(A number of UNIX scripting languages and utilities, such as   *awk*   and   *sed*   either default to processing files in this way or have command line switches or modules to easily implement these wrapper semantics, e.g.,   Perl   and   Python).\n\nThe   **rot-13**   encoding is commonly known from the early days of Usenet \"Netnews\" as a way of obfuscating text to prevent casual reading of   spoiler   or potentially offensive material.\n\nMany news reader and mail user agent programs have built-in **rot-13** encoder/decoders or have the ability to feed a message through any external utility script for performing this (or other) actions.\n\nThe definition of the rot-13 function is to simply replace every letter of the ASCII alphabet with the letter which is \"rotated\" 13 characters \"around\" the 26 letter alphabet from its normal cardinal position   (wrapping around from   **z**   to   **a**   as necessary).\n\nThus the letters   **abc**   become   **nop**   and so on.\n\nTechnically **rot-13** is a   \"mono-alphabetic substitution cipher\"   with a trivial   \"key\".\n\nA proper implementation should work on upper and lower case letters, preserve case, and pass all non-alphabetic characters\nin the input stream through without alteration.\n\nRelated tasks\n\n* Caesar cipher\n* Substitution Cipher\n* Vigenère Cipher/Cryptanalysis\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @abc = 'a'..'z';\nmy $abc = [@abc».uc, @abc];\nput .trans: $abc => $abc».rotate(13) for lines\n```\n\nInput:\n\n```\nRosetta Code\n```\n\nOutput:\n\n```\nEbfrggn Pbqr\n```\n\nAs a one-liner:\n\n```\n$ raku -pe '.=trans: {$_ => $_».rotate(13)}({[$_».uc, @$_]}(\"a\"..\"z\"))'\n```"}]}
{"messages": [{"role": "user", "content": "A round-robin tournament is also known as an all-play-all-tournament; each participant plays every other participant once.\n\nFor N participants the number of rounds is N-1 if N is an even number. When there are an odd number of participants then each round one contestor has no opponent (AKA as a \"bye\"). The number of rounds is N in that case.\n\nTask\n\nWrite a program that prints out a tournament schedule for 12 participants (represented by numbers 1 to 12).\n\nSee also\n:   * **Wikipedia - Round-robin tournament**"}, {"role": "assistant", "content": "```\nmy @players = (1,0)[$_%2] .. $_ given 12;\nmy $half = +@players div 2;\nmy $round = 0;\n\nloop {\n    printf \"Round %2d: %s\\n\", ++$round, \"{ zip( @players[^$half], @players[$half..*].reverse ).map: { sprintf \"(%2d vs %-2d)\", |$_ } }\";\n    @players[1..*].=rotate(-1);\n    last if [<] @players;\n}\n\n```\n\nOutput:\n\n```\nRound  1: ( 1 vs 12) ( 2 vs 11) ( 3 vs 10) ( 4 vs 9 ) ( 5 vs 8 ) ( 6 vs 7 )\nRound  2: ( 1 vs 11) (12 vs 10) ( 2 vs 9 ) ( 3 vs 8 ) ( 4 vs 7 ) ( 5 vs 6 )\nRound  3: ( 1 vs 10) (11 vs 9 ) (12 vs 8 ) ( 2 vs 7 ) ( 3 vs 6 ) ( 4 vs 5 )\nRound  4: ( 1 vs 9 ) (10 vs 8 ) (11 vs 7 ) (12 vs 6 ) ( 2 vs 5 ) ( 3 vs 4 )\nRound  5: ( 1 vs 8 ) ( 9 vs 7 ) (10 vs 6 ) (11 vs 5 ) (12 vs 4 ) ( 2 vs 3 )\nRound  6: ( 1 vs 7 ) ( 8 vs 6 ) ( 9 vs 5 ) (10 vs 4 ) (11 vs 3 ) (12 vs 2 )\nRound  7: ( 1 vs 6 ) ( 7 vs 5 ) ( 8 vs 4 ) ( 9 vs 3 ) (10 vs 2 ) (11 vs 12)\nRound  8: ( 1 vs 5 ) ( 6 vs 4 ) ( 7 vs 3 ) ( 8 vs 2 ) ( 9 vs 12) (10 vs 11)\nRound  9: ( 1 vs 4 ) ( 5 vs 3 ) ( 6 vs 2 ) ( 7 vs 12) ( 8 vs 11) ( 9 vs 10)\nRound 10: ( 1 vs 3 ) ( 4 vs 2 ) ( 5 vs 12) ( 6 vs 11) ( 7 vs 10) ( 8 vs 9 )\nRound 11: ( 1 vs 2 ) ( 3 vs 12) ( 4 vs 11) ( 5 vs 10) ( 6 vs 9 ) ( 7 vs 8 )\n```"}]}
{"messages": [{"role": "user", "content": "**RPG**   =   Role Playing Game.\n\nYou're running a tabletop RPG, and your players are creating characters.\n\nEach character has six core attributes: strength, dexterity, constitution, intelligence, wisdom, and charisma.\n\nOne way of generating values for these attributes is to roll four, 6-sided dice (d6) and sum the three highest rolls, discarding the lowest roll.\n\nSome players like to assign values to their attributes in the order they're rolled.\n\nTo ensure generated characters don't put players at a disadvantage, the following requirements must be satisfied:\n\n* The total of all character attributes must be at least 75.\n* At least two of the attributes must be at least 15.\n\nHowever, this can require a lot of manual dice rolling. A programatic solution would be much faster.\n\nTask\n\nWrite a program that:\n\n1. Generates 4 random, whole values between 1 and 6.\n2. Saves the sum of the 3 largest values.\n3. Generates a total of 6 values this way.\n4. Displays the total, and all 6 values once finished.\n\n* The order in which each value was generated must be preserved.\n* The total of all 6 values must be at least 75.\n* At least 2 of the values must be 15 or more."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo Star version 2018.04.1\n\n```\nmy ( $min_sum, $hero_attr_min, $hero_count_min ) = 75, 15, 2;\nmy @attr-names = <Str Int Wis Dex Con Cha>;\n\nsub heroic { + @^a.grep: * >= $hero_attr_min }\n\nmy @attr;\nrepeat until @attr.sum     >= $min_sum\n         and heroic(@attr) >= $hero_count_min {\n\n    @attr = @attr-names.map: { (1..6).roll(4).sort(+*).skip(1).sum };\n}\n\nsay @attr-names Z=> @attr;\nsay \"Sum: {@attr.sum}, with {heroic(@attr)} attributes >= $hero_attr_min\";\n\n```\n\nOutput:\n\n```\n(Str => 15 Int => 16 Wis => 13 Dex => 11 Con => 15 Cha => 6)\nSum: 76, with 3 attributes >= 15\n\n```"}]}
{"messages": [{"role": "user", "content": "A daemon is a service that runs in the background independent of a users login session.\n\nDemonstrate how a program disconnects from the terminal to run as a daemon in the background.\n\nWrite a small program that writes a message roughly once a second to its stdout which should be redirected to a file.\n\nNote that in some language implementations it may not be possible to disconnect from the terminal, and instead the process needs to be started with stdout (and stdin) redirected to files before program start. If that is the case then a helper program to set up this redirection should be written in the language itself. A shell wrapper, as would be the usual solution on Unix systems, is not appropriate."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# Reference:\n# https://github.com/hipek8/p6-UNIX-Daemonize/\n\nuse v6;\nuse UNIX::Daemonize;\nuse File::Temp;\n\nmy ($output, $filehandle) = tempfile(:tempdir(\"/tmp\"),:!unlink) or die;\n\nsay \"Output now goes to \",$output;\n\ndaemonize();\n\nloop {\n   sleep(1);\n   spurt $output, DateTime.now.Str~\"\\n\", :append;\n}\n\n```\n\nOutput:\n\n```\nroot@ubuntu:~# su - david\n\ndavid@ubuntu:~$ ./dumper.p6\nOutput now goes to /tmp/x2ovx9JG8b\ndavid@ubuntu:~$ tail -f /tmp/x2ovx9JG8b\n2018-12-11T20:20:01.510484+08:00\n2018-12-11T20:20:02.513732+08:00\n2018-12-11T20:20:03.517063+08:00\n2018-12-11T20:20:04.520394+08:00\n2018-12-11T20:20:05.524871+08:00\n2018-12-11T20:20:06.528244+08:00\n2018-12-11T20:20:07.531985+08:00\n2018-12-11T20:20:08.537776+08:00\n2018-12-11T20:20:09.541606+08:00\n2018-12-11T20:20:10.545796+08:00\n2018-12-11T20:20:11.549047+08:00\n2018-12-11T20:20:12.552704+08:00\n^C\ndavid@ubuntu:~$ exit\nlogout\nroot@ubuntu:~# tail -f /tmp/x2ovx9JG8b\n2018-12-11T20:20:28.623690+08:00\n2018-12-11T20:20:29.626978+08:00\n2018-12-11T20:20:30.634309+08:00\n2018-12-11T20:20:31.637481+08:00\n2018-12-11T20:20:32.640794+08:00\n2018-12-11T20:20:33.643947+08:00\n2018-12-11T20:20:34.647146+08:00\n2018-12-11T20:20:35.651008+08:00\n^C\nroot@ubuntu:~# su - david\ndavid@ubuntu:~$ tail -f /tmp/x2ovx9JG8b\n2018-12-11T20:20:51.711357+08:00\n2018-12-11T20:20:52.715044+08:00\n2018-12-11T20:20:53.718921+08:00\n2018-12-11T20:20:54.722134+08:00\n2018-12-11T20:20:55.725970+08:00\n2018-12-11T20:20:56.729160+08:00\n2018-12-11T20:20:57.732376+08:00\n2018-12-11T20:20:58.735409+08:00\n2018-12-11T20:20:59.738886+08:00\n2018-12-11T20:21:00.743045+08:00\n2018-12-11T20:21:01.748113+08:00\n2018-12-11T20:21:02.753204+08:00\n2018-12-11T20:21:03.756665+08:00\n2018-12-11T20:21:04.759902+08:00\n^C\ndavid@ubuntu:~$ pkill -c moar\n1\n\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Run-length\\_encoding. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nGiven a string containing uppercase characters (A-Z), compress repeated 'runs' of the same character by storing the length of that run, and provide a function to reverse the compression.\n\nThe output can be anything, as long as you can recreate the input with it.\n\nExample\n:   Input: `WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW`\n:   Output: `12W1B12W3B24W1B14W`\n\nNote: the encoding step in the above example is the same as a step of the Look-and-say sequence."}, {"role": "assistant", "content": "(formerly Perl 6)\nNote that Raku regexes don't care about unquoted whitespace, and that backrefs\ncount from 0, not from 1.\n\n```\nsub encode($str) { $str.subst(/(.) $0*/, { $/.chars ~ $0 }, :g) }\n\nsub decode($str) { $str.subst(/(\\d+) (.)/, { $1 x $0 }, :g) }\n\nmy $e = encode('WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW');\nsay $e;\nsay decode($e);\n```\n\nOutput:\n\n```\n12W1B12W3B24W1B14W \nWWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW\n```"}]}
{"messages": [{"role": "user", "content": "Given the example Differential equation:\n\n:   y\n    ′\n    (\n    t\n    )\n    =\n    t\n    ⋅\n\n\n    y\n    (\n    t\n    )\n    {\\displaystyle {\\displaystyle y'(t)=t\\cdot {\\sqrt {y(t)}}}}\n\nWith initial condition:\n\n:   t\n\n    0\n    =\n    0\n    {\\displaystyle {\\displaystyle t\\_{0}=0}}\n     and \n\n    y\n\n    0\n    =\n    y\n    (\n\n    t\n\n    0\n    )\n    =\n    y\n    (\n    0\n    )\n    =\n    1\n    {\\displaystyle {\\displaystyle y\\_{0}=y(t\\_{0})=y(0)=1}}\n\nThis equation has an exact solution:\n\n:   y\n    (\n    t\n    )\n    =\n\n    1\n    16\n    (\n\n    t\n\n    2\n    +\n    4\n\n    )\n\n    2\n    {\\displaystyle {\\displaystyle y(t)={\\tfrac {1}{16}}(t^{2}+4)^{2}}}\n\nTask\n\nDemonstrate the commonly used explicit   fourth-order Runge–Kutta method   to solve the above differential equation.\n\n* Solve the given differential equation over the range \n\n  t\n  =\n  0\n  …\n  10\n  {\\displaystyle {\\displaystyle t=0\\ldots 10}}\n   with a step value of \n\n  δ\n  t\n  =\n  0.1\n  {\\displaystyle {\\displaystyle \\delta t=0.1}}\n   (101 total points, the first being given)\n* Print the calculated values of \n\n  y\n  {\\displaystyle {\\displaystyle y}}\n   at whole numbered \n\n  t\n  {\\displaystyle {\\displaystyle t}}\n  's (\n\n  0.0\n  ,\n  1.0\n  ,\n  …\n  10.0\n  {\\displaystyle {\\displaystyle 0.0,1.0,\\ldots 10.0}}\n  ) along with error as compared to the exact solution.\n\nMethod summary\n\nStarting with a given \n\ny\n\nn\n{\\displaystyle {\\displaystyle y\\_{n}}}\n and \n\nt\n\nn\n{\\displaystyle {\\displaystyle t\\_{n}}}\n calculate:\n\n:   δ\n\n    y\n\n    1\n    =\n    δ\n    t\n    ⋅\n\n    y\n    ′\n    (\n\n    t\n\n    n\n    ,\n\n    y\n\n    n\n    )\n\n    {\\displaystyle {\\displaystyle \\delta y\\_{1}=\\delta t\\cdot y'(t\\_{n},y\\_{n})\\quad }}\n:   δ\n\n    y\n\n    2\n    =\n    δ\n    t\n    ⋅\n\n    y\n    ′\n    (\n\n    t\n\n    n\n    +\n\n    1\n    2\n    δ\n    t\n    ,\n\n    y\n\n    n\n    +\n\n    1\n    2\n    δ\n\n    y\n\n    1\n    )\n    {\\displaystyle {\\displaystyle \\delta y\\_{2}=\\delta t\\cdot y'(t\\_{n}+{\\tfrac {1}{2}}\\delta t,y\\_{n}+{\\tfrac {1}{2}}\\delta y\\_{1})}}\n:   δ\n\n    y\n\n    3\n    =\n    δ\n    t\n    ⋅\n\n    y\n    ′\n    (\n\n    t\n\n    n\n    +\n\n    1\n    2\n    δ\n    t\n    ,\n\n    y\n\n    n\n    +\n\n    1\n    2\n    δ\n\n    y\n\n    2\n    )\n    {\\displaystyle {\\displaystyle \\delta y\\_{3}=\\delta t\\cdot y'(t\\_{n}+{\\tfrac {1}{2}}\\delta t,y\\_{n}+{\\tfrac {1}{2}}\\delta y\\_{2})}}\n:   δ\n\n    y\n\n    4\n    =\n    δ\n    t\n    ⋅\n\n    y\n    ′\n    (\n\n    t\n\n    n\n    +\n    δ\n    t\n    ,\n\n    y\n\n    n\n    +\n    δ\n\n    y\n\n    3\n    )\n\n    {\\displaystyle {\\displaystyle \\delta y\\_{4}=\\delta t\\cdot y'(t\\_{n}+\\delta t,y\\_{n}+\\delta y\\_{3})\\quad }}\n\nthen:\n\n:   y\n\n    n\n    +\n    1\n    =\n\n    y\n\n    n\n    +\n\n    1\n    6\n    (\n    δ\n\n    y\n\n    1\n    +\n    2\n    δ\n\n    y\n\n    2\n    +\n    2\n    δ\n\n    y\n\n    3\n    +\n    δ\n\n    y\n\n    4\n    )\n    {\\displaystyle {\\displaystyle y\\_{n+1}=y\\_{n}+{\\tfrac {1}{6}}(\\delta y\\_{1}+2\\delta y\\_{2}+2\\delta y\\_{3}+\\delta y\\_{4})}}\n:   t\n\n    n\n    +\n    1\n    =\n\n    t\n\n    n\n    +\n    δ\n    t\n\n    {\\displaystyle {\\displaystyle t\\_{n+1}=t\\_{n}+\\delta t\\quad }}"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.03\n\n```\nsub runge-kutta(&yp) {\n    return -> \\t, \\y, \\δt {\n        my $a = δt * yp( t, y );\n        my $b = δt * yp( t + δt/2, y + $a/2 );\n        my $c = δt * yp( t + δt/2, y + $b/2 );\n        my $d = δt * yp( t + δt, y + $c );\n        ($a + 2*($b + $c) + $d) / 6;\n    }\n}\n \nconstant δt = .1;\nmy &δy = runge-kutta { $^t * sqrt($^y) };\n \nloop (\n    my ($t, $y) = (0, 1);\n    $t <= 10;\n    ($t, $y) »+=« (δt, δy($t, $y, δt))\n) {\n    printf \"y(%2d) = %12f ± %e\\n\", $t, $y, abs($y - ($t**2 + 4)**2 / 16)\n    if $t %% 1;\n}\n\n```\n\nOutput:\n\n```\ny( 0) =     1.000000 ± 0.000000e+00\ny( 1) =     1.562500 ± 1.457219e-07\ny( 2) =     3.999999 ± 9.194792e-07\ny( 3) =    10.562497 ± 2.909562e-06\ny( 4) =    24.999994 ± 6.234909e-06\ny( 5) =    52.562489 ± 1.081970e-05\ny( 6) =    99.999983 ± 1.659460e-05\ny( 7) =   175.562476 ± 2.351773e-05\ny( 8) =   288.999968 ± 3.156520e-05\ny( 9) =   451.562459 ± 4.072316e-05\ny(10) =   675.999949 ± 5.098329e-05\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate a language's ability for programs to execute code written in the language provided at runtime.\n\nShow what kind of program fragments are permitted (e.g. expressions vs. statements), and how to get values in and out (e.g. environments, arguments, return values), if applicable what lexical/static environment the program is evaluated in, and what facilities for restricting (e.g. sandboxes, resource limits) or customizing (e.g. debugging facilities) the execution.\n\nYou may not invoke a separate evaluator program, or invoke a compiler and then its output, unless the interface of that program, and the syntax and means of executing it, are considered part of your language/library/platform.\n\nFor a more constrained task giving a specific program fragment to evaluate, see Eval in environment."}, {"role": "assistant", "content": "(formerly Perl 6)\nAny syntactically valid sequence of statements may be run, and the snippet to be run can see its outer lexical scope at the point of the eval:\n\n```\nuse MONKEY-SEE-NO-EVAL;\n\nmy ($a, $b) = (-5, 7);\nmy $ans = EVAL 'abs($a * $b)';  # => 35\n\n```\n\nUnlike in Perl 5, eval in Raku only compiles and executes the string, but does not trap exceptions. You must say try eval to get that behavior (or supply a CATCH block within the text to be evaluated)."}]}
{"messages": [{"role": "user", "content": "Given a program in the language (as a string or AST) with a free variable named x (or another name if that is not valid syntax), evaluate it with x bound to a provided value, then evaluate it again with x bound to another provided value, then subtract the result of the first from the second and return or print it.\n\nDo so in a way which:\n\n* does not involve string manipulation of the input source code\n* is plausibly extensible to a runtime-chosen set of bindings rather than just x\n* does not make x a *global* variable\n\nor note that these are impossible.\n\nSee also\n\n* For more general examples and language-specific details, see Eval.\n* Dynamic variable names is a similar task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-12-22\n\nFor security, you must explicitly allow use of 'EVAL'.\n\n```\nuse MONKEY-SEE-NO-EVAL;\nsub eval_with_x($code, *@x) { [R-] @x.map: -> \\x { EVAL $code } }\n\nsay eval_with_x('3 * x', 5, 10);      # Says \"15\".\nsay eval_with_x('3 * x', 5, 10, 50);  # Says \"105\".\n\n```"}]}
{"messages": [{"role": "user", "content": "A **Ruth–Aaron** pair consists of two consecutive integers (e.g., 714 and 715) for which the sums of the prime divisors of each integer are equal. So called because 714 is Babe Ruth's lifetime home run record; Hank Aaron's 715th home run broke this record and 714 and 715 have the same prime divisor sum.\n\nA **Ruth–Aaron** triple consists of ***three*** consecutive integers with the same properties.\n\nThere is a second variant of **Ruth–Aaron** numbers, one which uses prime *factors* rather than prime *divisors*. The difference; divisors are unique, factors may be repeated. The 714, 715 pair appears in both, so the name still fits.\n\nIt is common to refer to each **Ruth–Aaron** group by the first number in it.\n\nTask\n\n* Find and show, here on this page, the first **30** **Ruth-Aaron numbers** (factors).\n\n* Find and show, here on this page, the first **30** **Ruth-Aaron numbers** (divisors).\n\nStretch\n\n* Find and show the first **Ruth-Aaron triple** (factors).\n\n* Find and show the first **Ruth-Aaron triple** (divisors).\n\nSee also\n\n* Wikipedia: Ruth–Aaron pair * OEIS:A006145 - Ruth-Aaron numbers (1): sum of prime divisors of n = sum of prime divisors of n+1 * OEIS:A039752 - Ruth-Aaron numbers (2): sum of prime divisors of n = sum of prime divisors of n+1 (both taken with multiplicity)"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\n\nmy @pf  = lazy (^∞).hyper(:1000batch).map: *.&prime-factors.sum;\nmy @upf = lazy (^∞).hyper(:1000batch).map: *.&prime-factors.unique.sum;\n\n# Task: < 1 second\nput \"First 30 Ruth-Aaron numbers (Factors):\\n\" ~\n(1..∞).grep( { @pf[$_] == @pf[$_ + 1] } )[^30];\n\nput \"\\nFirst 30 Ruth-Aaron numbers (Divisors):\\n\" ~\n(1..∞).grep( { @upf[$_] == @upf[$_ + 1] } )[^30];\n\n# Stretch: ~ 5 seconds\nput \"\\nFirst Ruth-Aaron triple (Factors):\\n\" ~\n(1..∞).first: { @pf[$_] == @pf[$_ + 1] == @pf[$_ + 2] }\n\n# Really, really, _really_ slow. 186(!) minutes... but with no cheating or \"leg up\".\nput \"\\nFirst Ruth-Aaron triple (Divisors):\\n\" ~\n(1..∞).first: { @upf[$_] == @upf[$_ + 1] == @upf[$_ + 2] }\n\n```\n\nOutput:\n\n```\nFirst 30 Ruth-Aaron numbers (Factors):\n5 8 15 77 125 714 948 1330 1520 1862 2491 3248 4185 4191 5405 5560 5959 6867 8280 8463 10647 12351 14587 16932 17080 18490 20450 24895 26642 26649\n\nFirst 30 Ruth-Aaron numbers (Divisors):\n5 24 49 77 104 153 369 492 714 1682 2107 2299 2600 2783 5405 6556 6811 8855 9800 12726 13775 18655 21183 24024 24432 24880 25839 26642 35456 40081\n\nFirst Ruth-Aaron triple (Factors):\n417162\n\nFirst Ruth-Aaron triple (Divisors):\n89460294\n```"}]}
{"messages": [{"role": "user", "content": "S-Expressions   are one convenient way to parse and store data.\n\nTask\n\nWrite a simple reader and writer for S-Expressions that handles quoted and unquoted strings, integers and floats.\n\nThe reader should read a single but nested S-Expression from a string and store it in a suitable datastructure (list, array, etc).\n\nNewlines and other whitespace may be ignored unless contained within a quoted string.\n\n“()”   inside quoted strings are not interpreted, but treated as part of the string.\n\nHandling escaped quotes inside a string is optional;   thus “(foo\"bar)” maybe treated as a string “foo\"bar”, or as an error.\n\nFor this, the reader need not recognize “\\” for escaping, but should, in addition, recognize numbers if the language has appropriate datatypes.\n\nLanguages that support it may treat unquoted strings as symbols.\n\nNote that with the exception of “()\"” (“\\” if escaping is supported) and whitespace there are no special characters. Anything else is allowed without quotes.\n\nThe reader should be able to read the following input\n\n```\n((data \"quoted data\" 123 4.5)\n (data (!@# (4.5) \"(more\" \"data)\")))\n\n```\n\nand turn it into a native datastructure. (see the Pike, Python and Ruby implementations for examples of native data structures.)\n\nThe writer should be able to take the produced list and turn it into a new S-Expression.\nStrings that don't contain whitespace or parentheses () don't need to be quoted in the resulting S-Expression, but as a simplification, any string may be quoted.\n\nExtra Credit\n\nLet the writer produce pretty printed output with indenting and line-breaks."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.02\n\nThis parses the task, but it isn't really a good lisp parser, because it always wants whitespace between lists, so `(()())` will fail ( `(() ())` wont)\n\n```\ngrammar S-Exp {\n  rule TOP    {^ <s-list> $};\n\n  token s-list { '(' ~ ')' [ <in_list>+ % [\\s+] | '' ] }\n  token in_list { <s-token> | <s-list> } \n \n  proto token s-token {*}\n  token s-token:sym<Num>    {\\d*\\.?\\d+}\n  token s-token:sym<String> {'\"' ['\\\"' |<-[\\\\\"]>]*? '\"'} #'\n  token s-token:sym<Atom>   {<-[()\\s]>+}\n \n}\n \n# The Actions class, for each syntactic rule there is a method\n# that stores some data in the abstract syntax tree with make\nclass S-Exp::ACTIONS {\n  method TOP ($/) {make $<s-list>.ast}\n  method s-list ($/) {make [$<in_list>».ast]}\n  method in_list ($/) {make $/.values[0].ast}\n \n  method s-token:sym<Num> ($/){make +$/}\n  method s-token:sym<String> ($/){make ~$/.substr(1,*-1)}\n  method s-token:sym<Atom> ($/){make ~$/}\n}\n \nmulti s-exp_writer (Positional $ary) {'(' ~ $ary.map(&s-exp_writer).join(' ') ~ ')'}\nmulti s-exp_writer (Numeric    $num) {~$num}\nmulti s-exp_writer (Str        $str) {\n  return $str unless $str ~~ /<[(\")]>|\\s/;\n  return '()' if $str eq '()';\n  '\"' ~ $str.subst('\"', '\\\"' ) ~ '\"';\n}\n \n \nmy $s-exp = '((data \"quoted data\" 123 4.5)\n (data (!@# (4.5) \"(more\" \"data)\")))';\n \nmy $actions = S-Exp::ACTIONS.new();\nmy $raku_array = (S-Exp.parse($s-exp, :$actions)).ast;\n \nsay \"the expression:\\n$s-exp\\n\";\nsay \"the Raku expression:\\n{$raku_array.raku}\\n\";\nsay \"and back:\\n{s-exp_writer($raku_array)}\";\n\n```\n\nOutput:\n\n```\nthe expression:\n((data \"quoted data\" 123 4.5)\n (data (!@# (4.5) \"(more\" \"data)\")))\n\nthe Raku expression:\n[[\"data\", \"quoted data\", \"123\", 9/2], [\"data\", [\"!\\@#\", [9/2], \"(more\", \"data)\"]]]\n\nand back:\n((data \"quoted data\" 123 4.5) (data (!@# (4.5) \"(more\" \"data)\")))\n```"}]}
{"messages": [{"role": "user", "content": "Implementation of   interval arithmetic   and more generally fuzzy number arithmetic require operations that yield safe upper and lower bounds of the exact result.\n\nFor example, for an addition, it is the operations    +↑    and    +↓    defined as:    *a* +↓ *b* ≤ *a* + *b* ≤ *a* +↑ *b*.\n\nAdditionally it is desired that the width of the interval    (*a* +↑ *b*) - (*a* +↓ *b*)    would be about the machine epsilon after removing the exponent part.\n\nDifferently to the standard floating-point arithmetic, safe interval arithmetic is **accurate** (but still imprecise).\n\nI.E.:   the result of each defined operation contains (though does not identify) the exact mathematical outcome.\n\nUsually a   FPU's   have machine    +,-,\\*,/    operations accurate within the machine precision.\n\nTo illustrate it, let us consider a machine with decimal floating-point arithmetic that has the precision is **3** decimal points.\n\nIf the result of the machine addition is    1.23,    then the exact mathematical result is within the interval    ]1.22, 1.24[.\n\nWhen the machine rounds towards zero, then the exact result is within    [1.23,1.24[.    This is the basis for an implementation of safe addition.\n\nTask;\n\nShow how    +↓    and    +↑    can be implemented in your language using the standard floating-point type.\n\nDefine an interval type based on the standard floating-point one,   and implement an interval-valued addition of two floating-point numbers considering them exact, in short an operation that yields the interval    [*a* +↓ *b*, *a* +↑ *b*]."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nRaku uses 64 bit IEEE floating points numbers which provide 53 binary digits\nof accuracy. If you insist on using floats your answer will be accurate in the range\n± 1.1102230246251565e-16. Raku actually makes it somewhat difficult to output\nan exact stringified float with more than 15 digits of accuracy. It automatically\nrounds since it doesn't try to pretend that it is more accurate than that.\n\nIf you really DO need very high precision and accuracy, Raku has native\nbuilt-in Rational number support. Rationals are the ratio of two integers, and\nare always exact. Standard Rats are limited to 64 bits of precision in the\ndenominator. On overflow, they will downgrade to a float (Num).\nFatRats have unlimited denominators.\n\nThere is no need to load any external libraries or force the use of Rats. Unless\nyou force it otherwise, decimal number are always stored as Rats as long as they\nwill fit within the denominator limit.\n\nYou can see the two integers making up the ratio of a Rat (or FatRat) using the\n.nude method (**nu**merator, **de**nominator).\n\nRats and FatRats by default stringify to a fixed number of places for\nnon-terminating fractions and the same number of digits as the denominator for\nterminating fractions. If you need more control over stringification, load the\nmodule Rat::Precise for configurable stringification. Rat::Precise *only* affects\nstringification, not calculation. Calculations are always done at full (exact) precision.\n\n```\nsay \"Floating points: (Nums)\";\nsay \"Error: \" ~ (2**-53).Num;\n\nsub infix:<±+> (Num $a, Num $b) {\n    my \\ε = (2**-53).Num;\n    $a - ε + $b, $a + ε + $b,\n}\n\nprintf \"%4.16f .. %4.16f\\n\", (1.14e0 ±+ 2e3);\n\nsay \"\\nRationals:\";\n\nsay \".1 + .2 is exactly equal to .3: \", .1 + .2 === .3;\n\nsay \"\\nLarge denominators require explicit coercion to FatRats:\";\nsay \"Sum of inverses of the first 500 natural numbers:\";\nmy $sum = sum (1..500).map: { FatRat.new(1,$_) };\nsay $sum;\nsay $sum.nude;\n\n{\n    say \"\\nRat stringification may not show full precision for terminating fractions by default.\";\n    say \"Use a module to get full precision.\";\n    use Rat::Precise; # module loading is scoped to the enclosing block\n    my $rat = 1.5**63;\n    say \"\\nRaku default stringification for 1.5**63:\\n\" ~ $rat; # standard stringification\n    say \"\\nRat::Precise stringification for 1.5**63:\\n\" ~$rat.precise; # full precision\n}\n\n```\n\nOutput:\n\n```\nFloating points: (Nums)\nError: 1.1102230246251565e-16\n2001.1400000000000000 .. 2001.1400000000000000\n\nRationals:\n.1 + .2 is exactly equal to .3: True\n\nLarge denominators require explicit coercion to FatRats:\nSum of inverses of the first 500 natural numbers:\n6.79282342999052460298928714536797369481981381439677911664308889685435662379055049245764940373586560391756598584375065928223134688479711715030249848314807266844371012370203147722209400570479644295921001097190193214586271\n(6633384299891198065461433023874214660151383488987829406868700907802279376986364154005690172480537248349310365871218591743641116766728139494727637850449054802989613344274500453825922847052235859615378238909694581687099 976528297586037954584851660253897317730151176683856787284655867127950765610716178591036797598551026470244168088645451676177520177514977827924165875515464044694152207479405310883385229609852607806002629415184926954240)\n\nRat stringification may not show full precision for terminating fractions by default.\nUse a module to get full precision.\n\nRaku default stringification for 1.5**63:\n124093581919.64894769782737365038\n\nRat::Precise stringification for 1.5**63:\n124093581919.648947697827373650380188008224280338254175148904323577880859375\n\n```"}]}
{"messages": [{"role": "user", "content": "A prime number *p* is a Sophie Germain prime if 2*p* + 1 is also prime.  \nThe number 2*p* + 1 associated with a Sophie Germain prime is called a **safe prime**.\n\nTask\n\nGenerate the first   **50**   Sophie Germain prime numbers.\n\nSee also\n\n* Wikipedia: Sophie Germain primes * OEIS:A005384 - Sophie Germain primes * Related Task: Safe\\_primes\\_and\\_unsafe\\_primes"}, {"role": "assistant", "content": "```\nput join \"\\n\", (^∞ .grep: { .is-prime && ($_*2+1).is-prime } )[^50].batch(10)».fmt: \"%4d\";\n\n```\n\nOutput:\n\n```\n   2    3    5   11   23   29   41   53   83   89\n 113  131  173  179  191  233  239  251  281  293\n 359  419  431  443  491  509  593  641  653  659\n 683  719  743  761  809  911  953 1013 1019 1031\n1049 1103 1223 1229 1289 1409 1439 1451 1481 1499\n```"}]}
{"messages": [{"role": "user", "content": "Does the language implementation allow for a \"safer mode\" of execution? Usually termed **Safe mode**, a more realistic view is probably **Safer mode** or **restricted mode**. It is one thing to place restrictions on execution, and another thing entirely to allow execution of scripts from untrusted sources and assume nothing untoward will happen.\n\nAlong with a simple yes/no answer, describe what features are restricted when running in safe mode."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n*Mostly a cut-n-paste from the Untrusted environment task.*\n\nRaku doesn't really provide a high security mode for untrusted environments. By default, Raku is sort of a walled garden. It is difficult to access memory directly, especially in locations not controlled by the Raku interpreter, so unauthorized memory access is unlikely to be a threat with default Raku commands and capabilities.\n\nIt is possible (and quite easy) to run Raku with a restricted setting which will disable many IO commands that can be used to access or modify things outside of the Raku interpreter. However, a determined bad actor could theoretically work around the restrictions, especially if the nativecall interface is available. The nativecall interface allows directly calling in to and executing code from C libraries so anything possible in C is now possible in Raku. This is great for all of the power it provides, but along with that comes the responsibility and inherent security risk. The same issue arises with unrestricted loading of modules. If modules can be loaded, especially from arbitrary locations, then any and all restriction imposed by the setting can be worked around.\n\nThe restricted setting is modifiable, but by default places restrictions on or completely disables the following things:\n\nUser Subroutines (disabled)\n\n:   * sub chmod() *modify filesystem permissions*\n    * sub copy() *copy a file*\n    * sub link() *create a link to a file*\n    * sub mkdir() *make a filesystem directory*\n    * sub open() *open a filesystem location / file*\n    * sub pipe() *open a pipe*\n    * sub QX() *execute arbitrary code*\n    * sub rename() *rename a file*\n    * sub rmdir() *remove a directory*\n    * sub run() *run arbitrary code*\n    * sub shell() *execute code in a shell*\n    * sub socket() *open a socket*\n    * sub spurt() *write a file*\n    * sub symlink() *create a symbolic link to a location*\n    * sub unlink() *delete a file*\n\nInternal Subroutines (disabled)\n\n:   * sub CHANGE-DIRECTORY *change directory*\n    * sub CHMOD-PATH *change permissions*\n    * sub COPY-FILE *copy a file*\n    * sub MAKE-DIR *make a directory*\n    * sub REMOVE-DIR *remove a directory*\n    * sub RENAME-PATH *rename a directory*\n    * sub SYMLINK-PATH *create a symbolic link*\n    * sub UNLINK-PATH *delete a file*\n\nClasses (disabled)\n\n:   * class IO::CatHandle *streaming file handle*\n    * class IO::Handle *file handle*\n    * class IO::Path *filesystem path*\n    * class IO::Pipe *OS pipe*\n    * class IO::Socket *OS socket*\n    * class IO::Socket::INET *Network socket*\n    * class NativeCall *Nativecall interface to foreign code (C mostly)*\n    * class Proc *OS Process*\n    * class Proc::Async *Asynchronous OS Process*\n\nMethod Mixins / Roles (locked down so can't be overridden)\n\n:   * method FALLBACK() *handle unknown method calls*\n    * method new() *create a new instance*\n    * method gist() *display method*\n\nReally, if you want to lock down a Raku instance so it is \"safe\" for unauthenticated, untrusted, general access, you are better off running it in some kind of locked down virtual machine or sandbox managed by the operating system rather than trying to build an ad hoc \"safe\" environment."}]}
{"messages": [{"role": "user", "content": "Definitions\n:   :   * A   **safe prime**   is a prime   **p**   and where   **(p-1)/2**   is also prime.\n        * The corresponding prime  **(p-1)/2**   is known as a   **Sophie Germain**   prime.\n        * An   **unsafe prime**   is a prime   **p**   and where   **(p-1)/2**   *isn't*   a prime.\n        * An   **unsafe prime**   is a prime that   *isn't*   a   **safe**   prime.\n\nTask\n:   :   * Find and display (on one line) the first   **35**   safe primes.\n        * Find and display the   *count*   of the safe primes below   1,000,000.\n        * Find and display the   *count*   of the safe primes below 10,000,000.\n        * Find and display (on one line) the first   **40**   unsafe primes.\n        * Find and display the   *count*   of the unsafe primes below   1,000,000.\n        * Find and display the   *count*   of the unsafe primes below 10,000,000.\n        * (Optional)   display the   *counts*   and   \"below numbers\"   with commas.\n\nShow all output here.\n\nRelated Task\n:   :   * strong and weak primes.\n\nAlso see\n:   :   * The OEIS article:     safe   primes.\n        * The OEIS article:   unsafe primes."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.08\n\nRaku has a built-in method .is-prime to test for prime numbers. It's great for testing individual numbers or to find/filter a few thousand numbers, but when you are looking for millions, it becomes a drag. No fear, the Raku ecosystem has a fast prime sieve module available which can produce 10 million primes in a few seconds. Once we have the primes, it is just a small matter of filtering and formatting them appropriately.\n\n```\nsub comma { $^i.flip.comb(3).join(',').flip }\n\nuse Math::Primesieve;\n\nmy $sieve = Math::Primesieve.new;\n\nmy @primes = $sieve.primes(10_000_000);\n\nmy %filter = @primes.Set;\n\nmy $primes = @primes.classify: { %filter{($_ - 1)/2} ?? 'safe' !! 'unsafe' };\n\nfor 'safe', 35, 'unsafe', 40 -> $type, $quantity {\n    say \"The first $quantity $type primes are:\";\n\n    say $primes{$type}[^$quantity]».&comma;\n\n    say \"The number of $type primes up to {comma $_}: \",\n    comma $primes{$type}.first(* > $_, :k) // +$primes{$type} for 1e6, 1e7;\n\n    say '';\n}\n\n```\n\nOutput:\n\n```\nThe first 35 safe primes are:\n(5 7 11 23 47 59 83 107 167 179 227 263 347 359 383 467 479 503 563 587 719 839 863 887 983 1,019 1,187 1,283 1,307 1,319 1,367 1,439 1,487 1,523 1,619)\nThe number of safe primes up to 1,000,000: 4,324\nThe number of safe primes up to 10,000,000: 30,657\n\nThe first 40 unsafe primes are:\n(2 3 13 17 19 29 31 37 41 43 53 61 67 71 73 79 89 97 101 103 109 113 127 131 137 139 149 151 157 163 173 181 191 193 197 199 211 223 229 233)\nThe number of unsafe primes up to 1,000,000: 74,174\nThe number of unsafe primes up to 10,000,000: 633,922\n```"}]}
{"messages": [{"role": "user", "content": "Five sailors are shipwrecked on an island and collect a large pile of coconuts during the day.\n\nThat night the first sailor wakes up and decides to take his first share early so tries to divide the pile of coconuts equally into five piles but finds that there is one coconut left over, so he tosses it to a monkey and then hides \"his\" one of the five equally sized piles of coconuts and pushes the other four piles together to form a single visible pile of coconuts again and goes to bed.\n\nTo cut a long story short, each of the sailors in turn gets up once during the night and performs the same actions of dividing the coconut pile into five, finding that one coconut is left over and giving that single remainder coconut to the monkey.\n\nIn the morning (after the surreptitious and separate action of each of the five sailors during the night), the remaining coconuts are divided into five equal piles for each of the sailors, whereupon it is found that the pile of coconuts divides equally amongst the sailors with no remainder. (Nothing for the monkey in the morning.)\n\nThe task\n\n1. Calculate the minimum possible size of the initial pile of coconuts collected during the first day.\n2. Use a method that assumes an answer is possible, and then applies the constraints of the tale to see if it is correct. (I.e. no applying some formula that generates the correct answer without integer divisions and remainders and tests on remainders; but constraint solvers *are* allowed.)\n3. Calculate the size of the initial pile of coconuts if six sailors were marooned and went through a similar process (but split into six piles instead of five of course).\n4. Show your answers here.\n\nExtra credit (optional)\n\n* Give some indication of the number of coconuts each sailor hides during the night.\n\nNote\n\n* Of course the tale is told in a world where the collection of any amount of coconuts in a day and multiple divisions of the pile, etc can occur in time fitting the story line, so as not to affect the mathematics.\n* The tale is also told in a version where the monkey also gets a coconut in the morning. This is *not* that tale!\n\nC.f\n\n* Monkeys and Coconuts - Numberphile (Video) Analytical solution.\n* A002021: Pile of coconuts problem The On-Line Encyclopedia of Integer Sequences. (Although some of its references may use the alternate form of the tale)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015.09\n\nThere is nowhere in the spec where it explicitly states that the sailors cannot equally share zero coconuts in the morning. Actually, The On-Line Encyclopedia of Integer Sequences A002021 considers the cases for 1 and 2 sailors equally sharing zero coconuts in the morning to be the correct answer.\n\nThis will test combinations of sailors and coconuts to see if they form a valid pairing. The first 6 are done using brute force, testing every combination until a valid one is found. For cases of 7 to 15 sailors, it uses a carefully crafted filter to drastically reduce the number of trials needed to find a valid case (to one, as it happens... :-) )\n\n```\nmy @ones = flat 'th', 'st', 'nd', 'rd', 'th' xx 6;\nmy @teens = 'th' xx 10;\nmy @suffix = lazy flat (@ones, @teens, @ones xx 8) xx *;\n\n# brute force the first six\nfor 1 .. 6 -> $sailors { for $sailors .. * -> $coconuts { last if check( $sailors, $coconuts ) } }\n\n# finesse 7 through 15\nfor 7 .. 15 -> $sailors { next if check( $sailors, coconuts( $sailors ) ) }\n\nsub is_valid ( $sailors is copy, $nuts is copy ) {\n    return 0, 0 if $sailors == $nuts == 1;\n    my @shares;\n    for ^$sailors {\n        return () unless $nuts % $sailors == 1;\n        push @shares, ($nuts - 1) div $sailors;\n        $nuts -= (1 + $nuts div $sailors);\n    }\n    push @shares, $nuts div $sailors;\n    return @shares if !?($nuts % $sailors);\n}\n\nsub check ($sailors, $coconuts) {\n    if my @piles = is_valid($sailors, $coconuts) {\n        say \"\\nSailors $sailors: Coconuts $coconuts:\";\n        for ^(@piles - 1) -> $k {\n             say \"{$k+1}@suffix[$k+1] takes @piles[$k], gives 1 to the monkey.\"\n        }\n        say \"The next morning, each sailor takes @piles[*-1]\\nwith none left over for the monkey.\";\n        return True;\n    }\n    False;\n}\n\nmulti sub coconuts ( $sailors where { $sailors % 2 == 0 } ) { ($sailors - 1) * ($sailors ** $sailors - 1) }\nmulti sub coconuts ( $sailors where { $sailors % 2 == 1 } ) { $sailors ** $sailors - $sailors + 1 }\n\n```\n\nOutput:\n\n```\nSailors 1: Coconuts 1:\n1st takes 0, gives 1 to the monkey.\nThe next morning, each sailor takes 0\nwith none left over for the monkey.\n\nSailors 2: Coconuts 3:\n...\n\nSailors 5: Coconuts 3121:\n1st takes 624, gives 1 to the monkey.\n2nd takes 499, gives 1 to the monkey.\n3rd takes 399, gives 1 to the monkey.\n4th takes 319, gives 1 to the monkey.\n5th takes 255, gives 1 to the monkey.\nThe next morning, each sailor takes 204\nwith none left over for the monkey.\n\nSailors 6: Coconuts 233275:\n1st takes 38879, gives 1 to the monkey.\n2nd takes 32399, gives 1 to the monkey.\n3rd takes 26999, gives 1 to the monkey.\n4th takes 22499, gives 1 to the monkey.\n5th takes 18749, gives 1 to the monkey.\n6th takes 15624, gives 1 to the monkey.\nThe next morning, each sailor takes 13020\nwith none left over for the monkey.\n\nSailors 7: Coconuts 823537:\n...\n\nSailors 15: Coconuts 437893890380859361:\n...\n\n```"}]}
{"messages": [{"role": "user", "content": "Write a routine that will compare the leaves (\"fringe\") of two binary trees to determine whether they are the same list of leaves when visited left-to-right. The structure or balance of the trees does not matter; only the number, order, and value of the leaves is important.\n\nAny solution is allowed here, but many computer scientists will consider it inelegant to collect either fringe in its entirety before starting to collect the other one. In fact, this problem is usually proposed in various forums as a way to show off various forms of concurrency (tree-rotation algorithms have also been used to get around the need to collect one tree first). Thinking of it a slightly different way, an elegant solution is one that can perform the minimum amount of work to falsify the equivalence of the fringes when they differ somewhere in the middle, short-circuiting the unnecessary additional traversals and comparisons.\n\nAny representation of a binary tree is allowed, as long as the nodes are orderable, and only downward links are used (for example, you may not use parent or sibling pointers to avoid recursion)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nUnlike in Perl 5, where => is just a synonym for comma, in Raku it creates a true Pair object. So here we use Pair objects for our \"cons\" cells, just as if we were doing this in Lisp. We use the gather/take construct to harvest the leaves lazily as the elements are visited with a standard recursive algorithm, using multiple dispatch to differentiate nodes from leaves. The eqv value equivalence is applied to the two lists in parallel.\n\n```\nsub fringe ($tree) {\n    multi sub fringey (Pair $node) { fringey $_ for $node.kv; }\n    multi sub fringey ( Any $leaf) { take $leaf; }\n\n    gather fringey $tree;\n}\n\nsub samefringe ($a, $b) { fringe($a) eqv fringe($b) }\n\n# Testing:\n\nmy $a = 1 => 2 => 3 => 4 => 5 => 6 => 7 => 8;\nmy $b = 1 => (( 2 => 3 ) => (4 => (5 => ((6 => 7) => 8))));\nmy $c = (((1 => 2) => 3) => 4) => 5 => 6 => 7 => 8;\n\nmy $x = 1 => 2 => 3 => 4 => 5 => 6 => 7 => 8 => 9;\nmy $y = 0 => 2 => 3 => 4 => 5 => 6 => 7 => 8;\nmy $z = 1 => 2 => (4 => 3) => 5 => 6 => 7 => 8;\n\nsay  so samefringe $a, $a;\nsay  so samefringe $a, $b;\nsay  so samefringe $a, $c;\n\nsay not samefringe $a, $x;\nsay not samefringe $a, $y;\nsay not samefringe $a, $z;\n\n```\n\nOutput:\n\n```\nTrue\nTrue\nTrue\nTrue\nTrue\nTrue\n```"}]}
{"messages": [{"role": "user", "content": "\"Never trust user input.\" If the Super Mario Bros. 3 Wrong Warp or [Bobby Tables] have taught programmers anything, it's that user input can be dangerous in unexpected ways.\n\nIn general, the task of preventing errors such as the above are best left to the built-in security features of the language rather than a filter of your own creation. This exercise is to test your ability to think about all the possible ways user input could break your program.\n\nTask\n\nCreate a function that takes a list of 20 first and last names, and copies them to a record or struct. Ten of them must be typical input, (i.e. consist of only letters of the alphabet and punctuation), but the other ten must be deliberately chosen to cause problems with a program that expects only letters and punctuation. A few examples:\n\n* ASCII control codes such as NUL, CR, LF\n* Code for the language you are using that can result in damage (e.g. -rm -rf, delete System32, DROP TABLE, etc.)\n* Numbers, symbols, foreign languages, emojis, etc.\n\n(There were already solutions provided before the requirement that ten names are \"normal\" and ten are potentially harmful was added. Those answers satisfied the task requirements at the time they were submitted.)\n\nRelated tasks\n\n* Parametrized SQL statement"}, {"role": "assistant", "content": "It would be helpful if the task author would be a little more specific about what he is after. How user inputs must be \"sanitized\" entirely depends on how the data is going to be used.\n\nFor internal usage, in Raku, where you are simply storing data into an internal data structure, it is pretty much a non issue. Variables in Raku aren't executed without specific instructions to do so. Full stop.\n\nYour name is a string of 2.6 million null bytes? Ok. Good luck typing that in.\n\nYou're called 'rm -rf /'? Wow. sucks to be you.\n\nNow, it may be a good idea to check for a maximum permitted length; (2.6e6 null bytes) but Raku would handle it with no problem.\n\nThe problem mostly comes in when you need to interchange data with some 3rd party library / system; but every different system is going to have it's own quirks and caveats. There is no \"one size fits all\" solution.\n\nIn general, when it comes to sanitizing user input, the best way to go about it is: **don't**. It's a losing game.\n\nInstead either validate input to make sure it follows a certain format, whitelist input so only a know few commands are permitted, or if those aren't possible, use 3rd party tools the 3rd party system provides to make arbitrary input \"safe\" to run. Which one of these is used depends on what system you need to interact with.\n\nFor the case given, (Bobby Tables), where you are presumably putting names into some 3rd party data storage (nominally a database of some kind), you would use bound parameters to automatically \"make safe\" any user input. See the Raku entry under the Parametrized SQL statement task.\n\nValidating is making sure the the input matches some predetermined format, usually with some sort of regular expression. For names, you probably want to allow a fixed maximum (and minimum!) number of: any word or digit character, space and period characters and possibly some small selection of non-word characters. It is a careful balance between too restrictive and too permissive. You need to avoid falling into pre-conceived assumptions about:\nnames, time, gender, addresses, phone numbers... the list goes on.\n\nWhen passing a user command to the operating system, you probably want to use whitelisting. Only a very few commands from a predetermined list are allowed to be used.\n\n```\n   if $command ∈ <ls time cd df> then { execute $command }\n\n```\n\nor some such. What the whitelist contains and how to determine if the input matches is a whole article in itself.\n\nUnfortunately, this is very vague and hand-wavey due to the vagueness of the task description. Really, any language could copy/paste 95% or better of the above, change the language name, and be done with it. But until the task description is made a little more focused, it will have to do."}]}
{"messages": [{"role": "user", "content": "Most programming languages offer support for subroutines.\nWhen execution changes between subroutines, different sets of variables and functions (\"scopes\") are available to the program.\nFrequently these sets are defined by the placement of the variable and function declarations (\"static scoping\" or \"lexical scoping\").\nThese sets may also be defined by special modifiers to the variable and function declarations.\n\nShow the different scope modifiers available in your language and briefly explain how they change the scope of their variable or function.\nIf your language has no scope modifiers, note it."}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku has a system of declarators that introduce new names into various scopes.\n\n```\nmy $lexical-variable;\nour $package-variable;\nstate $persistent-lexical;\nhas $.public-attribute;\n\n```\n\nLexically scoped variables, declared with my, are the norm.\nFunction definitions are intrinsically lexical by default, but allow for forward references, unlike any other declaration.\n\nPackage variables, declared with our, are de-emphasized. Unlike in Perl 5, almost no built-ins use package declarations for anything other than type names, and most of Perl 5's global punctuational variables become dynamic variables instead, with the final recourse in the GLOBAL and PROCESS packages. The per-interpreter GLOBAL package is mainly for users; all predefined process-wide information is stored in the PROCESS symbol table instead. The our declarator actually just declares an alias to a variable of the same name in the current package, and is in a sense just permission to use that global variable in the current scope as if it were a lexical. Type and constant declarations, including enums, are intrinsically considered \"our\" declarations, since Raku considers constants to be degenerate types.\n\nState variables, declared with state, are persistent lexicals that are not re-initialized on each function entry, but retain their previous value. An initializer is run only the first time through. State variables are similar but not identical to C static variables; in Raku each closure clone gets its own state variable, since such closures are really a form of generic code.\n\nThe has declarator is for declaring items in object scope.\nMethod declarations are implicitly in \"has\" scope.\n\nIn Perl 5, dynamic scoping is done via \"local\" to temporarily change the value of a global variable. This mechanism is still specced for Raku, albeit with a different keyword, temp, that better reflects what it's doing. None of the implementations yet implement temp, since Raku does dynamic scoping via a more robust system of scanning up the call stack for the innermost dynamic declaration, which actually lives in the lexical scope of the function declaring it. We distinguish dynamic variables syntactically by introducing a \"twigil\" after the sigil. The twigil for dynamic variables is \\* to represent that we don't know how to qualify the location of the variable.\n\n```\nsub a {\n    my $*dyn = 'a';\n    c();\n}\nsub b {\n    my $*dyn = 'b';\n    c();\n}\nsub c {\n    say $*dyn;\n}\na();  # says a\nb();  # says b\n\n```\n\nThe standard IO filehandles are dynamic variables $\\*IN, $\\*OUT, and $\\*ERR, which allows a program to easily redirect the input or output from any subroutine and all its children. More generally, since most process-wide variables are accessed via this mechanism, and only look in the PROCESS package as a last resort, any chunk of code can pretend to be in a different kind of process environment merely by redefining one or more of the dynamic variables in question, such as %\\*ENV.\n\nThis mechanism automatically produces thread-local storage if you declare your dynamic variable inside the lexical scope of the thread."}]}
{"messages": [{"role": "user", "content": "Task\n\nExplain or demonstrate the levels of visibility of function names and labels within the language.\n\nSee also\n\n* Variables for levels of scope relating to visibility of program variables\n* Scope modifiers for general scope modification facilities"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nFirst a little hand-wavey exposition. The lines are rather blurry in Raku between subroutines, methods, operators and functions. Methods are associated with an object and are inheritable. Subroutines and operators are not. Other than that though there is a lot of overlap. \"A function\" doesn't really have a specific definition, but is more of a generic term used when talking about code reference type of things.\n\nMethods don't have a separate scope from the object they are attached to. If the object is in scope, the method will be.\n\nA subroutine is really just another type of object. It has a code reference and has ROUTINE semantics attached to it. The same holds for operators. Operators are really just subroutines with a funny calling convention. That being the case, scoping for subroutines very closely follows scoping rules for any other Raku variable type.\n\nIn general, subroutines are \"my\" variables by default (if you don't specify, the \"my\" is implicit), meaning scoping is lexical to the enclosing block and flows inward. A subroutine defined within a block will be visible to everything inside that block, even other blocks within that block. However, any inner block can define its own subroutine with the same name and that will be used in preference to the routine from an outer block. That implies you can easily override / redefine core functions from the Raku setting. The setting is the collection of built in functions supplied by Raku, typically and somewhat incongruously referred to as \"CORE\" even though technically it is the outermost scope. ( SKIN? BARK? CRUST? ... oooo! EXOSKELETON! :-) )\n\nAlternately, subroutines may be declared as an \"our\" variable making it a package global, visible anywhere in the packages' namespace. That is somewhat discouraged though as it pollutes the namespace and reduces the granularity of control.\n\nThere are several ways to modify the relative scope of a subroutine (any item in the symbol table really) by adding modifiers to the name.\n\n```\nCALLER    # Contextual symbols in the immediate caller's lexical scope\nOUTER     # Symbols in the next outer lexical scope\nUNIT      # Symbols in the outermost lexical scope of compilation unit\nSETTING   # Lexical symbols in the unit's DSL (usually CORE)\nPARENT    # Symbols in this package's parent package (or lexical scope)\n\n```\n\n```\n# call a routine before it has been defined\nsay log();              # prints: outer\n\n# define a subroutine that overrides a CORE function\nsub log { 'outer' }; \n{\n    # redefine the subroutine in this block\n    sub log { 'inner' };\n    {\n        # redefine the subroutine yet again\n        sub log { 'way down inside' };\n        \n        # call it within this block\n        say log();                 # prints: way down inside\n        \n        # call it from the block one level out\n        say &OUTER::log();         # prints: inner\n        \n        # call it from the block two levels out\n        say &OUTER::OUTER::log();  # prints: outer\n        \n        # call it from the outermost block\n        say &UNIT::log();          # prints: outer\n        \n        # call a subroutine that is post declared in outermost scope\n        outersub()\n    }\n\n    {\n        # subroutine in an inner block that doesn't redefine it\n        # uses definition from nearest enclosing block\n        say log();      # prints: inner\n    }\n    # call it within this block\n    say log();          # prints: inner\n    \n    # call it from the block one level out\n    say &OUTER::log();  # prints: outer\n}\n\nsub outersub{ \n    # call subroutine within this block - gets outer sub\n    say log();          # prints: outer\n    \n    # call subroutine from the scope of the callers block\n    say &CALLER::log(); # prints: way down inside\n    \n    # call subroutine from the outer scope of the callers block\n    say &CALLER::OUTER::log(); # prints: inner\n    \n    # call the original overridden CORE routine\n    say &CORE::log(e);  # prints: 1 ( natural log of e )\n}\n\n```\n\nLabels are less interesting and are typically useful only for control flow in looping constructs. They generally follow the same scoping rules as \"my\" variables. There is nearly always easier ways to do control flow though, so they aren't heavily used."}]}
{"messages": [{"role": "user", "content": "Definition\n\nIn object-oriented programming, a **sealed** or **final class** is one which cannot be inherited from.\n\nClasses are sometimes made non-subclassable in this way if the author feels that it would not be useful or even undesirable for subclasses to be created from them. Moreover, in a compiled language, knowing that a class cannot be subclassed, may enable optimizations to be made.\n\nRather than sealing the entire class, it may be possible to just seal certain methods for the same reasons and with the same potential benefits.\n\nTask\n\nIf your language supports the object oriented paradigm, explain what support it has for sealed classes and/or methods and, if there is no support, what if anything can be done to simulate them. If possible illustrate your answer with an example.\n\nIf your language does not support the object oriented paradigm (or its inheritance aspect), you may either simply say so, omit the task altogether or describe any equivalent structure(s) and restrictions on use which the language does have.\n\nReference\n\n* Inheritance Non-subclassable classes\n\nRelated task\n\n* Classes\n* Inheritance/Single\n* Inheritance/Multiple"}, {"role": "assistant", "content": "Raku doesn't have final class but Roles is normally used to mimic the goal.\n\n```\n# 20240626 Raku programming solution\n\nrole MovieWatcherRole { has Str $.name;\n   method WatchMovie() { say \"$.name is watching the movie.\"   }\n   method EatPopcorn() { say \"$.name is enjoying the popcorn.\" }\n}\n\nclass MovieWatcher does MovieWatcherRole {\n   method new(Str $name) { self.bless(:$name) }\n}\n\nclass ParentMovieWatcher is MovieWatcher { }\n\nrole ChildMovieWatcherRole {\n   method EatPopcorn() { say \"$.name is eating too much popcorn.\" }\n}\n\nclass ChildMovieWatcher is MovieWatcher does ChildMovieWatcherRole { }\n\nrole YoungChildMovieWatcherRole {\n   method WatchMovie() { \n      say \"Sorry, $.name, you are too young to watch the movie.\" \n   }\n}\n\nclass YoungChildMovieWatcher is ChildMovieWatcher does YoungChildMovieWatcherRole { }\n\nfor ParentMovieWatcher.new('Donald'),\n    ChildMovieWatcher.new('Lisa'),\n    YoungChildMovieWatcher.new('Fred')\n{ .WatchMovie and .EatPopcorn }\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task[edit]\n\nFind the index of a string (needle) in an indexable, ordered collection of strings (haystack).\n\nRaise an exception if the needle is missing.\n\nIf there is more than one occurrence then return the smallest index to the needle.\n\nExtra credit\n\nReturn the largest index to a needle that has multiple occurrences in the haystack.\n\nSee also\n\n* Search a list of records\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo Star version 2016.07\n\n```\nmy @haystack = <Zig Zag Wally Ronald Bush Krusty Charlie Bush Bozo>;\n \nfor <Washington Bush> -> $needle {\n    say \"$needle -- { @haystack.first($needle, :k) // 'not in haystack' }\";\n}\n```\n\nOutput:\n\n```\nWashington -- not in haystack\nBush -- 4\n\n```\n\nOr, including the \"extra credit\" task:\n\n**Works with**: Rakudo Star version 2016.07\n\n```\nmy Str @haystack = <Zig Zag Wally Ronald Bush Krusty Charlie Bush Bozo>;\n\nfor <Washingston Bush> -> $needle {\n    my $first = @haystack.first($needle, :k);\n\n    if defined $first {\n        my $last = @haystack.first($needle, :k, :end);\n        say \"$needle -- first at $first, last at $last\";\n    }\n    else {\n        say \"$needle -- not in haystack\";\n    }\n}\n```\n\nOutput:\n\n```\nWashingston -- not in haystack\nBush -- first at 4, last at 7\n\n```\n\nThe built-in method `.first` takes a smart-matcher, and returns the first matching list element.  \nThe `:k` adverb tells it to return the key (a.k.a. list index) instead of the value of the matching element.  \nThe `:end` adverb tells it to start searching from the end of the list.\n\nIf you plan to do many searches on the same large list, you might want to build a search hash first for efficient look-up:\n\n```\nmy @haystack = <Zig Zag Wally Ronald Bush Krusty Charlie Bush Bozo>;\n\nmy %index;\n%index{.value} //= .key for @haystack.pairs;\n\nfor <Washington Bush> -> $needle {\n    say \"$needle -- { %index{$needle} // 'not in haystack' }\";\n}\n```"}]}
{"messages": [{"role": "user", "content": "Many programming languages provide convenient ways to look for a known value in a simple list of strings or numbers.  \nBut what if the elements of the list are themselves compound records/objects/data-structures, and the search condition is more complex than a simple equality test?\n\nTask[edit]\n\nWrite a function/method/etc. that can find the first element in a given list matching a given condition.  \nIt should be as generic and reusable as possible.  \n(Of course if your programming language already provides such a feature, you can use that instead of recreating it.)\n\nThen to demonstrate its functionality, create the data structure specified under #Data set, and perform on it the searches specified under #Test cases.\n\nData set\n\nThe data structure to be used contains the names and populations (in millions) of the 10 largest metropolitan areas in Africa, and looks as follows when represented in JSON:\n\n```\n[\n  { \"name\": \"Lagos\",                \"population\": 21.0  },\n  { \"name\": \"Cairo\",                \"population\": 15.2  },\n  { \"name\": \"Kinshasa-Brazzaville\", \"population\": 11.3  },\n  { \"name\": \"Greater Johannesburg\", \"population\":  7.55 },\n  { \"name\": \"Mogadishu\",            \"population\":  5.85 },\n  { \"name\": \"Khartoum-Omdurman\",    \"population\":  4.98 },\n  { \"name\": \"Dar Es Salaam\",        \"population\":  4.7  },\n  { \"name\": \"Alexandria\",           \"population\":  4.58 },\n  { \"name\": \"Abidjan\",              \"population\":  4.4  },\n  { \"name\": \"Casablanca\",           \"population\":  3.98 }\n]\n\n```\n\nHowever, you shouldn't parse it from JSON, but rather represent it natively in your programming language.\n\n* The top-level data structure should be an **ordered** collection *(i.e. a list, array, vector, or similar)*.\n* Each element in this list should be an **associative** collection that maps from keys to values *(i.e. a struct, object, hash map, dictionary, or similar)*.\n* Each of them has two entries: One string value with key \"name\", and one numeric value with key \"population\".\n* You may rely on the list being sorted by population count, as long as you explain this to readers.\n\nIf any of that is impossible or unreasonable in your programming language, then feel free to deviate, as long as you explain your reasons in a comment above your solution.\n\nTest cases\n\n| Search | Expected result |\n| --- | --- |\n| Find the (zero-based) **index** of the first city in the list whose **name is \"Dar Es Salaam\"** | 6 |\n| Find the **name** of the first city in this list whose **population is less than 5 million** | Khartoum-Omdurman |\n| Find the **population** of the first city in this list whose **name starts with the letter \"A\"** | 4.58 |\n\nGuidance\n\nIf your programming language supports higher-order programming, then the most elegant way to implement the requested functionality in a generic and reusable way, might be to write a function (maybe called \"find\\_index\" or similar), that takes two arguments:\n\n1. The list to search through.\n2. A function/lambda/closure (the so-called \"predicate\"), which will be applied in turn to each element in the list, and whose boolean return value defines whether that element matches the search requirement.\n\nIf this is not the approach which would be most natural or idiomatic in your language, explain why, and show what is.\n\nRelated tasks\n\n* Search a list\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe built-in method .first fulfills the requirements of this task.  \nIt takes any smart-matcher as a predicate. The :k adverb makes it return the key (i.e. numerical index) instead of the value of the element.\n\n**Works with**: Rakudo version 2016.08\n\n```\nmy @cities =\n  { name => 'Lagos',                population => 21.0  },\n  { name => 'Cairo',                population => 15.2  },\n  { name => 'Kinshasa-Brazzaville', population => 11.3  },\n  { name => 'Greater Johannesburg', population =>  7.55 },\n  { name => 'Mogadishu',            population =>  5.85 },\n  { name => 'Khartoum-Omdurman',    population =>  4.98 },\n  { name => 'Dar Es Salaam',        population =>  4.7  },\n  { name => 'Alexandria',           population =>  4.58 },\n  { name => 'Abidjan',              population =>  4.4  },\n  { name => 'Casablanca',           population =>  3.98 },\n;\n\nsay @cities.first(*<name> eq 'Dar Es Salaam', :k);\nsay @cities.first(*<population> < 5).<name>;\nsay @cities.first(*<name>.match: /^A/).<population>;\n\n```\n\nOutput:\n\n```\n6\nKhartoum-Omdurman\n4.58\n\n```"}]}
{"messages": [{"role": "user", "content": "The goal is to verify the presence of a word or regular expression within several paragraphs of text (structured or not) and to format the output of the relevant paragraphs before putting them on the standard output.\n\nSo here, let’s imagine that we are trying to verify the presence of a keyword \"SystemError\" within what I want to call \"the paragraphs\" \"Traceback (most recent call last):\" in the file Traceback.txt\n\n```\ncat Traceback.txt :\n\n2018-06-19 23:19:34,877 ERROR Processes plugin raised an exception.\nTraceback (most recent call last):\n  File \"/usr/lib/python3/dist-packages/landscape/sysinfo/sysinfo.py\", line 99, in run\n    result = plugin.run()\n  File \"/usr/lib/python3/dist-packages/landscape/sysinfo/processes.py\", line 18, in run\n    for process_info in info.get_all_process_info():\n  File \"/usr/lib/python3/dist-packages/landscape/lib/process.py\", line 39, in get_all_process_info\n    process_info = self.get_process_info(process_id)\n  File \"/usr/lib/python3/dist-packages/landscape/lib/process.py\", line 61, in get_process_info\n    cmd_line = file.readline()\n  File \"/usr/lib/python3.6/encodings/ascii.py\", line 26, in decode\n    return codecs.ascii_decode(input, self.errors)[0]\nUnicodeDecodeError: 'ascii' codec can't decode byte 0xc5 in position 152: ordinal not in range(128)\n\n2018-06-19 23:19:34,877 ERROR Processes plugin raised an exception.\nTraceback (most recent call last):\n    vmodl.fault.SystemError: (vmodl.fault.SystemError) {\n    dynamicType = ,\n    dynamicProperty = (vmodl.DynamicProperty) [],\n    msg = 'A general system error occurred: Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.',\n    faultCause = ,\n    faultMessage = (vmodl.LocalizableMessage) [],\n    reason = 'Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.'\n    }\n\n[Tue Jan 21 16:16:19.250245 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] Traceback (most recent call last):\n[Tue Jan 21 16:16:19.252221 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] SystemError: unable to access /home/dir\n[Tue Jan 21 16:16:19.249067 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] mod_wsgi (pid=6515): Failed to exec Python script file '/home/pi/RaspBerryPiAdhan/www/sysinfo.wsgi'.\n[Tue Jan 21 16:16:19.249609 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] mod_wsgi (pid=6515): Exception occurred processing WSGI script '/home/pi/RaspBerryPiAdhan/www/sysinfo.wsgi'.\n\n[Tue Jan 21 17:16:19.250245 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] Traceback (most recent call last):\n[Tue Jan 21 17:16:19.250679 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757]   File \"/home/pi/RaspBerryPiAdhan/www/sysinfo.wsgi\", line 5, in <module>\n[Tue Jan 21 17:16:19.251735 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757]     from test import app as application\n[Tue Jan 21 17:16:19.252221 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] ImportError: cannot import name app\n\n2021-04-23 17:13:14,425 ERROR    Network plugin raised an exception.\nTraceback (most recent call last):\n  File \"/usr/lib/python3/dist-packages/landscape/sysinfo/sysinfo.py\", line 99, \nin run\n    result = plugin.run()\n  File \"/usr/lib/python3/dist-packages/landscape/sysinfo/network.py\", line 36, \nin run\n    device_info = self._get_device_info()\n  File \"/usr/lib/python3/dist-packages/landscape/lib/network.py\", line 163, in \nget_active_device_info\n    speed, duplex = get_network_interface_speed(\n  File \"/usr/lib/python3/dist-packages/landscape/lib/network.py\", line 249, in \nget_network_interface_speed\n    res = status_cmd.tostring()\nAttributeError: 'array.array' object has no attribute 'tostring'\n\n11/01 18:24:57.726 ERROR| log:0072| post-test sysinfo error: 11/01 18:24:57.727 ERROR| traceback:0013| Traceback (most recent call last): 11/01 18:24:57.728 ERROR| traceback:0013| File \"/tmp/sysinfo/autoserv-0tMj3m/common_lib/log.py\", line 70, in decorated_func 11/01 18:24:57.729 ERROR| traceback:0013| fn(*args, **dargs) 11/01 18:24:57.730 ERROR| traceback:0013| File \"/tmp/sysinfo/autoserv-0tMj3m/bin/base_sysinfo.py\", line 286, in log_after_each_test 11/01 18:24:57.731 ERROR| traceback:0013| old_packages = set(self._installed_packages) 11/01 18:24:57.731 ERROR| traceback:0013| TypeError: 'NoneType' object is not iterable\n\n12/01 19:24:57.726 ERROR| log:0072| post-test sysinfo error: 11/01 18:24:57.727 ERROR| traceback:0013| Traceback (most recent call last): 11/01 18:24:57.728 ERROR| traceback:0013| File \"/tmp/sysinfo/autoserv-0tMj3m/common_lib/log.py\", line 70, in decorated_func 11/01 18:24:57.729 ERROR| traceback:0013| fn(*args, **dargs) 11/01 18:24:57.730 ERROR| traceback:0013| File \"/tmp/sysinfo/autoserv-0tMj3m/bin/base_sysinfo.py\", line 286, in log_after_each_test 11/01 18:24:57.731 ERROR| traceback:0013| old_packages = set(self._installed_packages) 11/01 18:24:57.731 ERROR| traceback:0013| SystemError: no such file or directory\n\nTraceback (most recent call last):\n    File \"/usr/lib/vmware-vpx/vsan-health/pyMoVsan/VsanClusterPrototypeImpl.py\", line 1492, in WaitForUpdateTask\n    WaitForTask(task)\n    File \"/usr/lib/vmware-vpx/pyJack/pyVim/task.py\", line 123, in WaitForTask\n    raise task.info.error\n    vmodl.fault.SystemError: (vmodl.fault.SystemError) {\n    dynamicType = ,\n    dynamicProperty = (vmodl.DynamicProperty) [],\n    msg = 'A general system error occurred: Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.',\n    faultCause = ,\n    faultMessage = (vmodl.LocalizableMessage) [],\n    reason = 'Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.'\n    }\n\n```\n\nThe expected result must be formated with ---------------- for paragraph's separator AND \"Traceback (most recent call last):\" as the beginning of each relevant's paragraph :\n\n```\nTraceback (most recent call last):\n    vmodl.fault.SystemError: (vmodl.fault.SystemError) {\n    dynamicType = ,\n    dynamicProperty = (vmodl.DynamicProperty) [],\n    msg = 'A general system error occurred: Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.',\n    faultCause = ,\n    faultMessage = (vmodl.LocalizableMessage) [],\n    reason = 'Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.'\n    }\n----------------\nTraceback (most recent call last):\n[Tue Jan 21 16:16:19.252221 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] SystemError: unable to access /home/dir\n[Tue Jan 21 16:16:19.249067 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] mod_wsgi (pid=6515): Failed to exec Python script file '/home/pi/RaspBerryPiAdhan/www/sysinfo.wsgi'.\n[Tue Jan 21 16:16:19.249609 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] mod_wsgi (pid=6515): Exception occurred processing WSGI script '/home/pi/RaspBerryPiAdhan/www/sysinfo.wsgi'.\n----------------\nTraceback (most recent call last): 11/01 18:24:57.728 ERROR| traceback:0013| File \"/tmp/sysinfo/autoserv-0tMj3m/common_lib/log.py\", line 70, in decorated_func 11/01 18:24:57.729 ERROR| traceback:0013| fn(*args, **dargs) 11/01 18:24:57.730 ERROR| traceback:0013| File \"/tmp/sysinfo/autoserv-0tMj3m/bin/base_sysinfo.py\", line 286, in log_after_each_test 11/01 18:24:57.731 ERROR| traceback:0013| old_packages = set(self._installed_packages) 11/01 18:24:57.731 ERROR| traceback:0013| SystemError: no such file or directory\n----------------\nTraceback (most recent call last):\n    File \"/usr/lib/vmware-vpx/vsan-health/pyMoVsan/VsanClusterPrototypeImpl.py\", line 1492, in WaitForUpdateTask\n    WaitForTask(task)\n    File \"/usr/lib/vmware-vpx/pyJack/pyVim/task.py\", line 123, in WaitForTask\n    raise task.info.error\n    vmodl.fault.SystemError: (vmodl.fault.SystemError) {\n    dynamicType = ,\n    dynamicProperty = (vmodl.DynamicProperty) [],\n    msg = 'A general system error occurred: Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.',\n    faultCause = ,\n    faultMessage = (vmodl.LocalizableMessage) [],\n    reason = 'Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.'\n    }\n----------------\n\n```"}, {"role": "assistant", "content": "Generalized. Pipe in the file from the shell, user definable search term and entry point.\n\n```\nunit sub MAIN ( :$for, :$at = 0 );\n\nput slurp.split( /\\n\\n+/ ).grep( { .contains: $for } )\n         .map( { .substr: .index: $at } )\n         .join: \"\\n----------------\\n\"\n\n```\n\nExample output using command line:\n\n```\n   raku search.raku --for='SystemError' --at='Traceback' < traceback.txt\n\n```\n\n*Matches expected except for not having a extraneous trailing paragraph separator.*\n\n```\nTraceback (most recent call last):\n    vmodl.fault.SystemError: (vmodl.fault.SystemError) {\n    dynamicType = ,\n    dynamicProperty = (vmodl.DynamicProperty) [],\n    msg = 'A general system error occurred: Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.',\n    faultCause = ,\n    faultMessage = (vmodl.LocalizableMessage) [],\n    reason = 'Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.'\n    }\n----------------\nTraceback (most recent call last):\n[Tue Jan 21 16:16:19.252221 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] SystemError: unable to access /home/dir\n[Tue Jan 21 16:16:19.249067 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] mod_wsgi (pid=6515): Failed to exec Python script file '/home/pi/RaspBerryPiAdhan/www/sysinfo.wsgi'.\n[Tue Jan 21 16:16:19.249609 2020] [wsgi:error] [pid 6515:tid 3041002528] [remote 10.0.0.12:50757] mod_wsgi (pid=6515): Exception occurred processing WSGI script '/home/pi/RaspBerryPiAdhan/www/sysinfo.wsgi'.\n----------------\nTraceback (most recent call last): 11/01 18:24:57.728 ERROR| traceback:0013| File \"/tmp/sysinfo/autoserv-0tMj3m/common_lib/log.py\", line 70, in decorated_func 11/01 18:24:57.729 ERROR| traceback:0013| fn(*args, **dargs) 11/01 18:24:57.730 ERROR| traceback:0013| File \"/tmp/sysinfo/autoserv-0tMj3m/bin/base_sysinfo.py\", line 286, in log_after_each_test 11/01 18:24:57.731 ERROR| traceback:0013| old_packages = set(self._installed_packages) 11/01 18:24:57.731 ERROR| traceback:0013| SystemError: no such file or directory\n----------------\nTraceback (most recent call last):\n    File \"/usr/lib/vmware-vpx/vsan-health/pyMoVsan/VsanClusterPrototypeImpl.py\", line 1492, in WaitForUpdateTask\n    WaitForTask(task)\n    File \"/usr/lib/vmware-vpx/pyJack/pyVim/task.py\", line 123, in WaitForTask\n    raise task.info.error\n    vmodl.fault.SystemError: (vmodl.fault.SystemError) {\n    dynamicType = ,\n    dynamicProperty = (vmodl.DynamicProperty) [],\n    msg = 'A general system error occurred: Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.',\n    faultCause = ,\n    faultMessage = (vmodl.LocalizableMessage) [],\n    reason = 'Unable to complete Sysinfo operation. Please see the VMkernel log file for more details.: Sysinfo error: Bad parameterSee VMkernel log for details.'\n    }\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a temporary file, **securely and exclusively** (opening it such that there are no possible race conditions).\n\nIt's fine assuming local filesystem semantics (NFS or other networking filesystems can have signficantly more complicated semantics for satisfying the \"no race conditions\" criteria).\n\nThe function should automatically resolve name collisions and should only fail in cases where permission is denied, the filesystem is read-only or full, or similar conditions exist (returning an error or raising an exception as appropriate to the language/environment)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nThis is something best done with a module which is heavily tested, tries to account for all corner cases and automatically cleans up after itself.\n\nAlmost verbatim from the synopsis:\n\n```\nuse File::Temp;\n\n# Generate a temp file in a temp dir\nmy ($filename0,$filehandle0) = tempfile;\n\n# specify a template for the filename\n#  * are replaced with random characters\nmy ($filename1,$filehandle1) = tempfile(\"******\");\n\n# Automatically unlink files at DESTROY (this is the default)\nmy ($filename2,$filehandle2) = tempfile(\"******\", :unlink);\n\n# Specify the directory where the tempfile will be created\nmy ($filename3,$filehandle3) = tempfile(:tempdir(\"/path/to/my/dir\"));\n\n# don't unlink this one\nmy ($filename4,$filehandle4) = tempfile(:tempdir('.'), :!unlink);\n\n# specify a prefix, a suffix, or both for the filename\nmy ($filename5,$filehandle5) = tempfile(:prefix('foo'), :suffix(\".txt\"));\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFor each number list of **6**-digit SEDOLs, calculate and append the checksum digit.\n\nThat is, given this input:\n\n```\n710889\nB0YBKJ\n406566\nB0YBLH\n228276\nB0YBKL\n557910\nB0YBKR\n585284\nB0YBKT\nB00030\n\n```\n\nProduce this output:\n\n```\n7108899\nB0YBKJ7\n4065663\nB0YBLH2\n2282765\nB0YBKL9\n5579107\nB0YBKR5\n5852842\nB0YBKT7\nB000300\n\n```\n\nExtra credit\n\nCheck each input is correctly formed, especially with respect to valid characters allowed in a SEDOL string.\n\nRelated tasks\n\n* Luhn test\n* ISIN"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n**Works with**: rakudo version 2015-12-17\n\n```\nsub sedol( Str $s ) {\n    die 'No vowels allowed' if $s  ~~ /<[AEIOU]>/;\n    die 'Invalid format'    if $s !~~ /^ <[0..9B..DF..HJ..NP..TV..Z]>**6 $ /;\n\n    my %base36 = (flat 0..9, 'A'..'Z') »=>« ^36;\n    my @weights = 1, 3, 1, 7, 3, 9;\n\n    my @vs = %base36{ $s.comb };\n    my $checksum = [+] @vs Z* @weights;\n    my $check_digit = (10 - $checksum % 10) % 10;\n    return $s ~ $check_digit;\n}\n\nsay sedol($_) for <\n    710889\n    B0YBKJ\n    406566\n    B0YBLH\n    228276\n    B0YBKL\n    557910\n    B0YBKR\n    585284\n    B0YBKT\n    B00030\n>;\n\n```"}]}
{"messages": [{"role": "user", "content": "In epidemiology, retrospective analyses have well-known limitations compared to prospective studies.\n\nOne such limitation is the occurrence of *selection bias* in the choice of subjects between treated\nand untreated groups about whom the data is collected. For example, a treatment may have only been\ngiven to persons who were less severely ill, which would bias the results in favor of such subjects\nappearing to have done better because of the treatment when the biased group is then compared to those\nwho who did not receive the study treatment. Or, in a retrospective study, there may a choice to place\nsubjects in a particular study group using a method which is inadvertently biased by the outcome being\nmeasured. Creating a programming example of a simulation of such selection bias in the design of a\nretrospective study is the topic of this task.\n\nThe genuine, historical example (only partially approximated in this task) is of a study done of persons who, over a course\nof 180 days, may or may not have become infected with Covid-19. Prior to becoming ill, these subjects may or may not have taken an available medication, which was actually taken on a particular schedule not used here, but is approximated by stating the medication was taken in doses of 3, 6, or 9 mg daily. The historical study then divided its subjects into three groups based on their cumulative dosage of the study medication:\n\n* Group UNTREATED were those who did not take the study medication at all before they got Covid-19, including those who exited the study period without Covid-19 and having never taken the study medication.\n\n* Group IRREGULAR is those who took the study medication but whose cumulative dose was less than a certain amount (approximated for our purposes as 100 mg) before they either came down with Covid-19 during the study or the study period ended.\n\n* Group REGULAR is those who took (our approximation is >= 100 mg) of the study medication either before they came down with Covid-19 or took >= 100 mg by the end of the study and never became infected during the study.\n\nAssumptions for the study simulation programming task\n\n* Daily risk of getting Covid-19 infection for each subject was 0.1% per day, or 18% over the 180 cumulative days of the study.\n\n* The probability of starting treatment medication for anyone not already taking it was 0.5% per day. For those who started medication, the chance of continuing the treatment was increased 50-fold to 25% each day, since most who started the medication continued to take it to some extent.\n\n* Study dose per day is random between the approximation for the simulation of 3, 6 and 9 mg. The daily cumulative dosage is used to determine the group the subject is in, unless a subject develops Covid-19. If a subject was diagnosed with Covid-19, their group at the time of that diagnosis is used in the statistical analysis of that group.\n\nTask\n\n* Create a simulation of the subjects, keeping track of their medication dosages, group membership, and Covid-19 status during the study.\n\n* Use at least 1000 subjects in the simulation over the 180 days (historically, the study size was 80,000).\n\n* Statistics used are to be the Kruskal statistic for the analysis of multiple groups, with the boolean study outcome variable whether the subject got Covid-19 during the study period, analyzed versus category. If the programming language does not have a statistical package for such a test, calculation of the Kruskal H statistic may be used, since any values of H over about 50 are considered very highly indicative of significant group difference. A description of that test is found at Kruskal-Wallis test.\n\n* You should get a statistical result highly favoring the REGULAR group.\n\nStretch task\n\n* Show monthly outcomes.\n\nA note regarding outcome: Note that by simulation design all subjects must have an IDENTICAL risk, that is 0.1 per cent or p = 0.001 per day, of developing Covid-19. Because of the design, any statistical differences between the groups CANNOT come from an influence of the treatment on that risk, but must come from some other feature of the study design.\n\nSee also\n:   * Wikipedia - Selection Bias * Wikipedia - Retrospective studies * UCDavis (pdf) Challenges in Retrospective studies"}, {"role": "assistant", "content": "**Translation of**: Phix\n\n```\n# 20221025 Raku programming solution\n\nenum <UNTREATED REGULAR IRREGULAR>;\nmy \\DOSE_FOR_REGULAR = 100;\nmy ($nSubjects,$duration,$interval) = 10000, 180, 30;\nmy (@dosage,@category,@hadcovid) := (0,UNTREATED,False)>>.&{($_ xx $nSubjects).Array};\n\nsub update($pCovid=1e-3, $pStartTreatment=5e-3, $pRedose=¼, @dRange=<3 6 9>) {\n   for 0 ..^ @dosage.elems -> \\i { \n      unless @hadcovid[i] { \n         if rand < $pCovid { \n            @hadcovid[i] = True\n         } else {\n            my $dose = @dosage[i];\n            if $dose==0 && rand < $pStartTreatment or $dose > 0 && rand < $pRedose {               \n\t           @dosage[i]   = $dose += @dRange.roll;\n               @category[i] = ($dose > DOSE_FOR_REGULAR) ?? REGULAR !! IRREGULAR\n            } \n         } \n      } \n   } \n}\n\nsub kruskal (@sets) {\n   my $n          = ( my @ranked = @sets>>.List.flat.sort ).elems;\n   my @sr         = 0 xx @sets.elems;\n   my $ix         = (@ranked.first: * == True, :k)+1, \n   my ($arf,$art) = ($ix, $ix+$n) >>/>> 2;\n\n   for @sets.kv -> \\i,@set { for @set -> $b { @sr[i] += $b ?? $art !! $arf } } \n\n   my $H = [+] @sr.kv.map: -> \\i,\\s { s*s/@sets[i].elems }\n   return 12/($n*($n+1)) * $H - 3 * ($n + 1)\n}\n\nsay \"Total subjects: $nSubjects\\n\";\n\nmy ($midpoint,$unt,$irr,$reg,$hunt,$hirr,$hreg,@sunt,@sirr,@sreg)=$duration div 2;\n\nfor 1 .. $duration -> \\day { \n   update();\n   if day %% $interval or day == $duration or day == $midpoint { \n      @sunt = @hadcovid[ @category.grep: UNTREATED,:k ];\n      @sirr = @hadcovid[ @category.grep: IRREGULAR,:k ]; \n      @sreg = @hadcovid[ @category.grep: REGULAR,  :k ]; \n      ($unt,$hunt,$irr,$hirr,$reg,$hreg)=(@sunt,@sirr,@sreg).map:{|(.elems,.sum)}\n   } \n   if day %% $interval {\n      printf \"Day %d:\\n\",day;\n      printf \"Untreated:     N = %4d, with infection = %4d\\n\",  $unt,$hunt;\n      printf \"Irregular Use: N = %4d, with infection = %4d\\n\",  $irr,$hirr;\n      printf \"Regular Use:   N = %4d, with infection = %4d\\n\\n\",$reg,$hreg\n   } \n   if day == $midpoint | $duration { \n      my $stage = day == $midpoint ?? 'midpoint' !! 'study end';\n      printf \"At $stage, Infection case percentages are:\\n\";\n      printf \"  Untreated : %f\\n\",  100*$hunt/$unt;\n      printf \"  Irregulars: %f\\n\",  100*$hirr/$irr;\n      printf \"  Regulars  : %f\\n\\n\",100*$hreg/$reg\n   }    \n}\n\nprintf \"Final statistics: H = %f\\n\", kruskal ( @sunt, @sirr, @sreg )\n\n```\n\nOutput:\n\n```\nTotal subjects: 10000\n\nDay 30:\nUntreated:     N = 8616, with infection =  314\nIrregular Use: N = 1383, with infection =   27\nRegular Use:   N =    1, with infection =    0\n\nDay 60:\nUntreated:     N = 7511, with infection =  561\nIrregular Use: N = 2308, with infection =   87\nRegular Use:   N =  181, with infection =    1\n\nDay 90:\nUntreated:     N = 6571, with infection =  760\nIrregular Use: N = 2374, with infection =  141\nRegular Use:   N = 1055, with infection =   19\n\nAt midpoint, Infection case percentages are:\n  Untreated : 11.565972\n  Irregulars: 5.939343\n  Regulars  : 1.800948\n\nDay 120:\nUntreated:     N = 5757, with infection =  909\nIrregular Use: N = 2097, with infection =  189\nRegular Use:   N = 2146, with infection =   61\n\nDay 150:\nUntreated:     N = 5092, with infection = 1054\nIrregular Use: N = 1832, with infection =  238\nRegular Use:   N = 3076, with infection =  132\n\nDay 180:\nUntreated:     N = 4530, with infection = 1172\nIrregular Use: N = 1615, with infection =  282\nRegular Use:   N = 3855, with infection =  229\n\nAt study end, Infection case percentages are:\n  Untreated : 25.871965\n  Irregulars: 17.461300\n  Regulars  : 5.940337\n\nFinal statistics: H = 248.419454\n```"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nCopy part of input records to an output file.\n\nShow how file processing as known from PL/I or COBOL can be implemented in the\nlanguage of your choice.\n\nHere, a file is not 'just' a sequence of bytes or lines but a sequence of *records* (structured data).\n\nThe structure is usually described by declarations contained in an *INCLUDE* file (PL/I) or *COPY BOOK* (COBOL).\n\nThe *by name* assignment is a little extra available in PL/I.\n\nData conversions may be necessary (as shown here for data element *c* in the Go listing)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.10\n\nI have no idea how PL/I or COBOL store records and little enthusiasm to research it. If the task author can't be bothered to spell out what the format should look like, then I have no compunction about just making something up out of whole cloth. In the absence of better guidance I am going to make a binary encoded data file format with fixed sized fields consisting of a mix of ISO-8859-1 encoded text and raw binary (hex) encoded integers.\n\nThis is WAY more complicated than it could be. Could achieve the same effect in one or two lines of code, but this explicitly shows some of the possible mechanics.\n\nSince the sfc.dat file is binary encoded, I can't include it here easily as text so here is a link to an online copy instead.\n\n```\nmy @format = ( # arbitrary and made up record format\n    'field a' => { offset => 0,  length => 5, type => 'Str' },\n    'field b' => { offset => 5,  length => 5, type => 'Str' },\n    'field c' => { offset => 10, length => 4, type => 'Int' },\n    'field d' => { offset => 14, length => 1, type => 'Str' },\n    'field e' => { offset => 15, length => 5, type => 'Str' }\n);\n\nmy $record-length = @format[*]».value».<length>.sum;\n\nmy $in = './sfc.dat'.IO.open :r :bin;\n\nsay \"Input data as read from $in:\";\nmy @records;\n@records.push: get-record($in, $record-length) until $in.eof;\n.perl.say for @records;\n\n# not going to bother to actually write out to a file, if you really want to,\n# supply a file handle to a local file\nsay \"\\nOutput:\";\nmy $outfile = $*OUT; # or some other filename, whatever.\n\nfor @records -> $r {\n    $outfile.printf( \"%-5s%s%08x%5s\\n\", flat $r.{'field a','field d','field c'}, 'xxxxx' );\n}\n\nsub get-record($fh, $bytes) {\n    my $record = $fh.read($bytes);\n    return ().Slip unless $record.elems == $bytes;\n    my %r = @format.map: {\n        .key => do given $_.value.<type> -> $type\n        {\n            when $type eq 'Str' { $record.subbuf($_.value.<offset>, $_.value.<length>).decode }\n            when $type eq 'Int' { sum $record.subbuf($_.value.<offset>, $_.value.<length>) Z+< (24,16,8,0) }\n            default             { $record.subbuf($_.value.<offset>, $_.value.<length>) } # Buf\n        }\n    }\n}\n\n```\n\nOutput:\n\n```\nInput data as read from ./sfc.dat:\n${\"field a\" => \"A    \", \"field b\" => \"bbbbB\", \"field c\" => 1, \"field d\" => \"+\", \"field e\" => \"d2345\"}\n${\"field a\" => \"AA   \", \"field b\" => \"bbbBB\", \"field c\" => 2, \"field d\" => \"+\", \"field e\" => \"1d345\"}\n${\"field a\" => \"AAA  \", \"field b\" => \"bbBBB\", \"field c\" => 3, \"field d\" => \"+\", \"field e\" => \"12d45\"}\n${\"field a\" => \"AAAA \", \"field b\" => \"bBBBB\", \"field c\" => 4, \"field d\" => \"-\", \"field e\" => \"123d5\"}\n${\"field a\" => \"AAAAA\", \"field b\" => \"BBBBB\", \"field c\" => 3729368837, \"field d\" => \"-\", \"field e\" => \"1234d\"}\n\nOutput:\nA    +00000001xxxxx\nAA   +00000002xxxxx\nAAA  +00000003xxxxx\nAAAA -00000004xxxxx\nAAAAA-de49a705xxxxx\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nThis is admittedly a trivial task but I thought it would be interesting to see how succinctly (or otherwise) different languages can handle it.\n\nGiven the string: \"abracadabra\", replace programatically:\n\n* the first 'a' with 'A'\n* the second 'a' with 'B'\n* the fourth 'a' with 'C'\n* the fifth 'a' with 'D'\n* the first 'b' with 'E'\n* the second 'r' with 'F'\n\nNote that there is no replacement for the third 'a', second 'b' or first 'r'.\n\nThe answer should, of course, be : \"AErBcadCbFD\".\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "Set up to not particularly rely on absolute structure of the word. Demonstrate with both the original 'abracadabra' and with a random shuffled instance.\n\n```\nsub mangle ($str is copy) {\n    $str.match(:ex, 'a')».from.map: { $str.substr-rw($_, 1) = 'ABaCD'.comb[$++] };\n    $str.=subst('b', 'E');\n    $str.substr-rw($_, 1) = 'F' given $str.match(:ex, 'r')».from[1];\n    $str\n}\n\nsay $_, ' -> ', .&mangle given 'abracadabra';\n\nsay $_, ' -> ', .&mangle given 'abracadabra'.comb.pick(*).join;\n\n```\n\nOutput:\n\n```\nabracadabra -> AErBcadCbFD\ncaarabadrab -> cABraECdFDb\n```"}]}
{"messages": [{"role": "user", "content": "A number n is a self number if there is no number g such that g + the sum of g's digits = n. So 18 is not a self number because 9+9=18, 43 is not a self number because 35+5+3=43.\n  \nThe task is:\n\n```\n Display the first 50 self numbers;\n I believe that the 100000000th self number is 1022727208. You should either confirm or dispute my conjecture.\n\n```\n\n224036583-1 is a Mersenne prime, claimed to also be a self number. Extra credit to anyone proving it.\n\nSee also\n\n* OEIS: A003052 - Self numbers or Colombian numbers * Wikipedia: Self numbers"}, {"role": "assistant", "content": "Translated the low memory version of the Go entry but showed only the first 50 self numbers. The machine for running this task (a Xeon E3110+8GB memory) is showing its age as, 1) took over 6 minutes to complete the Go entry, 2) not even able to run the other two Go alternative entries and 3) needed over 47 minutes to reach 1e6 iterations here. Anyway I will try this on an i5 box later to see how it goes.\n\n**Translation of**: Go\n\n```\n# 20201127 Raku programming solution\n\nmy ( $st, $count, $i, $pow, $digits, $offset, $lastSelf, $done, @selfs) =\n     now,      0,  1,   10,       1,       9,         0, False;\n\n# while ( $count < 1e8 ) {\nuntil $done {\n   my $isSelf = True;\n   my $sum    = (my $start = max ($i-$offset), 0).comb.sum;\n   loop ( my $j = $start; $j < $i; $j+=1 ) {\n      if $j+$sum == $i { $isSelf = False and last }\n      ($j+1)%10 != 0 ?? ( $sum+=1 ) !! ( $sum = ($j+1).comb.sum ) ;\n   }\n   if $isSelf {\n      $count+=1;\n      $lastSelf = $i;\n      if $count ≤ 50 {\n         @selfs.append: $i;\n         if $count == 50 {\n            say \"The first 50 self numbers are:\\n\", @selfs;\n            $done = True;\n         }\n      }\n   }\n   $i+=1;\n   if $i % $pow == 0 {\n      $pow *= 10;\n      $digits+=1 ;\n      $offset = $digits * 9\n   }\n}\n\n# say \"The 100 millionth self number is \", $lastSelf;\n# say \"Took \", now - $st, \" seconds.\"\n\n```\n\nOutput:\n\n```\nThe first 50 self numbers are:\n[1 3 5 7 9 20 31 42 53 64 75 86 97 108 110 121 132 143 154 165 176 187 198 209 211 222 233 244 255 266 277 288 299 310 312 323 334 345 356 367 378 389 400 411 413 424 435 446 457 468]\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nThere are several so-called \"self-describing\" or \"self-descriptive\" integers.\n\nAn integer is said to be \"self-describing\" if it has the property that, when digit positions are labeled 0 to N-1, the digit in each position is equal to the number of times that that digit appears in the number.\n\nFor example,   **2020**   is a four-digit self describing number:\n\n* position   0   has value   2   and there are two 0s in the number;\n* position   1   has value   0   and there are no 1s in the number;\n* position   2   has value   2   and there are two 2s;\n* position   3   has value   0   and there are zero 3s.\n\nSelf-describing numbers < 100.000.000  are:     1210,   2020,   21200,   3211000,   42101000.\n\nTask Description\n\n1. Write a function/routine/method/... that will check whether a given positive integer is self-describing.\n2. As an optional stretch goal - generate and display the set of self-describing numbers.\n\nRelated tasks\n\n* Fours is the number of letters in the ...\n* Look-and-say sequence\n* Number names\n* Self-referential sequence\n* Spelling of ordinal numbers"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @values = <1210 2020 21200 3211000\n42101000 521001000 6210001000 27 115508>;\n\nfor @values -> $test {\n    say \"$test is {sdn($test) ?? '' !! 'NOT ' }a self describing number.\";\n}\n\nsub sdn($n) {\n    my $s = $n.Str;\n    my $chars = $s.chars;\n    my @a = +«$s.comb;\n    my @b;\n    for @a -> $i {\n        return False if $i >= $chars;\n        ++@b[$i];\n    }\n    @b[$_] //= 0 for ^$chars;\n    @a eqv @b;\n}\n\n.say if .&sdn for ^9999999;\n\n```\n\nOutput:\n\n```\n1210 is a self describing number.\n2020 is a self describing number.\n21200 is a self describing number.\n3211000 is a self describing number.\n42101000 is a self describing number.\n521001000 is a self describing number.\n6210001000 is a self describing number.\n27 is NOT a self describing number.\n115508 is NOT a self describing number.\n1210\n2020\n21200\n3211000\n\n```"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification due to it being believed to be too difficult to implement in a reasonable amount of effort in more than one (usually very specialised) language. It may need to be divided into multiple tasks or modified substantially so that multiple implementations are practical, and that may cause code on this page in its current state to be flagged incorrect afterwards. See this page's Talk page for discussion.\n\nImplement a self-hosting compiler for your language, i.e.:   create a compiler that is implemented in the language it's supposed to compile.\n\nExtra credit for any solution that can compile in an online compiler such as Ideone.\n\nIf this isn't feasible due to language complexity, link to external projects that achieve this task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nuse MONKEY-SEE-NO-EVAL;\nEVAL slurp\n\n```"}]}
{"messages": [{"role": "user", "content": "Semiprime numbers are natural numbers that are products of exactly two (possibly equal) prime numbers.\n\n**Semiprimes**   are also known as:\n\n:   :   :   * **semi-primes**\n            * **biprimes**\n            * **bi-primes**\n            * ***2-almost***    primes\n            * or simply:    ***P2***\n\nExample\n\n```\n   1679  =  23 × 73  \n\n```\n\n(This particular number was chosen as the length of the Arecibo message).\n\nTask\n\nWrite a function determining whether a given number is semiprime.\n\nSee also\n\n* The Wikipedia article:  semiprime.\n* The Wikipedia article:  almost prime.\n* The OEIS sequence:  A001358: semiprimes  which has a shorter definition: *the product of two primes*."}, {"role": "assistant", "content": "(formerly Perl 6)\nHere is a naive, grossly inefficient implementation.\n\n```\nsub is-semiprime (Int $n --> Bool) {\n    not $n.is-prime and\n        .is-prime given \n        $n div first $n %% *, flat grep &is-prime, 2 .. *;\n}\n\nuse Test;\nmy @primes = flat grep &is-prime, 2 .. 100;\nfor ^5 {\n    nok is-semiprime([*] my @f1 = @primes.roll(1)), ~@f1;\n    ok  is-semiprime([*] my @f2 = @primes.roll(2)), ~@f2;\n    nok is-semiprime([*] my @f3 = @primes.roll(3)), ~@f3;\n    nok is-semiprime([*] my @f4 = @primes.roll(4)), ~@f4;\n}\n\n```\n\nOutput:\n\n```\nok 1 - 17\nok 2 - 47 23\nok 3 - 23 37 41\nok 4 - 53 37 67 47\nok 5 - 5\nok 6 - 73 43\nok 7 - 13 53 71\nok 8 - 7 79 37 71\nok 9 - 41\nok 10 - 71 37\nok 11 - 37 53 43\nok 12 - 3 2 47 67\nok 13 - 17\nok 14 - 41 61\nok 15 - 71 31 79\nok 16 - 97 17 73 17\nok 17 - 61\nok 18 - 73 47\nok 19 - 13 19 5\nok 20 - 37 97 11 31\n```\n\n### More efficient example\n\nHere is a more verbose, but MUCH more efficient implementation. Demonstrating using it to find an infinite list of semiprimes and to check a range of integers to find the semiprimes.\n\n**Works with**: Rakudo version 2017.02\n\n```\nsub is-semiprime ( Int $n where * > 0 ) {\n    return False if $n.is-prime;\n    my $factor = find-factor( $n );\n    return True if $factor.is-prime && ( $n div $factor ).is-prime;\n    False;\n}\n\nsub find-factor ( Int $n, $constant = 1 ) {\n    my $x      = 2;\n    my $rho    = 1;\n    my $factor = 1;\n    while $factor == 1 {\n        $rho *= 2;\n        my $fixed = $x;\n        for ^$rho {\n            $x = ( $x * $x + $constant ) % $n;\n            $factor = ( $x - $fixed ) gcd $n;\n            last if 1 < $factor;\n        }\n    }\n    $factor = find-factor( $n, $constant + 1 ) if $n == $factor;\n    $factor;\n}\n\nINIT my $start = now;\n\n# Infinite list of semiprimes\nconstant @semiprimes = lazy gather for 4 .. * { .take if .&is-semiprime };\n\n# Show the semiprimes < 100\nsay 'Semiprimes less than 100:';\nsay @semiprimes[^ @semiprimes.first: * > 100, :k ], \"\\n\";\n\n# Check individual integers, or in this case, a range\nmy $s = 2⁹⁷ - 1;\nsay \"Is $_ semiprime?: \", .&is-semiprime for $s .. $s + 30;\n\nsay 'elapsed seconds: ', now - $start;\n\n```\n\nOutput:\n\n```\nSemiprimes less than 100:\n(4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95)\n\nIs 158456325028528675187087900671 semiprime?: True\nIs 158456325028528675187087900672 semiprime?: False\nIs 158456325028528675187087900673 semiprime?: False\nIs 158456325028528675187087900674 semiprime?: False\nIs 158456325028528675187087900675 semiprime?: False\nIs 158456325028528675187087900676 semiprime?: False\nIs 158456325028528675187087900677 semiprime?: False\nIs 158456325028528675187087900678 semiprime?: False\nIs 158456325028528675187087900679 semiprime?: False\nIs 158456325028528675187087900680 semiprime?: False\nIs 158456325028528675187087900681 semiprime?: False\nIs 158456325028528675187087900682 semiprime?: False\nIs 158456325028528675187087900683 semiprime?: False\nIs 158456325028528675187087900684 semiprime?: False\nIs 158456325028528675187087900685 semiprime?: False\nIs 158456325028528675187087900686 semiprime?: False\nIs 158456325028528675187087900687 semiprime?: False\nIs 158456325028528675187087900688 semiprime?: False\nIs 158456325028528675187087900689 semiprime?: False\nIs 158456325028528675187087900690 semiprime?: False\nIs 158456325028528675187087900691 semiprime?: False\nIs 158456325028528675187087900692 semiprime?: False\nIs 158456325028528675187087900693 semiprime?: False\nIs 158456325028528675187087900694 semiprime?: False\nIs 158456325028528675187087900695 semiprime?: False\nIs 158456325028528675187087900696 semiprime?: False\nIs 158456325028528675187087900697 semiprime?: False\nIs 158456325028528675187087900698 semiprime?: False\nIs 158456325028528675187087900699 semiprime?: False\nIs 158456325028528675187087900700 semiprime?: False\nIs 158456325028528675187087900701 semiprime?: True\nelapsed seconds: 0.0574433\n```"}]}
{"messages": [{"role": "user", "content": "A semordnilap is a word (or phrase) that spells a different word (or phrase) backward. \"Semordnilap\" is a word that itself is a semordnilap.\n\nExample: *lager* and *regal*\n\nTask\n\nThis task does not consider semordnilap phrases, only single words.\nUsing only words from this list, report the total number of unique semordnilap pairs, and print 5 examples.\nTwo matching semordnilaps, such as *lager* and *regal*, should be counted as one unique pair.\n(Note that the word \"semordnilap\" is not in the above dictionary.)\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-10-26\n\n```\nmy $words = set slurp(\"unixdict.txt\").lines;\n\nmy @sems = gather for $words.flat -> $word {\n    my $drow = $word.key.flip;\n    take $drow if $drow ∈ $words and $drow lt $word;\n}\n\nsay $_ ~ ' ' ~ $_.flip for @sems.pick(5);\n\n```\n\nOutput:\n\n```\nabut tuba\navid diva\nbard drab\nloot tool\npart trap\n```"}]}
{"messages": [{"role": "user", "content": "Write a program in your language to solve SEND + MORE = MONEY: A Great Puzzle."}, {"role": "assistant", "content": "### Idiomatic\n\n```\nenum <D E M N O R S Y>;\n\nsub find_solution ( ) {\n    for ('0'..'9').combinations(8) -> @c {\n        .return with @c.permutations.first: -> @p {\n            @p[M] !== 0 and\n\n            @p[  S,E,N,D].join\n          + @p[  M,O,R,E].join\n         == @p[M,O,N,E,Y].join\n        }\n    }\n}\n\nmy @s = find_solution();\nsay \"    {@s[  S,E,N,D].join}\";\nsay \" +  {@s[  M,O,R,E].join}\";\nsay \"== { @s[M,O,N,E,Y].join}\";\n\n```\n\nOutput:\n\n```\n    9567\n +  1085\n== 10652\n\n```\n\n### Fast\n\nAlternately, a version written in 2015 by Carl Mäsak. Not very concise but quite speedy. Applying the observation that M must be 1 and S must be either 8 or 9 gets the runtime under a tenth of a second.\n\n```\nmy $s = 7;\nwhile ++$s ≤ 9 {\n    my $e = -1;\n    while ++$e ≤ 9 {\n        next if $e == $s;\n \n        my $n = -1;\n        while ++$n ≤ 9 {\n            next if $n == $s|$e;\n \n            my $d = -1;\n            while ++$d ≤ 9 {\n                next if $d == $s|$e|$n;\n\n                my $send = $s×10³ + $e×10² + $n×10 + $d; \n                my ($m, $o) = 1, -1;\n                while ++$o ≤ 9 {\n                    next if $o == $s|$e|$n|$d|$m;\n \n                    my $r = -1;\n                    while ++$r ≤ 9 {\n                        next if $r == $s|$e|$n|$d|$m|$o;\n \n                        my $more = $m×10³ + $o×10² + $r×10 + $e;\n                        my $y = -1;\n                        while ++$y ≤ 9 {\n                            next if $y == $s|$e|$n|$d|$m|$o|$r;\n\n                            my $money = $m×10⁴ + $o×10³ + $n×10² + $e×10 + $y;\n                            next unless $send + $more == $money;\n                            say 'SEND + MORE == MONEY' ~ \"\\n$send + $more == $money\";\n                        }\n                    }\n                }\n            }\n        }\n    }\n}\nprintf \"%.3f elapsed seconds\", now - INIT now;\n\n```\n\nOutput:\n\n```\nSEND + MORE == MONEY\n9567 + 1085 == 10652\n0.080 elapsed seconds\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nInvoke an object method where the name of the method to be invoked can be generated at run time.\n\nRelated tasks\n\n* Respond to an unknown method call.\n* Runtime evaluation"}, {"role": "assistant", "content": "(formerly Perl 6)\nJust for the fun of it, we'll mix in an anonymous role into an integer instead of defining a class.\n\n```\nmy $object = 42 but role { method add-me($x) { self + $x } }\nmy $name = 'add-me';\nsay $object.\"$name\"(5);  # 47\n\n```\n\nThe double quotes are required, by the way; without them the variable would be interpreted as a hard ref to a method."}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function to send an email.\n\nThe function should have parameters for setting From, To and Cc addresses; the Subject, and the message text, and optionally fields for the server name and login details.\n\n* If appropriate, explain what notifications of problems/success are given.\n* Solutions using libraries or functions from the language are preferred, but failing that, external programs can be used with an explanation.\n* Note how portable the solution given is between operating systems when multi-OS languages are used.\n\n(Remember to obfuscate any sensitive data used in examples)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nuse Email::Simple;\n\nmy $to      = 'mail@example.com';\nmy $from    = 'me@example.com';\nmy $subject = 'test';\nmy $body    = 'This is a test.';\n\nmy $email = Email::Simple.create(\n    :header[['To', $to], ['From', $from], ['Subject', $subject]],\n    :body($body)\n);\n\nsay ~$email;\n\n# Note that the following will fail without an actual smtp server that\n# will accept anonymous emails on port 25 (Not very common anymore).\n# Most public email servers now require authentication and encryption.\n\nmy $smtp-server = 'smtp.example.com';\nmy $smtp-port   = 25;\n\nawait IO::Socket::Async.connect($smtp-server, $smtp-port).then(\n    -> $smtp {\n        if $smtp.status {\n            given $smtp.result {\n                react {\n                    whenever .Supply() -> $response {\n                        if $response ~~ /^220/ {\n                            .print( join \"\\r\\n\",\n                                \"EHLO $smtp-server\",\n                                \"MAIL FROM:<{$email.from}>\",\n                                \"RCPT TO:<{$email.to}>\",\n                                \"DATA\", $email.body,\n                                '.', ''\n                            )\n                        }\n                        elsif $response ~~ /^250/ {\n                            .print(\"QUIT\\r\\n\");\n                            done\n                        }\n                        else {\n                           say \"Send email failed with: $response\";\n                           done\n                        }\n                    }\n                    .close\n                }\n            }\n        }\n    }\n)\n\n```"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nIn Germany and the Netherlands postal addresses have the form: street name, followed by the house number, in accordance with the national standards DIN 5008 respectively NEN 5825. The problem is that some street names have numbers (e.g. special years) and some house numbers have characters as an extension. It's a real life problem and difficult because in the Netherlands some street names are a tribute to our liberators. The street names have the numbers 40 and 45 indicating the years of war between 1940 and 1945.\n\nTask\n\nWrite code that correctly separates the house number from the street name and presents them both.\n*No static data must be shown, only processed data.*\n\nThe suggested approach is to either use the regular expression in the Scala entry or to devise an equivalent algorithm.\n\nThe test-set:\n\n```\nPlataanstraat 5\nStraat 12\nStraat 12 II\nDr. J. Straat   12\nDr. J. Straat 12 a\nDr. J. Straat 12-14\nLaan 1940 – 1945 37\nPlein 1940 2\n1213-laan 11\n16 april 1944 Pad 1\n1e Kruisweg 36\nLaan 1940-’45 66\nLaan ’40-’45\nLangeloërduinen 3 46\nMarienwaerdt 2e Dreef 2\nProvincialeweg N205 1\nRivium 2e Straat 59.\nNieuwe gracht 20rd\nNieuwe gracht 20rd 2\nNieuwe gracht 20zw /2\nNieuwe gracht 20zw/3\nNieuwe gracht 20 zw/4\nBahnhofstr. 4\nWertstr. 10\nLindenhof 1\nNordesch 20\nWeilstr. 6\nHarthauer Weg 2\nMainaustr. 49\nAugust-Horch-Str. 3\nMarktplatz 31\nSchmidener Weg 3\nKarl-Weysser-Str. 6\n```\n\nReference The Netherlands - Addresses"}, {"role": "assistant", "content": "(formerly Perl 6)\nAn unquestioning translation of the Scala example's regex to show how we lay out such regexes for readability in Raku, except that we take the liberty of leaving the space out of the house number.\n(Hard constants like 1940 and 1945 are a code smell,\nand the task should probably not require such constants unless there is a standard to point to that mandates them.)\nSo expect this solution to change if the task is actually defined reasonably, such as by specifying that four-digit house numbers are excluded in Europe.\n(In contrast, four- and five-digit house numbers are not uncommon\nin places such as the U.S. where each block gets a hundred house numbers\nto play with, and there are cities with hundreds of blocks along a street.)\n\n```\nsay m[\n    ( .*? )\n\n    [\n        \\s+\n        (\n        | \\d+ [ \\- | \\/ ] \\d+\n        | <!before 1940 | 1945> \\d+ <[ a..z I . / \\x20 ]>* \\d*\n        )\n    ]?\n\n    $\n] for lines;\n\n```\n\nOutput:\n\n```\n｢Plataanstraat 5｣\n 0 => ｢Plataanstraat｣\n 1 => ｢5｣\n\n｢Straat 12｣\n 0 => ｢Straat｣\n 1 => ｢12｣\n\n｢Straat 12 II｣\n 0 => ｢Straat｣\n 1 => ｢12 II｣\n\n｢Dr. J. Straat   12｣\n 0 => ｢Dr. J. Straat｣\n 1 => ｢12｣\n\n｢Dr. J. Straat 12 a｣\n 0 => ｢Dr. J. Straat｣\n 1 => ｢12 a｣\n\n｢Dr. J. Straat 12-14｣\n 0 => ｢Dr. J. Straat｣\n 1 => ｢12-14｣\n\n｢Laan 1940 – 1945 37｣\n 0 => ｢Laan 1940 – 1945｣\n 1 => ｢37｣\n\n｢Plein 1940 2｣\n 0 => ｢Plein 1940｣\n 1 => ｢2｣\n\n｢1213-laan 11｣\n 0 => ｢1213-laan｣\n 1 => ｢11｣\n\n｢16 april 1944 Pad 1｣\n 0 => ｢16 april 1944 Pad｣\n 1 => ｢1｣\n\n｢1e Kruisweg 36｣\n 0 => ｢1e Kruisweg｣\n 1 => ｢36｣\n\n｢Laan 1940-’45 66｣\n 0 => ｢Laan 1940-’45｣\n 1 => ｢66｣\n\n｢Laan ’40-’45｣\n 0 => ｢Laan ’40-’45｣\n\n｢Langeloërduinen 3 46｣\n 0 => ｢Langeloërduinen｣\n 1 => ｢3 46｣\n\n｢Marienwaerdt 2e Dreef 2｣\n 0 => ｢Marienwaerdt 2e Dreef｣\n 1 => ｢2｣\n\n｢Provincialeweg N205 1｣\n 0 => ｢Provincialeweg N205｣\n 1 => ｢1｣\n\n｢Rivium 2e Straat 59.｣\n 0 => ｢Rivium 2e Straat｣\n 1 => ｢59.｣\n\n｢Nieuwe gracht 20rd｣\n 0 => ｢Nieuwe gracht｣\n 1 => ｢20rd｣\n\n｢Nieuwe gracht 20rd 2｣\n 0 => ｢Nieuwe gracht｣\n 1 => ｢20rd 2｣\n\n｢Nieuwe gracht 20zw /2｣\n 0 => ｢Nieuwe gracht｣\n 1 => ｢20zw /2｣\n\n｢Nieuwe gracht 20zw/3｣\n 0 => ｢Nieuwe gracht｣\n 1 => ｢20zw/3｣\n\n｢Nieuwe gracht 20 zw/4｣\n 0 => ｢Nieuwe gracht｣\n 1 => ｢20 zw/4｣\n\n｢Bahnhofstr. 4｣\n 0 => ｢Bahnhofstr.｣\n 1 => ｢4｣\n\n｢Wertstr. 10｣\n 0 => ｢Wertstr.｣\n 1 => ｢10｣\n\n｢Lindenhof 1｣\n 0 => ｢Lindenhof｣\n 1 => ｢1｣\n\n｢Nordesch 20｣\n 0 => ｢Nordesch｣\n 1 => ｢20｣\n\n｢Weilstr. 6｣\n 0 => ｢Weilstr.｣\n 1 => ｢6｣\n\n｢Harthauer Weg 2｣\n 0 => ｢Harthauer Weg｣\n 1 => ｢2｣\n\n｢Mainaustr. 49｣\n 0 => ｢Mainaustr.｣\n 1 => ｢49｣\n\n｢August-Horch-Str. 3｣\n 0 => ｢August-Horch-Str.｣\n 1 => ｢3｣\n\n｢Marktplatz 31｣\n 0 => ｢Marktplatz｣\n 1 => ｢31｣\n\n｢Schmidener Weg 3｣\n 0 => ｢Schmidener Weg｣\n 1 => ｢3｣\n\n｢Karl-Weysser-Str. 6｣\n 0 => ｢Karl-Weysser-Str.｣\n 1 => ｢6｣\n\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow that the following remarkable formula gives the sequence of non-square natural numbers:\n\n```\n            n + floor(1/2 + sqrt(n)) \n\n```\n\n* Print out the values for    n    in the range   **1**   to   **22**\n* Show that no squares occur for    n    less than one million\n\nThis is sequence   A000037   in the **OEIS** database."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.07\n\n```\nsub nth-term (Int $n) { $n + round sqrt $n }\n\n# Print the first 22 values of the sequence\nsay (nth-term $_ for 1 .. 22);\n\n# Check that the first million values of the sequence are indeed non-square\nfor 1 .. 1_000_000 -> $i {\n    say \"Oops, nth-term($i) is square!\" if (sqrt nth-term $i) %% 1;\n}\n\n```\n\nOutput:\n\n```\n(2 3 5 6 7 8 10 11 12 13 14 15 17 18 19 20 21 22 23 24 26 27)\n```"}]}
{"messages": [{"role": "user", "content": "The sequence of primorial primes is given as the increasing values of n where primorial(n) ± 1 is prime.\n\nNoting that the n'th primorial is defined as the multiplication of the smallest n primes, the sequence is of the number of primes, in order that when multiplied together is one-off being a prime number itself.\n\nTask\n\nGenerate and show here the first ten values of the sequence.\n\nOptional extended task\n\nShow the first twenty members of the series.\n\nNotes\n\n* This task asks for the primorial *indices* that create the final primorial prime numbers, so there should be no ten-or-more digit numbers in the program output (although extended precision integers *will* be needed for intermediate results).\n* There is some confusion in the references, but for the purposes of this task the **sequence begins with n = 1**.\n* Probabilistic primality tests are allowed, as long as they are good enough such that the output shown is correct.\n\nRelated tasks\n\n* Primorial numbers\n* Factorial\n\nSee also\n\n* Primorial prime Wikipedia.\n* Primorial prime from The Prime Glossary.\n* Sequence A088411 from The On-Line Encyclopedia of Integer Sequences"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nconstant @primes     = |grep *.is-prime, 2..*;\nconstant @primorials = [\\*] 1, @primes;\n\nmy @pp_indexes := |@primorials.pairs.map: {\n    .key if ( .value + any(1, -1) ).is-prime\n};\n\nsay ~ @pp_indexes[ 0 ^.. 20 ]; # Skipping bogus first element.\n\n```\n\nOutput:\n\n```\n1 2 3 4 5 6 11 13 24 66 68 75 167 171 172 287 310 352 384 457\n```\n\n### Alternate implementation\n\nmerged from another removed draft task.\n\n```\nmy @primorials = 1, |[\\*] (2..*).grep: &is-prime;\nsub abr ($_) { .chars < 41 ?? $_ !! .substr(0,20) ~ '..' ~ .substr(*-20) ~ \" ({.chars} digits)\" }\n\nmy $limit;\n\nfor ^∞ {\n    my \\p = @primorials[$_];\n    ++$limit and printf \"%2d: %5s - 1 = %s\\n\", $limit, \"p$_#\", abr p -1 if (p -1).is-prime;\n    ++$limit and printf \"%2d: %5s + 1 = %s\\n\", $limit, \"p$_#\", abr p +1 if (p +1).is-prime;\n    exit if $limit >= 30\n}\n\n```\n\nOutput:\n\n```\n 1:   p0# + 1 = 2\n 2:   p1# + 1 = 3\n 3:   p2# - 1 = 5\n 4:   p2# + 1 = 7\n 5:   p3# - 1 = 29\n 6:   p3# + 1 = 31\n 7:   p4# + 1 = 211\n 8:   p5# - 1 = 2309\n 9:   p5# + 1 = 2311\n10:   p6# - 1 = 30029\n11:  p11# + 1 = 200560490131\n12:  p13# - 1 = 304250263527209\n13:  p24# - 1 = 23768741896345550770650537601358309\n14:  p66# - 1 = 19361386640700823163..29148240284399976569 (131 digits)\n15:  p68# - 1 = 21597045956102547214..98759003964186453789 (136 digits)\n16:  p75# + 1 = 17196201054584064334..62756822275663694111 (154 digits)\n17: p167# - 1 = 19649288510530675457..35580823050358968029 (413 digits)\n18: p171# + 1 = 20404068993016374194..29492908966644747931 (425 digits)\n19: p172# + 1 = 20832554441869718052..12260054944287636531 (428 digits)\n20: p287# - 1 = 71488723083486699645..63871022000761714929 (790 digits)\n21: p310# - 1 = 40476351620665036743..10663664196050230069 (866 digits)\n22: p352# - 1 = 13372477493552802137..21698973741675973189 (1007 digits)\n23: p384# + 1 = 78244737296323701708..84011652643245393971 (1115 digits)\n24: p457# + 1 = 68948124012218025568..25023568563926988371 (1368 digits)\n25: p564# - 1 = 12039145942930719470..56788854266062940789 (1750 digits)\n26: p590# - 1 = 19983712295113492764..61704122697617268869 (1844 digits)\n27: p616# + 1 = 13195724337318102247..85805719764535513291 (1939 digits)\n28: p620# - 1 = 57304682725550803084..81581766766846907409 (1953 digits)\n29: p643# + 1 = 15034815029008301639..38987057002293989891 (2038 digits)\n30: p849# - 1 = 11632076146197231553..78739544174329780009 (2811 digits)\n```"}]}
{"messages": [{"role": "user", "content": "Calculate the sequence where each term **an** is the **nth** that has **n** divisors.\n\nTask\n\nShow here, on this page, at least the first **15** terms of the sequence.\n\nSee also\n\n:   * OEIS:A073916\n\nRelated tasks\n\n:   * Sequence: smallest number greater than previous term with exactly n divisors\n    * Sequence: smallest number with exactly n divisors"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\nTry it online!\n\n```\nsub div-count (\\x) {\n    return 2 if x.is-prime;\n    +flat (1 .. x.sqrt.floor).map: -> \\d {\n        unless x % d { my \\y = x div d; y == d ?? y !! (y, d) }\n    }\n}\n\nmy $limit = 20;\n\nmy @primes = grep { .is-prime }, 1..*;\n@primes[$limit]; # prime the array. SCNR\n\nput \"First $limit terms of OEIS:A073916\";\nput (1..$limit).hyper(:2batch).map: -> $n {\n    ($n > 4 and $n.is-prime) ??\n    exp($n - 1, @primes[$n - 1]) !!\n    do {\n        my $i = 0;\n        my $iterator = $n %% 2 ?? (1..*) !! (1..*).map: *²;\n        $iterator.first: {\n            next unless $n == .&div-count;\n            next unless ++$i == $n;\n            $_\n        }\n    }\n};\n\n```\n\n```\nFirst 20 terms of OEIS:A073916\n1 3 25 14 14641 44 24137569 70 1089 405 819628286980801 160 22563490300366186081 2752 9801 462 21559177407076402401757871041 1044 740195513856780056217081017732809 1520\n```"}]}
{"messages": [{"role": "user", "content": "Calculate the sequence where each term **an** is the **smallest natural number** greater than the previous term, that has exactly **n** divisors.\n\nTask\n\nShow here, on this page, at least the first **15** terms of the sequence.\n\nSee also\n:   * OEIS:A069654\n\nRelated tasks\n:   * Sequence: smallest number with exactly n divisors\n    * Sequence: nth number with exactly n divisors‎‎"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\n```\nsub div-count (\\x) {\n    return 2 if x.is-prime;\n    +flat (1 .. x.sqrt.floor).map: -> \\d {\n        unless x % d { my \\y = x div d; y == d ?? y !! (y, d) }\n    }\n}\n\nmy $limit = 15;\n\nmy $m = 1;\nput \"First $limit terms of OEIS:A069654\";\nput (1..$limit).map: -> $n { my $ = $m = first { $n == .&div-count }, $m..Inf };\n\n```\n\nOutput:\n\n```\nFirst 15 terms of OEIS:A069654\n1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624\n\n```"}]}
{"messages": [{"role": "user", "content": "Calculate the sequence where each term   **an**   is the **smallest natural number** that has exactly   **n**   divisors.\n\nTask\n\nShow here, on this page, at least the first  **15**  terms of the sequence.\n\nRelated tasks\n:   * Sequence: smallest number greater than previous term with exactly n divisors\n    * Sequence: nth number with exactly n divisors‎‎\n\nSee also\n:   * OEIS:A005179"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03\n\n```\nsub div-count (\\x) {\n    return 2 if x.is-prime;\n    +flat (1 .. x.sqrt.floor).map: -> \\d {\n        unless x % d { my \\y = x div d; y == d ?? y !! (y, d) }\n    }\n}\n\nmy $limit = 15;\n\nput \"First $limit terms of OEIS:A005179\";\nput (1..$limit).map: -> $n { first { $n == .&div-count }, 1..Inf };\n\n```\n\nOutput:\n\n```\nFirst 15 terms of OEIS:A005179\n1 2 4 6 16 12 64 24 36 48 1024 60 4096 192 144\n```"}]}
{"messages": [{"role": "user", "content": "A   **set**  is a collection of elements, without duplicates and without order.\n\nTask\n\nShow each of these set operations:\n\n* Set creation\n* Test m ∈ S -- \"m is an element in set S\"\n* A ∪ B -- *union*; a set of all elements either in set A or in set B.\n* A ∩ B -- *intersection*; a set of all elements in *both* set A and set B.\n* A ∖ B -- *difference*; a set of all elements in set A, except those in set B.\n* A ⊆ B -- *subset*; true if every element in set A is also in set B.\n* A = B -- *equality*; true if every element of set A is in set B and vice versa.\n\nAs an option, show some other set operations.\n  \n(If A ⊆ B, but A ≠ B, then A is called a true or proper subset of B, written A ⊂ B or A ⊊ B.)\n\nAs another option, show how to modify a mutable set.\n\nOne might implement a set using an associative array (with set elements as array keys and some dummy value as the values).\n\nOne might also implement a set with a binary search tree, or with a hash table, or with an ordered array of binary bits (operated on with bit-wise binary operators).\n\nThe basic test, m ∈ S, is O(n) with a sequential list of elements, O(*log* n) with a balanced binary search tree, or (O(1) average-case, O(n) worst case) with a hash table.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nuse Test;\n\nmy $a = set <a b c>;\nmy $b = set <b c d>;\nmy $c = set <a b c d e>;\n\nok 'c' ∈ $a, \"c is an element in set A\";\nnok 'd' ∈ $a, \"d is not an element in set A\";\n\nis-deeply $a ∪ $b, set(<a b c d>), \"union; a set of all elements either in set A or in set B\";\nis-deeply $a ∩ $b, set(<b c>), \"intersection; a set of all elements in both set A and set B\";\nis $a (-) $b, set(<a>), \"difference; a set of all elements in set A, except those in set B\";\n\nok $a ⊆ $c, \"subset; true if every element in set A is also in set B\";\nnok $c ⊆ $a, \"subset; false if every element in set A is not also in set B\";\nok $a ⊂ $c, \"strict subset; true if every element in set A is also in set B\";\nnok $a ⊂ $a, \"strict subset; false for equal sets\";\nok $a === set(<a b c>), \"equality; true if every element of set A is in set B and vice-versa\";\nnok $a === $b, \"equality; false for differing sets\";\n\n```\n\nOutput:\n\n```\nok 1 - c is an element in set A\nok 2 - d is not an element in set A\nok 3 - union; a set of all elements either in set A or in set B\nok 4 - intersection; a set of all elements in both set A and set B\nok 5 - difference; a set of all elements in set A, except those in set B\nok 6 - subset; true if every element in set A is also in set B\nok 7 - subset; false if every element in set A is not also in set B\nok 8 - strict subset; true if every element in set A is also in set B\nok 9 - strict subset; false for equal sets\nok 10 - equality; true if every element of set A is in set B and vice-versa\nok 11 - equality; false for differing sets\n```"}]}
{"messages": [{"role": "user", "content": "Given two sets of items then if any item is common to any set then the result of applying *consolidation* to those sets is a set of sets whose contents is:\n\n* The two input sets if no common item exists between the two input sets of items.\n* The single set that is the union of the two input sets if they share a common item.\n\nGiven N sets of items where N>2 then the result is the same as repeatedly replacing all combinations of two sets by their consolidation until no further consolidation between set pairs is possible.\nIf N<2 then consolidation has no strict meaning and the input can be returned.\n\n**Example 1:**\n:   Given the two sets {A,B} and {C,D} then there is no common element between the sets and the result is the same as the input.\n\n**Example 2:**\n:   Given the two sets {A,B} and {B,D} then there is a common element B between the sets and the result is the single set {B,D,A}. (Note that order of items in a set is immaterial: {A,B,D} is the same as {B,D,A} and {D,A,B}, etc).\n\n**Example 3:**\n:   Given the three sets {A,B} and {C,D} and {D,B} then there is no common element between the sets {A,B} and {C,D} but the sets {A,B} and {D,B} do share a common element that consolidates to produce the result {B,D,A}. On examining this result with the remaining set, {C,D}, they share a common element and so consolidate to the final output of the single set {A,B,C,D}\n\n**Example 4:**\n:   The consolidation of the five sets:\n\n    :   {H,I,K}, {A,B}, {C,D}, {D,B}, and {F,G,H}\n:   Is the two sets:\n\n    :   {A, C, B, D}, and {G, F, I, H, K}\n\n**See also**\n\n* Connected component (graph theory)\n* Range consolidation"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmulti consolidate() { () }\nmulti consolidate(Set \\this is copy, *@those) {\n    gather {\n        for consolidate |@those -> \\that {\n            if this ∩ that { this = this ∪ that }\n            else           { take that }\n        }\n        take this;\n    }\n}\n\nenum Elems <A B C D E F G H I J K>;\nsay $_, \"\\n    ==> \", consolidate |$_\n    for [set(A,B), set(C,D)],\n        [set(A,B), set(B,D)],\n        [set(A,B), set(C,D), set(D,B)],\n        [set(H,I,K), set(A,B), set(C,D), set(D,B), set(F,G,H)];\n\n```\n\nOutput:\n\n```\nset(A, B) set(C, D)\n    ==> set(C, D) set(A, B)\nset(A, B) set(B, D)\n    ==> set(A, B, D)\nset(A, B) set(C, D) set(D, B)\n    ==> set(A, B, C, D)\nset(H, I, K) set(A, B) set(C, D) set(D, B) set(F, G, H)\n    ==> set(A, B, C, D) set(H, I, K, F, G)\n```"}]}
{"messages": [{"role": "user", "content": "Set Puzzles are created with a deck of cards from the Set Game™. The object of the puzzle is to find sets of 3 cards in a rectangle of cards that have been dealt face up.   \n  \nThere are 81 cards in a deck.\nEach card contains a unique variation of the following four features: *color, symbol, number and shading*.\n\n* there are three colors:  \n      *red, green, purple*\n\n* there are three symbols:  \n      *oval, squiggle, diamond*\n\n* there is a number of symbols on the card:  \n      *one, two, three*\n\n* there are three shadings:  \n      *solid, open, striped*\n\nThree cards form a *set* if each feature is either the same on each card, or is different on each card. For instance: all 3 cards are red, all 3 cards have a different symbol, all 3 cards have a different number of symbols, all 3 cards are striped.\n\nThere are two degrees of difficulty: basic and advanced. The basic mode deals 9 cards, that contain exactly 4 sets; the advanced mode deals 12 cards that contain exactly 6 sets.\n\nWhen creating sets you may use the same card more than once.\n\nTask\n\nWrite code that deals the cards (9 or 12, depending on selected mode) from a shuffled deck in which the total number of sets that could be found is 4 (or 6, respectively); and print the contents of the cards and the sets.\n\nFor instance:\n\n**DEALT 9 CARDS:**\n\n:   green, one, oval, striped\n\n:   green, one, diamond, open\n\n:   green, one, diamond, striped\n\n:   green, one, diamond, solid\n\n:   purple, one, diamond, open\n\n:   purple, two, squiggle, open\n\n:   purple, three, oval, open\n\n:   red, three, oval, open\n\n:   red, three, diamond, solid\n\n**CONTAINING 4 SETS:**\n\n:   green, one, oval, striped\n\n:   purple, two, squiggle, open\n\n:   red, three, diamond, solid\n\n:   green, one, diamond, open\n\n:   green, one, diamond, striped\n\n:   green, one, diamond, solid\n\n:   green, one, diamond, open\n\n:   purple, two, squiggle, open\n\n:   red, three, oval, open\n\n:   purple, one, diamond, open\n\n:   purple, two, squiggle, open\n\n:   purple, three, oval, open"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe trick here is to allocate three different bits for each enum, with the result that the cards of a matching set OR together to produce a 4-digit octal number that contains only the digits 1, 2, 4, or 7. This OR is done by funny looking [+|], which is the reduction form of +|, which is the numeric bitwise OR. (Because Raku stole the bare | operator for composing junctions instead.)\n\n```\nenum Color (red => 0o1000, green =>  0o2000, purple => 0o4000);\nenum Count (one =>  0o100, two =>     0o200, three =>   0o400);\nenum Shape (oval =>  0o10, squiggle => 0o20, diamond =>  0o40);\nenum Style (solid =>  0o1, open =>      0o2, striped =>   0o4);\n \nmy @deck = Color.enums X Count.enums X Shape.enums X Style.enums;\n \nsub MAIN($DRAW = 9, $GOAL = $DRAW div 2) {\n    sub show-cards(@c) { { printf \"%9s%7s%10s%9s\\n\", @c[$_;*]».key } for ^@c }\n\n    my @combinations = [^$DRAW].combinations(3);\n\n    my @draw;\n    repeat until (my @sets) == $GOAL {\n        @draw = @deck.pick($DRAW);\n        my @bits = @draw.map: { [+] @^enums».value }\n        @sets = gather for @combinations -> @c {\n            take @draw[@c].item when /^ <[1247]>+ $/ given ( [+|] @bits[@c] ).base(8);\n        }\n    }\n\n    say \"Drew $DRAW cards:\";\n    show-cards @draw;\n    for @sets.kv -> $i, @cards {\n        say \"\\nSet {$i+1}:\";\n        show-cards @cards;\n    }\n}\n\n```\n\nOutput:\n\n```\nDrew 9 cards:\n   purple    two   diamond     open\n      red    two  squiggle  striped\n   purple  three  squiggle     open\n   purple    two  squiggle  striped\n      red  three      oval  striped\n      red    one   diamond  striped\n   purple    two      oval    solid\n    green  three   diamond    solid\n      red    two  squiggle     open\n\nSet 1:\n   purple    two   diamond     open\n   purple    two  squiggle  striped\n   purple    two      oval    solid\n\nSet 2:\n   purple    two   diamond     open\n      red    one   diamond  striped\n    green  three   diamond    solid\n\nSet 3:\n      red    two  squiggle  striped\n      red  three      oval  striped\n      red    one   diamond  striped\n\nSet 4:\n   purple  three  squiggle     open\n      red  three      oval  striped\n    green  three   diamond    solid\n```"}]}
{"messages": [{"role": "user", "content": "Given a left-to-right ordered collection of `e` bits, `b`, where `1 <= e <= 10000`,\nand a zero or more integer `n` :\n\n* Output the result of setting the `n` bits to the right of any set bit in `b`\n\n(if those bits are present in b and therefore also preserving the width, `e`).\n\n**Some examples:**\n\n```\n   Set of examples showing how one bit in a nibble gets changed:\n       \n       n = 2; Width e = 4:\n       \n            Input b: 1000\n             Result: 1110\n       \n            Input b: 0100\n             Result: 0111\n       \n            Input b: 0010\n             Result: 0011\n       \n            Input b: 0000\n             Result: 0000\n   \n   Set of examples with the same input with set bits of varying distance apart:\n   \n       n = 0; Width e = 66:\n       \n            Input b: 010000000000100000000010000000010000000100000010000010000100010010\n             Result: 010000000000100000000010000000010000000100000010000010000100010010\n       \n       n = 1; Width e = 66:\n       \n            Input b: 010000000000100000000010000000010000000100000010000010000100010010\n             Result: 011000000000110000000011000000011000000110000011000011000110011011\n       \n       n = 2; Width e = 66:\n       \n            Input b: 010000000000100000000010000000010000000100000010000010000100010010\n             Result: 011100000000111000000011100000011100000111000011100011100111011111\n       \n       n = 3; Width e = 66:\n       \n            Input b: 010000000000100000000010000000010000000100000010000010000100010010\n             Result: 011110000000111100000011110000011110000111100011110011110111111111\n\n```\n\n**Task:**\n\n* Implement a routine to perform the setting of right-adjacent bits on representations of bits that will scale over the given range of input width `e`.\n* Use it to show, here, the results for the input examples above.\n* Print the output aligned in a way that allows easy checking by eye of the binary input vs output."}, {"role": "assistant", "content": "A left-to-right ordered collection of bits is more commonly referred to as an Integer in Raku.\n\n```\nsub rab (Int $n, Int $b = 1) {\n    my $m = $n;\n    $m +|= ($n +> $_) for ^ $b+1;\n    $m\n}\n\nsub lab (Int $n, Int $b = 1) {\n    my $m = $n;\n    $m +|= ($n +< $_) for ^ $b+1;\n    $m\n}\n\nsay \"Powers of 2 ≤ 8, 0 - Right-adjacent-bits: 2\";\n.&rab(2).base(2).fmt('%04s').say for <8 4 2 1 0>;\n\n# Test with a few integers.\nfor 8,4, 18455760086304825618,5, 5444684034376312377319904082902529876242,15 -> $integer, $bits {\n\n    say \"\\nInteger: $integer - Right-adjacent-bits: up to $bits\";\n\n    .say for ^$bits .map: -> $b { $integer.&rab($b).base: 2 };\n\n    say \"\\nInteger: $integer - Left-adjacent-bits: up to $bits\";\n\n    .say for ^$bits .map: -> $b { $integer.&lab($b).fmt(\"%{0~$bits+$integer.msb}b\") };\n\n}\n\n```\n\nOutput:\n\n```\nPowers of 2 ≤ 8, 0 - Right-adjacent-bits: 2\n1110\n0111\n0011\n0001\n0000\n\nInteger: 8 - Right-adjacent-bits: up to 4\n1000\n1100\n1110\n1111\n\nInteger: 8 - Left-adjacent-bits: up to 4\n0001000\n0011000\n0111000\n1111000\n\nInteger: 18455760086304825618 - Right-adjacent-bits: up to 5\n10000000000100000000010000000010000000100000010000010000100010010\n11000000000110000000011000000011000000110000011000011000110011011\n11100000000111000000011100000011100000111000011100011100111011111\n11110000000111100000011110000011110000111100011110011110111111111\n11111000000111110000011111000011111000111110011111011111111111111\n\nInteger: 18455760086304825618 - Left-adjacent-bits: up to 5\n000010000000000100000000010000000010000000100000010000010000100010010\n000110000000001100000000110000000110000001100000110000110001100110110\n001110000000011100000001110000001110000011100001110001110011101111110\n011110000000111100000011110000011110000111100011110011110111111111110\n111110000001111100000111110000111110001111100111110111111111111111110\n\nInteger: 5444684034376312377319904082902529876242 - Right-adjacent-bits: up to 15\n1000000000000001000000000000010000000000000100000000000010000000000010000000000100000000010000000010000000100000010000010000100010010\n1100000000000001100000000000011000000000000110000000000011000000000011000000000110000000011000000011000000110000011000011000110011011\n1110000000000001110000000000011100000000000111000000000011100000000011100000000111000000011100000011100000111000011100011100111011111\n1111000000000001111000000000011110000000000111100000000011110000000011110000000111100000011110000011110000111100011110011110111111111\n1111100000000001111100000000011111000000000111110000000011111000000011111000000111110000011111000011111000111110011111011111111111111\n1111110000000001111110000000011111100000000111111000000011111100000011111100000111111000011111100011111100111111011111111111111111111\n1111111000000001111111000000011111110000000111111100000011111110000011111110000111111100011111110011111110111111111111111111111111111\n1111111100000001111111100000011111111000000111111110000011111111000011111111000111111110011111111011111111111111111111111111111111111\n1111111110000001111111110000011111111100000111111111000011111111100011111111100111111111011111111111111111111111111111111111111111111\n1111111111000001111111111000011111111110000111111111100011111111110011111111110111111111111111111111111111111111111111111111111111111\n1111111111100001111111111100011111111111000111111111110011111111111011111111111111111111111111111111111111111111111111111111111111111\n1111111111110001111111111110011111111111100111111111111011111111111111111111111111111111111111111111111111111111111111111111111111111\n1111111111111001111111111111011111111111110111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111\n1111111111111101111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111\n1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111\n\nInteger: 5444684034376312377319904082902529876242 - Left-adjacent-bits: up to 15\n000000000000001000000000000001000000000000010000000000000100000000000010000000000010000000000100000000010000000010000000100000010000010000100010010\n000000000000011000000000000011000000000000110000000000001100000000000110000000000110000000001100000000110000000110000001100000110000110001100110110\n000000000000111000000000000111000000000001110000000000011100000000001110000000001110000000011100000001110000001110000011100001110001110011101111110\n000000000001111000000000001111000000000011110000000000111100000000011110000000011110000000111100000011110000011110000111100011110011110111111111110\n000000000011111000000000011111000000000111110000000001111100000000111110000000111110000001111100000111110000111110001111100111110111111111111111110\n000000000111111000000000111111000000001111110000000011111100000001111110000001111110000011111100001111110001111110011111101111111111111111111111110\n000000001111111000000001111111000000011111110000000111111100000011111110000011111110000111111100011111110011111110111111111111111111111111111111110\n000000011111111000000011111111000000111111110000001111111100000111111110000111111110001111111100111111110111111111111111111111111111111111111111110\n000000111111111000000111111111000001111111110000011111111100001111111110001111111110011111111101111111111111111111111111111111111111111111111111110\n000001111111111000001111111111000011111111110000111111111100011111111110011111111110111111111111111111111111111111111111111111111111111111111111110\n000011111111111000011111111111000111111111110001111111111100111111111110111111111111111111111111111111111111111111111111111111111111111111111111110\n000111111111111000111111111111001111111111110011111111111101111111111111111111111111111111111111111111111111111111111111111111111111111111111111110\n001111111111111001111111111111011111111111110111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110\n011111111111111011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110\n111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Sexy\\_prime. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn mathematics, **sexy primes** are prime numbers that differ from each other by six.\n\nFor example, the numbers **5** and **11** are both sexy primes, because **11** minus **6** is **5**.\n\nThe term \"sexy prime\" is a pun stemming from the Latin word for six: *sex*.\n\n**Sexy prime pairs:** Sexy prime pairs are groups of two primes that differ by **6**. e.g. **(5 11), (7 13), (11 17)**  \nSee sequences: OEIS:A023201 and OEIS:A046117\n\n**Sexy prime triplets:** Sexy prime triplets are groups of three primes where each differs from the next by **6**. e.g. **(5 11 17), (7 13 19), (17 23 29)**  \nSee sequences: OEIS:A046118, OEIS:A046119 and OEIS:A046120\n\n**Sexy prime quadruplets:** Sexy prime quadruplets are groups of four primes where each differs from the next by **6**. e.g. **(5 11 17 23), (11 17 23 29)**  \nSee sequences: OEIS:A023271, OEIS:A046122, OEIS:A046123 and OEIS:A046124\n\n**Sexy prime quintuplets:** Sexy prime quintuplets are groups of five primes with a common difference of **6**. One of the terms must be divisible by **5**, because **5** and **6** are relatively prime. Thus, the only possible sexy prime quintuplet is **(5 11 17 23 29)**\n\nTask\n\n:   :   * For each of pairs, triplets, quadruplets and quintuplets, Find and display the count of each group type of sexy primes less than one million thirty-five (**1,000,035**).\n        * Display at most the **last** **5**, less than one million thirty-five, of each sexy prime group type.\n        * Find and display the count of the unsexy primes less than one million thirty-five.\n        * Find and display the **last 10** unsexy primes less than one million thirty-five.\n        * Note that 1000033 **SHOULD NOT** be counted in the pair count. It is sexy, but not in a pair within the limit. However, it also **SHOULD NOT** be listed in the unsexy primes since it is sexy."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.08\n\n```\nuse Math::Primesieve;\nmy $sieve = Math::Primesieve.new;\n\nmy $max = 1_000_035;\nmy @primes = $sieve.primes($max);\n\nmy $filter = @primes.Set;\nmy $primes = @primes.categorize: &sexy;\n\nsay \"Total primes less than {comma $max}: \", comma +@primes;\n\nfor <pair 2 triplet 3 quadruplet 4 quintuplet 5> -> $sexy, $cnt {\n    say \"Number of sexy prime {$sexy}s less than {comma $max}: \", comma +$primes{$sexy};\n    say \"   Last 5 sexy prime {$sexy}s less than {comma $max}: \",\n      join ' ', $primes{$sexy}.tail(5).grep(*.defined).map:\n      { \"({ $_ «+« (0,6 … 24)[^$cnt] })\" }\n    say '';\n}\n\nsay \"Number of unsexy primes less than {comma $max}: \", comma +$primes<unsexy>;\nsay \"  Last 10 unsexy primes less than {comma $max}: \", $primes<unsexy>.tail(10);\n\nsub sexy ($i) {\n    gather {\n        take 'quintuplet' if all($filter{$i «+« (6,12,18,24)});\n        take 'quadruplet' if all($filter{$i «+« (6,12,18)});\n        take 'triplet'    if all($filter{$i «+« (6,12)});\n        take 'pair'       if $filter{$i + 6};\n        take (($i >= $max - 6) && ($i + 6).is-prime) ||\n          (so any($filter{$i «+« (6, -6)})) ?? 'sexy' !! 'unsexy';\n    }\n}\n\nsub comma { $^i.flip.comb(3).join(',').flip }\n\n```\n\nOutput:\n\n```\nTotal primes less than 1,000,035: 78,500\nNumber of sexy prime pairs less than 1,000,035: 16,386\n   Last 5 sexy prime pairs less than 1,000,035: (999371 999377) (999431 999437) (999721 999727) (999763 999769) (999953 999959)\n\nNumber of sexy prime triplets less than 1,000,035: 2,900\n   Last 5 sexy prime triplets less than 1,000,035: (997427 997433 997439) (997541 997547 997553) (998071 998077 998083) (998617 998623 998629) (998737 998743 998749)\n\nNumber of sexy prime quadruplets less than 1,000,035: 325\n   Last 5 sexy prime quadruplets less than 1,000,035: (977351 977357 977363 977369) (983771 983777 983783 983789) (986131 986137 986143 986149) (990371 990377 990383 990389) (997091 997097 997103 997109)\n\nNumber of sexy prime quintuplets less than 1,000,035: 1\n   Last 5 sexy prime quintuplets less than 1,000,035: (5 11 17 23 29)\n\nNumber of unsexy primes less than 1,000,035: 48,627\n  Last 10 unsexy primes less than 1,000,035: (999853 999863 999883 999907 999917 999931 999961 999979 999983 1000003)\n```"}]}
{"messages": [{"role": "user", "content": "**SHA-1** or **SHA1** is a one-way hash function;\nit computes a 160-bit message digest.\nSHA-1 often appears in security protocols; for example,\nmany HTTPS websites use RSA with SHA-1 to secure their connections.\nBitTorrent uses SHA-1 to verify downloads.\nGit and Mercurial use SHA-1 digests to identify commits.\n\nA US government standard, FIPS 180-1, defines SHA-1.\n\nFind the SHA-1 message digest for a string of octets. You may either call a SHA-1 library, or implement SHA-1 in your language. Both approaches interest Rosetta Code.\n\n|  |\n| --- |\n| **Warning:** SHA-1 has known weaknesses. Theoretical attacks may find a collision after 252 operations, or perhaps fewer. This is much faster than a brute force attack of 280 operations. USgovernment deprecated SHA-1. For production-grade cryptography, users may consider a stronger alternative, such as SHA-256 (from the SHA-2 family) or the upcoming SHA-3. |"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Pure Raku\n\nA pure Raku implementation that closely follows the description of SHA-1 in FIPS 180-1. Slow.\n\n```\nsub postfix:<mod2³²> { $^x % 2**32 }\nsub infix:<⊕>        { ($^x + $^y)mod2³² }\nsub S                { ($^x +< $^n)mod2³² +| ($x +> (32-$n)) }\n\nmy \\f = -> \\B,\\C,\\D { (B +& C) +| ((+^B)mod2³² +& D)   },\n        -> \\B,\\C,\\D { B +^ C +^ D                      },\n        -> \\B,\\C,\\D { (B +& C) +| (B +& D) +| (C +& D) },\n        -> \\B,\\C,\\D { B +^ C +^ D                      };\n\nmy \\K = 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6;\n\nsub sha1-pad(Blob $msg)\n{   \n    my \\bits = 8 * $msg.elems;\n    my @padded = flat $msg.list, 0x80, 0x00 xx (-($msg.elems + 1 + 8) % 64);\n    flat @padded.map({ :256[$^a,$^b,$^c,$^d] }), (bits +> 32)mod2³², (bits)mod2³²;\n}\n\nsub sha1-block(@H, @M is copy)\n{   \n    @M.push: S(1, [+^] @M[$_ «-« <3 8 14 16>] ) for 16 .. 79;\n\n    my ($A,$B,$C,$D,$E) = @H;\n    for 0..79 -> \\t {\n        ($A, $B, $C, $D, $E) =\n        S(5,$A) ⊕ f[t div 20]($B,$C,$D) ⊕ $E ⊕ @M[t] ⊕ K[t div 20],\n        $A, S(30,$B), $C, $D;\n    }\n    @H »⊕=« ($A,$B,$C,$D,$E);\n}\n\nsub sha1(Blob $msg) returns Blob\n{   \n    my @M = sha1-pad($msg);\n    my @H = 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0;\n    sha1-block(@H,@M[$_..$_+15]) for 0, 16...^ +@M;\n    Blob.new: flat map { reverse .polymod(256 xx 3) }, @H;\n}\n\nsay sha1(.encode('ascii')), \"  $_\"\n   for 'abc',\n       'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',\n       'Rosetta Code',\n       'Ars longa, vita brevis';\n\n```\n\nOutput:\n\n```\nBuf:0x<a9 99 3e 36 47 06 81 6a ba 3e 25 71 78 50 c2 6c 9c d0 d8 9d>  abc\nBuf:0x<84 98 3e 44 1c 3b d2 6e ba ae 4a a1 f9 51 29 e5 e5 46 70 f1>  abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\nBuf:0x<48 c9 8f 7e 5a 6e 73 6d 79 0a b7 40 df c3 f5 1a 61 ab e2 b5>  Rosetta Code\nBuf:0x<e6 40 d2 85 24 28 86 eb 96 ab 80 cb f8 58 38 9b 3d f5 2f 43>  Ars longa, vita brevis\n```\n\n### Library based implementation\n\nQuite speedy.\n\n```\nuse Digest::SHA1::Native;\n\n# use sha1-hex() if you want a hex string\n\nsay sha1($_), \"  $_\" for\n  'abc',\n  'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',\n  'Rosetta Code',\n  'Ars longa, vita brevis'\n;\n\n```\n\nOutput:\n\n```\nBlob:0x<A9 99 3E 36 47 06 81 6A BA 3E 25 71 78 50 C2 6C 9C D0 D8 9D>  abc\nBlob:0x<84 98 3E 44 1C 3B D2 6E BA AE 4A A1 F9 51 29 E5 E5 46 70 F1>  abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\nBlob:0x<48 C9 8F 7E 5A 6E 73 6D 79 0A B7 40 DF C3 F5 1A 61 AB E2 B5>  Rosetta Code\nBlob:0x<E6 40 D2 85 24 28 86 EB 96 AB 80 CB F8 58 38 9B 3D F5 2F 43>  Ars longa, vita brevis\n```"}]}
{"messages": [{"role": "user", "content": "**SHA-256** is the recommended stronger alternative to SHA-1. See FIPS PUB 180-4 for implementation details.\n\nEither by using a dedicated library or implementing the algorithm in your language, show that the SHA-256 digest of the string \"Rosetta code\" is: 764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Pure Raku\n\nThe following implementation takes all data as input. Ideally, input should be given lazily or something.\n\n```\nsay sha256 \"Rosetta code\";\n\nour proto sha256($) returns blob8 {*}\n\nmulti sha256(Str $str) { samewith $str.encode }\nmulti sha256(blob8 $data) {\n  sub rotr { $^a +> $^b +| $a +< (32 - $b) }\n  sub init { ^Inf .grep(&is-prime).map: { (($_ - .Int)*2**32).Int } o &^f } \n  sub   Ch { $^x +& $^y +^ +^$x +& $^z }\n  sub  Maj { $^x +& $^y +^ $x +& $^z +^ $y +& $z }\n  sub   Σ0 { rotr($^x,  2) +^ rotr($x, 13) +^ rotr($x, 22) }\n  sub   Σ1 { rotr($^x,  6) +^ rotr($x, 11) +^ rotr($x, 25) }\n  sub   σ0 { rotr($^x,  7) +^ rotr($x, 18) +^ $x +>  3 }\n  sub   σ1 { rotr($^x, 17) +^ rotr($x, 19) +^ $x +> 10 }\n\n  return blob8.new: \n    map |*.polymod(256 xx 3).reverse,\n\t|reduce -> $H, $block {\n\t  blob32.new: $H[] Z+\n\t    reduce -> $h, $j {\n\t      my uint32 ($T1, $T2) =\n\t\t$h[7] + Σ1($h[4]) + Ch(|$h[4..6])\n\t\t+ (BEGIN init(* **(1/3))[^64])[$j] +\n\t\t(\n\t\t (state buf32 $w .= new)[$j] = $j < 16 ?? $block[$j] !!\n\t\t σ0($w[$j-15]) + $w[$j-7] + σ1($w[$j-2]) + $w[$j-16]\n\t\t),\n\t      Σ0($h[0]) + Maj(|$h[0..2]);\n\t      blob32.new: $T1 + $T2, |$h[0..2], $h[3] + $T1, |$h[4..6];\n\t    }, $H, |^64;\n\t},\n\t(BEGIN init(&sqrt)[^8]),\n\t|blob32.new(\n\t    blob8.new(\n\t      @$data,\n\t      0x80,\n\t      0 xx (-($data + 1 + 8) mod 64),\n\t      (8*$data).polymod(256 xx 7).reverse\n\t      ).rotor(4)\n\t    .map: { :256[@$_] }\n\t  ).rotor(16)\n}\n\n```\n\nOutput:\n\n```\nBlob[uint8]:0x<76 4F AF 5C 61 AC 31 5F 14 97 F9 DF A5 42 71 39 65 B7 85 E5 CC 2F 70 7D 64 68 D7 D1 12 4C DF CF>\n```\n\n### Native implementation\n\n```\nuse Digest::SHA256::Native;\n\n# If you want a string\nsay sha256-hex 'Rosetta code';\n\n# If you want a binary Blob\nsay sha256 'Rosetta code';\n\n```\n\nOutput:\n\n```\n764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf\nBlob:0x<76 4F AF 5C 61 AC 31 5F 14 97 F9 DF A5 42 71 39 65 B7 85 E5 CC 2F 70 7D 64 68 D7 D1 12 4C DF CF>\n```"}]}
{"messages": [{"role": "user", "content": "As described in its documentation, Amazon S3 Glacier requires that all uploaded files come with a checksum computed as a Merkle Tree using SHA-256.\n\nSpecifically, the SHA-256 hash is computed for each 1MiB block of the file. And then, starting from the beginning of the file, the raw hashes of consecutive blocks are paired up and concatenated together, and a new hash is computed from each concatenation. Then these are paired up and concatenated and hashed, and the process continues until there is only one hash left, which is the final checksum. The hexadecimal representation of this checksum is the value that must be included with the AWS API call to upload the object (or complete a multipart upload).\n\nImplement this algorithm in your language; you can use the code from the SHA-256 task for the actual hash computations. For better manageability and portability, build the tree using a smaller block size of only 1024 bytes, and demonstrate it on the RosettaCode title image with that block size. The final result should be the hexadecimal digest value a4f902cf9d51fe51eda156a6792e1445dff65edf3a217a1f3334cc9cf1495c2c."}, {"role": "assistant", "content": "```\nuse Digest::SHA256::Native;\n\nunit sub MAIN(Int :b(:$block-size) = 1024 × 1024, *@args);\n\nmy $in = @args ?? IO::CatHandle.new(@args) !! $*IN;\n\nmy @blocks = do while my $block = $in.read: $block-size { sha256 $block };\n\nwhile @blocks > 1 {\n  @blocks = @blocks.batch(2).map: { $_ > 1 ?? sha256([~] $_) !! .[0] }\n}\n\nsay @blocks[0]».fmt('%02x').join;\n\n```\n\nOutput:\n\n```\n$ sha256tree --block-size=1024 title.png\na4f902cf9d51fe51eda156a6792e1445dff65edf3a217a1f3334cc9cf1495c2c\n```"}]}
{"messages": [{"role": "user", "content": "**Task**:\n\nGet user input (or store the number somewhere if the programing langauge doesn't support input) and then add 3, multiply that 0.86 and repeat that over and over again.\n\nOptionally, halt the loop when quiescence has been achieved, i.e. when the value does not change, and report that value and the corresponding number of iterations.\n\n## See Also\n\n* Esolangs.org page"}, {"role": "assistant", "content": "```\nmy $input = (+prompt()).FatRat;\nmy $previous = 0.FatRat;\nmy $count;\nmy $places = 36;\nloop {\n    $input += 3;\n    $input ×= .86;\n    last if $previous.substr(0,$places) eq $input.substr(0,$places);\n    ++$count;\n    say ($previous = $input).substr(0,$places);\n}\nsay \"$count repetitions\";\n\n```\n\nOutput with a 4 fed in at the prompt:\n\n```\n4\n6.02\n7.7572\n9.251192\n10.53602512\n11.6409816032\n12.591244178752\n13.40846999372672\n14.1112841946049792\n14.715704407360282112\n15.23550579032984261632\n15.6825349796836646500352\n16.066980082527951599030272\n\n...\nmany, many lines omitted\n...\n\n18.428571428571428571428571428571416\n18.428571428571428571428571428571418\n18.428571428571428571428571428571419\n18.428571428571428571428571428571420\n18.428571428571428571428571428571421\n18.428571428571428571428571428571422\n18.428571428571428571428571428571423\n18.428571428571428571428571428571424\n512 repetitions\n\n```\n\nIn the latest iteration of the task instructions, we are to optionally \"halt the loop when quiescence has been achieved, i.e. when the value does not change\". Unless a precision is specified, \"quiescence\" will never be achieved. This operation adds more places of precision with every iteration, and will never \"quiesce\". (Unless run on a processor or with a language that is unable to handle high precision.)\n\nFor instance, the 1000th iteration, starting with 4 is exactly equal to:\n\n```\nsay (4.FatRat, (* + 3) × .86 … *)[999]\n\n```\n\nOutput:\n\n```\n18.428571428571428571428571428571428571428571428571428571428571428518562611055257476711345657046077536086307719590805662205008932637290716748623508143778473712167435511145273975385354947408188479662139937380449451942842937179508680530588633892945763008511616379084707917069957275072200539351914273993965066030011194811876547904839025263224744832595386782011862097471389181893672211696726485532183264057134602403929706908123592993235863786859888156665186026179826816128847575831458378844885123366878611593252686593421606487555134444315938261367778063531536534964127098858136548553001526656285822374662510184388742700972850063038414950295895060044238800011827580857336812976758443609296077801146559738910594736606435132635929690920618270821813108173656217015589361779205162675360527035288967300528197729261443766412283716792164777168702168039406788952779919915570541752416260293860518467707548712088056167502132216420672641269104901942501949966581723902330182247134406759443834453985391637796764689461663270662662993088449741102622767088092813554110022083926515230853581817905105492221230813528825959115645642043759816744064849863722778041272156387348996418369338438534662612609987037043047038131221189442288876209762806085696386445408093086328602555139121446610496274119187899056474561873403444794760343168250250584159942711177776533259811971409762989699214055857046134462937025863660124732727323402691866232023863821613479844954718192492032583994808226027774091320595373377362720291094591511865887665392365641680216202349251077081257991823441611723818589067580880018475492672710607080810164651535155593521646027992098574736200877274039486002214250862949227962977243520217727369412523884625435318388719886\n```\n\n(Notice that that, while very **precise**, is only **accurate** to 64 decimal places.)"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow how to specify and execute a short program in the language from a command shell, where the input to the command shell is only one line in length.\n\nAvoid depending on the particular shell or operating system used as much as is reasonable; if the language has notable implementations which have different command argument syntax, or the systems those implementations run on have different styles of shells, it would be good to show multiple examples."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #22 \"Thousand Oaks\"\n\n```\n$ raku -e 'say \"Hello, world!\"'\nHello, world!\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShift list elements to left by   **3**.\n\n```\n      shift  = [1,2,3,4,5,6,7,8,9]\n      result = [4, 5, 6, 7, 8, 9, 1, 2, 3]\n\n```"}, {"role": "assistant", "content": "```\n# 20210315 Raku programming solution\n\nsay [1..9].rotate(3)\n\n```\n\nOutput:\n\n```\n(4 5 6 7 8 9 1 2 3)\n\n```"}]}
{"messages": [{"role": "user", "content": "Given the `n + 1` vertices `x[0], y[0] .. x[N], y[N]` of a simple polygon described in a clockwise direction, then the polygon's area can be calculated by:\n\n```\nabs( (sum(x[0]*y[1] + ... x[n-1]*y[n]) + x[N]*y[0]) -\n     (sum(x[1]*y[0] + ... x[n]*y[n-1]) + x[0]*y[N])\n   ) / 2\n```\n\n(Where `abs` returns the absolute value)\n\nTask\n\nWrite a function/method/routine to use the the Shoelace formula to calculate the area of the polygon described by the ordered points:\n\n```\n     (3,4), (5,11), (12,8), (9,5), and (5,6) \n\n```\n\nShow the answer here, on this page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Index and mod offset\n\n**Works with**: Rakudo version 2017.07\n\n```\nsub area-by-shoelace(@p) {\n    (^@p).map({@p[$_;0] * @p[($_+1)%@p;1] - @p[$_;1] * @p[($_+1)%@p;0]}).sum.abs / 2\n}\n\nsay area-by-shoelace( [ (3,4), (5,11), (12,8), (9,5), (5,6) ] );\n\n```\n\nOutput:\n\n```\n30\n```\n\n### Slice and rotation\n\n**Works with**: Rakudo version 2017.07\n\n```\nsub area-by-shoelace ( @p ) {\n    my @x := @p».[0];\n    my @y := @p».[1];\n\n    my $s := ( @x Z* @y.rotate( 1) ).sum\n           - ( @x Z* @y.rotate(-1) ).sum;\n\n    return $s.abs / 2;\n}\n\nsay area-by-shoelace( [ (3,4), (5,11), (12,8), (9,5), (5,6) ] );\n\n```\n\nOutput:\n\n```\n30\n```"}]}
{"messages": [{"role": "user", "content": "Assume functions   `a`   and   `b`   return boolean values,   and further, the execution of function   `b`   takes considerable resources without side effects, and is to be minimized.\n\nIf we needed to compute the conjunction   (`and`):\n\n:   :   :   :   `x = a() and b()`\n\nThen it would be best to not compute the value of   `b()`   if the value of   `a()`   is computed as   `false`,   as the value of   `x`   can then only ever be    `false`.\n\nSimilarly, if we needed to compute the disjunction (`or`):\n\n:   :   :   :   `y = a() or b()`\n\nThen it would be best to not compute the value of   `b()`   if the value of   `a()`   is computed as   `true`,   as the value of   `y`   can then only ever be   `true`.\n\nSome languages will stop further computation of boolean equations as soon as the result is known, so-called   short-circuit evaluation   of boolean expressions\n\nTask\n\nCreate two functions named   `a`   and   `b`,   that take and return the same boolean value.\n\nThe functions should also print their name whenever they are called.\n\nCalculate and assign the values of the following equations to a variable in such a way that function   `b`   is only called when necessary:\n\n:   :   :   :   `x = a(i) and b(j)`\n            :   `y = a(i) or b(j)`\n\nIf the language does not have short-circuit evaluation, this might be achieved with nested     **if**     statements."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n```\nuse MONKEY-SEE-NO-EVAL;\n\nsub a ($p) { print 'a'; $p }\nsub b ($p) { print 'b'; $p }\n\nfor 1, 0 X 1, 0 -> ($p, $q) {\n    for '&&', '||' -> $op {\n        my $s = \"a($p) $op b($q)\";\n        print \"$s: \";\n        EVAL $s;\n        print \"\\n\";\n    }\n}\n\n```\n\nOutput:\n\n```\na(1) && b(1): ab\na(1) || b(1): a\na(1) && b(0): ab\na(1) || b(0): a\na(0) && b(1): a\na(0) || b(1): ab\na(0) && b(0): a\na(0) || b(0): ab\n```"}]}
{"messages": [{"role": "user", "content": "The   **shortest common supersequence**   is a problem closely related to the   longest common subsequence,   which you can use as an external function for this task.\n\nTask\n\nGiven two strings \n\nu\n{\\displaystyle {\\displaystyle u}}\n and \n\nv\n{\\displaystyle {\\displaystyle v}}\n, find the shortest possible sequence \n\ns\n{\\displaystyle {\\displaystyle s}}\n, which is the shortest common super-sequence of \n\nu\n{\\displaystyle {\\displaystyle u}}\n and \n\nv\n{\\displaystyle {\\displaystyle v}}\n where both \n\nu\n{\\displaystyle {\\displaystyle u}}\n and \n\nv\n{\\displaystyle {\\displaystyle v}}\n are a subsequence of \n\ns\n{\\displaystyle {\\displaystyle s}}\n. Defined as such, \n\ns\n{\\displaystyle {\\displaystyle s}}\n is not necessarily unique.\n\nDemonstrate this by printing \n\ns\n{\\displaystyle {\\displaystyle s}}\n where \n\nu\n=\n{\\displaystyle {\\displaystyle u=}}\n“abcbdab” and \n\nv\n=\n{\\displaystyle {\\displaystyle v=}}\n“bdcaba”.\n\nAlso see\n\n* Wikipedia: shortest common supersequence"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUsing 'lcs' routine from Longest common subsequence task\n\n```\nsub lcs(Str $xstr, Str $ystr) { # longest common subsequence\n    return \"\" unless $xstr && $ystr;\n    my ($x, $xs, $y, $ys) = $xstr.substr(0, 1), $xstr.substr(1), $ystr.substr(0, 1), $ystr.substr(1);\n    return $x eq $y\n        ?? $x ~ lcs($xs, $ys)\n        !! max(:by{ $^a.chars }, lcs($xstr, $ys), lcs($xs, $ystr) );\n}\n\nsub scs ($u, $v) { # shortest common supersequence\n    my @lcs = (lcs $u, $v).comb;\n    my $pat = '(.*)' ~ join('(.*)',@lcs) ~ '(.*)';\n    my $regex = \"rx/$pat/\".EVAL;\n    my @u = ($u ~~ $regex).list;\n    my @v = ($v ~~ $regex).list;\n    my $scs = shift(@u) ~ shift(@v);\n    $scs ~= $_ ~ shift(@u) ~ shift(@v) for @lcs;\n    return $scs;\n}\n\nmy $u = 'abcbdab';\nmy $v = 'bdcaba';\nprintf \"Strings: %s %s\\n\", $u, $v;\nprintf \"Longest common subsequence:   %s\\n\", lcs $u, $v;\nprintf \"Shortest common supersquence: %s\\n\", scs $u, $v;\n\n```\n\nOutput:\n\n```\nStrings: abcbdab bdcaba\nLongest common subsequence:   bcba\nShortest common supersquence: abdcabdab\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow  the ASCII character set  from values   **32**   to   **127**   (decimal)   in a table format.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nAlternately, and perhaps more usefully, output as a wiki-table rather than ASCII art. Hover mouse over the glyph to get the name.\n\n```\nsub glyph ($_) {\n    when * < 33 { (0x2400 + $_).chr } # display symbol names for invisible glyphs\n    when 127    { '␡' }\n    default     { .chr }\n}\n\nsay '{|class=\"wikitable\" style=\"text-align:center;background-color:hsl(39, 90%, 95%)\"';\n\nfor (^128).rotor(16) -> @row {\n    say '|-';\n    printf(q[|%d<br>0x%02X<br><big><big title=\"%s\">%s</big></big>] ~ \"\\n\",\n      $_, $_, .&glyph.uniname.subst('SYMBOL FOR ', ''),\n      .&glyph.subst('|', '<nowiki>|</nowiki>')) for @row;\n}\n\nsay '|}';\n\n```\n\nOutput:\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| 0 0x00 ␀ | 1 0x01 ␁ | 2 0x02 ␂ | 3 0x03 ␃ | 4 0x04 ␄ | 5 0x05 ␅ | 6 0x06 ␆ | 7 0x07 ␇ | 8 0x08 ␈ | 9 0x09 ␉ | 10 0x0A ␊ | 11 0x0B ␋ | 12 0x0C ␌ | 13 0x0D ␍ | 14 0x0E ␎ | 15 0x0F ␏ |\n| 16 0x10 ␐ | 17 0x11 ␑ | 18 0x12 ␒ | 19 0x13 ␓ | 20 0x14 ␔ | 21 0x15 ␕ | 22 0x16 ␖ | 23 0x17 ␗ | 24 0x18 ␘ | 25 0x19 ␙ | 26 0x1A ␚ | 27 0x1B ␛ | 28 0x1C ␜ | 29 0x1D ␝ | 30 0x1E ␞ | 31 0x1F ␟ |\n| 32 0x20 ␠ | 33 0x21 ! | 34 0x22 \" | 35 0x23 # | 36 0x24 $ | 37 0x25 % | 38 0x26 & | 39 0x27 ' | 40 0x28 ( | 41 0x29 ) | 42 0x2A \\* | 43 0x2B + | 44 0x2C , | 45 0x2D - | 46 0x2E . | 47 0x2F / |\n| 48 0x30 0 | 49 0x31 1 | 50 0x32 2 | 51 0x33 3 | 52 0x34 4 | 53 0x35 5 | 54 0x36 6 | 55 0x37 7 | 56 0x38 8 | 57 0x39 9 | 58 0x3A : | 59 0x3B ; | 60 0x3C < | 61 0x3D = | 62 0x3E > | 63 0x3F ? |\n| 64 0x40 @ | 65 0x41 A | 66 0x42 B | 67 0x43 C | 68 0x44 D | 69 0x45 E | 70 0x46 F | 71 0x47 G | 72 0x48 H | 73 0x49 I | 74 0x4A J | 75 0x4B K | 76 0x4C L | 77 0x4D M | 78 0x4E N | 79 0x4F O |\n| 80 0x50 P | 81 0x51 Q | 82 0x52 R | 83 0x53 S | 84 0x54 T | 85 0x55 U | 86 0x56 V | 87 0x57 W | 88 0x58 X | 89 0x59 Y | 90 0x5A Z | 91 0x5B [ | 92 0x5C \\ | 93 0x5D ] | 94 0x5E ^ | 95 0x5F \\_ |\n| 96 0x60 ` | 97 0x61 a | 98 0x62 b | 99 0x63 c | 100 0x64 d | 101 0x65 e | 102 0x66 f | 103 0x67 g | 104 0x68 h | 105 0x69 i | 106 0x6A j | 107 0x6B k | 108 0x6C l | 109 0x6D m | 110 0x6E n | 111 0x6F o |\n| 112 0x70 p | 113 0x71 q | 114 0x72 r | 115 0x73 s | 116 0x74 t | 117 0x75 u | 118 0x76 v | 119 0x77 w | 120 0x78 x | 121 0x79 y | 122 0x7A z | 123 0x7B { | 124 0x7C | | 125 0x7D } | 126 0x7E ~ | 127 0x7F ␡ |"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow here (on this page) the decimal numbers formed by:\n\n:   :   (**n**   **1'**s   appended by the digit   **3**)   and then square the result,     where    **0   <=   n   <   8**\n\nSee also\n\n* oeis:A151997"}, {"role": "assistant", "content": "In an attempt to stave of terminal ennui, Find the first 8 where a(n) is semiprime.\n\n```\nsay \"$_, {.²}\" for (^∞).map({ ( 1 x $_ ~ 3)} ).grep({ .is-prime })[^8]\n\n```\n\nOutput:\n\n```\n3, 9\n13, 169\n113, 12769\n11113, 123498769\n111111113, 12345679432098769\n11111111113, 123456790165432098769\n111111111111111111111113, 12345679012345679012346098765432098765432098769\n111111111111111111111111111111111111111111111111111111111111111111111111111111111113, 12345679012345679012345679012345679012345679012345679012345679012345679012345679012765432098765432098765432098765432098765432098765432098765432098765432098765432098769\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nChoose popular date libraries used by your language and show the   epoch   those libraries use.\n\nA demonstration is preferable   (e.g. setting the internal representation of the date to 0 ms/ns/etc.,   or another way that will still show the epoch even if it is changed behind the scenes by the implementers),   but text from (with links to) documentation is also acceptable where a demonstration is impossible/impractical.\n\nFor consistency's sake, show the date in UTC time where possible.\n\nRelated task\n\n* Date format"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsay DateTime.new(0)\n\n```\n\nOutput:\n\n```\n1970-01-01T00:00:00Z\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nProduce a graphical or ASCII-art representation of a  Sierpinski arrowhead curve  of at least order  **3**."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.02\n\n```\nuse SVG;\n\nrole Lindenmayer {\n    has %.rules;\n    method succ {\n        self.comb.map( { %!rules{$^c} // $c } ).join but Lindenmayer(%!rules)\n    }\n}\n\nmy $arrow = 'X' but Lindenmayer( { X => 'YF+XF+Y', Y => 'XF-YF-X' } );\n\n$arrow++ xx 7;\n\nmy $w = 800;\nmy $h = ($w * 3**.5 / 2).round(1);\n\nmy $scale = 6;\nmy @points = (400, 15);\nmy $dir = pi/3;\n\nfor $arrow.comb {\n    state ($x, $y) = @points[0,1];\n    state $d = $dir;\n    when 'F' { @points.append: ($x += $scale * $d.cos).round(1), ($y += $scale * $d.sin).round(1) }\n    when '+' { $d += $dir }\n    when '-' { $d -= $dir }\n    default { }\n}\n\nmy $out = './sierpinski-arrowhead-curve-perl6.svg'.IO;\n\n$out.spurt:  SVG.serialize(\n    svg => [\n        :width($w), :height($h),\n        :rect[:width<100%>, :height<100%>, :fill<black>],\n        :polyline[ :points(@points.join: ','), :fill<black>, :style<stroke:#FF4EA9> ],\n    ],\n);\n\n```\n\nSee: Sierpinski-arrowhead-curve-perl6.svg (offsite SVG image)"}]}
{"messages": [{"role": "user", "content": "Task\n\nProduce a graphical or ASCII-art representation of a Sierpinski carpet of order   **N**.\n\nFor example, the Sierpinski carpet of order   **3**   should look like this:\n\n```\n###########################\n# ## ## ## ## ## ## ## ## #\n###########################\n###   ######   ######   ###\n# #   # ## #   # ## #   # #\n###   ######   ######   ###\n###########################\n# ## ## ## ## ## ## ## ## #\n###########################\n#########         #########\n# ## ## #         # ## ## #\n#########         #########\n###   ###         ###   ###\n# #   # #         # #   # #\n###   ###         ###   ###\n#########         #########\n# ## ## #         # ## ## #\n#########         #########\n###########################\n# ## ## ## ## ## ## ## ## #\n###########################\n###   ######   ######   ###\n# #   # ## #   # ## #   # #\n###   ######   ######   ###\n###########################\n# ## ## ## ## ## ## ## ## #\n###########################\n\n```\n\nThe use of the   #   character is not rigidly required for ASCII art.\n\nThe important requirement is the placement of whitespace and non-whitespace characters.\n\nRelated task\n\n* Sierpinski triangle"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Tcl\n\n```\nsub carpet\n{\n    (['#'], -> @c {\n       [ \n        |@c.map({$_ x 3}), \n        |@c.map({ $_ ~ $_.trans('#'=>' ') ~ $_}),\n        |@c.map({$_ x 3}) \n       ]\n    } ... *).map: { .join(\"\\n\") };\n}\n\nsay carpet[3];\n\n# Same as above, structured as an array bound to a sequence, with a separate sub for clarity.\nsub weave ( @c ) {\n   [\n    |@c.map({ $_ x 3 }),\n    |@c.map({ $_ ~ .trans( '#' => ' ' ) ~ $_ }),\n    |@c.map({ $_ x 3 })\n   ]\n}\n\nmy @carpet = ( ['#'], &weave ... * ).map: { .join: \"\\n\" };\n\nsay @carpet[3];\n\n# Output of both versions matches task example.\n```"}]}
{"messages": [{"role": "user", "content": "Produce a graphical or ASCII-art representation of a Sierpinski pentagon (aka a Pentaflake) of order 5. Your code should also be able to correctly generate representations of lower orders: 1 to 4.\n\nSee also\n\n* Sierpinski pentagon"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018-10\n\n5th order pentaflake\n\n```\nconstant $sides = 5;\nconstant order  = 5;\nconstant $dim   = 250;\nconstant scaling-factor = ( 3 - 5**.5 ) / 2;\nmy @orders = ((1 - scaling-factor) * $dim) «*» scaling-factor «**» (^order);\n\nmy $fh = open('sierpinski_pentagon.svg', :w);\n\n$fh.say: qq|<svg height=\"{$dim*2}\" width=\"{$dim*2}\" style=\"fill:blue\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">|;\n\nmy @vertices = map { cis( $_ * τ / $sides ) }, ^$sides;\n\nfor 0 ..^ $sides ** order -> $i {\n   my $vector = [+] @vertices[$i.base($sides).fmt(\"%{order}d\").comb] «*» @orders;\n   $fh.say: pgon ((@orders[*-1] * (1 - scaling-factor)) «*» @vertices «+» $vector)».reals».fmt(\"%0.3f\");\n};\n\nsub pgon (@q) { qq|<polygon points=\"{@q}\" transform=\"translate({$dim},{$dim}) rotate(-18)\"/>| }\n\n$fh.say: '</svg>';\n$fh.close;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nProduce a graphical or ASCII-art representation of a Sierpinski square curve of at least order 3."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.02\n\n```\nuse SVG;\n\nrole Lindenmayer {\n    has %.rules;\n    method succ {\n        self.comb.map( { %!rules{$^c} // $c } ).join but Lindenmayer(%!rules)\n    }\n}\n\nmy $sierpinski = 'X' but Lindenmayer( { X => 'XF-F+F-XF+F+XF-F+F-X' } );\n\n$sierpinski++ xx 5;\n\nmy $dim = 600;\nmy $scale = 6;\n\nmy @points = (-80, 298);\n\nfor $sierpinski.comb {\n    state ($x, $y) = @points[0,1];\n    state $d = $scale + 0i;\n    when 'F' { @points.append: ($x += $d.re).round(1), ($y += $d.im).round(1) }\n    when /< + - >/ { $d *= \"{$_}1i\" }\n    default { }\n}\n\nmy @t = @points.tail(2).clone;\n\nmy $out = './sierpinski-square-curve-perl6.svg'.IO;\n\n$out.spurt: SVG.serialize(\n    svg => [\n        :width($dim), :height($dim),\n        :rect[:width<100%>, :height<100%>, :fill<black>],\n        :polyline[\n          :points((@points, map {(@t »+=» $_).clone}, ($scale,0), (0,$scale), (-$scale,0)).join: ','),\n          :fill<black>, :transform(\"rotate(45, 300, 300)\"), :style<stroke:#61D4FF>,\n        ],\n        :polyline[\n          :points(@points.map( -> $x,$y { $x, $dim - $y + 1 }).join: ','),\n          :fill<black>, :transform(\"rotate(45, 300, 300)\"), :style<stroke:#61D4FF>,\n        ],\n    ],\n);\n\n```\n\nSee: Sierpinski-square-curve-perl6.svg (offsite SVG image)"}]}
{"messages": [{"role": "user", "content": "Task\n\nProduce an ASCII representation of a Sierpinski triangle of order   **N**.\n\nExample\n\nThe Sierpinski triangle of order   **4**   should look like this:\n\n```\n                       *\n                      * *\n                     *   *\n                    * * * *\n                   *       *\n                  * *     * *\n                 *   *   *   *\n                * * * * * * * *\n               *               *\n              * *             * *\n             *   *           *   *\n            * * * *         * * * *\n           *       *       *       *\n          * *     * *     * *     * *\n         *   *   *   *   *   *   *   *\n        * * * * * * * * * * * * * * * *\n\n```\n\nRelated tasks\n\n* Sierpinski triangle/Graphical for graphics images of this pattern.\n* Sierpinski carpet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nsub sierpinski ($n) {\n    my @down  = '*';\n    my $space = ' ';\n    for ^$n {\n        @down = |(\"$space$_$space\" for @down), |(\"$_ $_\" for @down);\n        $space x= 2;\n    }\n    return @down;\n}\n \n.say for sierpinski 4;\n```"}]}
{"messages": [{"role": "user", "content": "Produce a graphical representation of a Sierpinski triangle of order N in any orientation.\n\nAn example of Sierpinski's triangle (order = 8) looks like this:"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis is a recursive solution. It is not really practical for more than 8 levels of recursion, but anything more than 7 is barely visible anyway.\n\n```\nmy $levels = 8;\nmy $side   = 512;\nmy $height = get_height($side);\n\nsub get_height ($side) { $side * 3.sqrt / 2 }\n\nsub triangle ( $x1, $y1, $x2, $y2, $x3, $y3, $fill?, $animate? ) {\n    my $svg;\n    $svg ~= qq{<polygon points=\"$x1,$y1 $x2,$y2 $x3,$y3\"};\n    $svg ~= qq{ style=\"fill: $fill; stroke-width: 0;\"} if $fill;\n    $svg ~= $animate\n        ?? qq{>\\n  <animate attributeType=\"CSS\" attributeName=\"opacity\"\\n  values=\"1;0;1\" keyTimes=\"0;.5;1\" dur=\"20s\" repeatCount=\"indefinite\" />\\n</polygon>}\n        !! ' />';\n    return $svg;\n}\n\nsub fractal ( $x1, $y1, $x2, $y2, $x3, $y3, $r is copy ) {\n    my $svg;\n    $svg ~= triangle( $x1, $y1, $x2, $y2, $x3, $y3 );\n    return $svg unless --$r;\n    my $side = abs($x3 - $x2) / 2;\n    my $height = get_height($side);\n    $svg ~= fractal( $x1, $y1-$height*2, $x1-$side/2, $y1-3*$height, $x1+$side/2, $y1-3*$height, $r);\n    $svg ~= fractal( $x2, $y1, $x2-$side/2, $y1-$height, $x2+$side/2, $y1-$height, $r);\n    $svg ~= fractal( $x3, $y1, $x3-$side/2, $y1-$height, $x3+$side/2, $y1-$height, $r);\n}\n\nmy $fh = open('sierpinski_triangle.svg', :w) orelse .die;\n$fh.print: qq:to/EOD/,\n<?xml version=\"1.0\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<svg width=\"100%\" height=\"100%\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">\n<defs>\n  <radialGradient id=\"basegradient\" cx=\"50%\" cy=\"65%\" r=\"50%\" fx=\"50%\" fy=\"65%\">\n    <stop offset=\"10%\" stop-color=\"#ff0\" />\n    <stop offset=\"60%\" stop-color=\"#f00\" />\n    <stop offset=\"99%\" stop-color=\"#00f\" />\n  </radialGradient>\n</defs>\nEOD\n\ntriangle( $side/2, 0, 0, $height, $side, $height, 'url(#basegradient)' ),\ntriangle( $side/2, 0, 0, $height, $side, $height, '#000', 'animate' ),\n'<g style=\"fill: #fff; stroke-width: 0;\">',\nfractal( $side/2, $height, $side*3/4, $height/2, $side/4, $height/2, $levels ),\n'</g></svg>';\n\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nThe Sieve of Eratosthenes is a simple algorithm that finds the prime numbers up to a given integer.\n\nTask\n\nImplement the   Sieve of Eratosthenes   algorithm, with the only allowed optimization that the outer loop can stop at the square root of the limit, and the inner loop may start at the square of the prime just found.\n\nThat means especially that you shouldn't optimize by using pre-computed *wheels*, i.e. don't assume you need only to cross out odd numbers (wheel based on 2), numbers equal to 1 or 5 modulo 6 (wheel based on 2 and 3), or similar wheels based on low primes.\n\nIf there's an easy way to add such a wheel based optimization, implement it as an alternative version.\n\nNote\n\n* It is important that the sieve algorithm be the actual algorithm used to find prime numbers for the task.\n\nRelated tasks\n\n* Emirp primes\n* count in factors\n* prime decomposition\n* factors of an integer\n* extensible prime generator\n* primality by trial division\n* factors of a Mersenne number\n* trial factoring of a Mersenne number\n* partition an integer X into N primes\n* sequence of primes by Trial Division"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub sieve( Int $limit ) {\n    my @is-prime = False, False, slip True xx $limit - 1;\n\n    gather for @is-prime.kv -> $number, $is-prime {\n        if $is-prime {\n            take $number;\n            loop (my $s = $number**2; $s <= $limit; $s += $number) {\n                @is-prime[$s] = False;\n            }\n        }\n    }\n}\n\n(sieve 100).join(\",\").say;\n```\n\n### A set-based approach\n\nMore or less the same as the first Python example:\n\n```\nsub eratsieve($n) {\n    # Requires n(1 - 1/(log(n-1))) storage\n    my $multiples = set();\n    gather for 2..$n -> $i {\n        unless $i (&) $multiples { # is subset\n            take $i;\n            $multiples (+)= set($i**2, *+$i ... (* > $n)); # union\n        }\n    }\n}\n\nsay flat eratsieve(100);\n```\n\nThis gives:\n\n```\n (2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97)\n\n```\n\n### Using a chain of filters\n\n|  |\n| --- |\n| This example is **incorrect**. Please fix the code and remove this message.  ***Details:*** This version uses modulo (division) testing and so is a trial division algorithm, not a sieve of Eratosthenes. |\n\n*Note: while this is \"incorrect\" by a strict interpretation of the rules, it is being left as an interesting example*\n\n```\nsub primes ( UInt $n ) {\n    gather {\n        # create an iterator from 2 to $n (inclusive)\n        my $iterator := (2..$n).iterator;\n\n        loop {\n            # If it passed all of the filters it must be prime\n            my $prime := $iterator.pull-one;\n            # unless it is actually the end of the sequence\n            last if $prime =:= IterationEnd;\n\n            take $prime; # add the prime to the `gather` sequence\n\n            # filter out the factors of the current prime\n            $iterator := Seq.new($iterator).grep(* % $prime).iterator;\n            # (2..*).grep(* % 2).grep(* % 3).grep(* % 5).grep(* % 7)…\n        }\n    }\n}\n\nput primes( 100 );\n```\n\nWhich prints\n\n```\n2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97\n\n```"}]}
{"messages": [{"role": "user", "content": "The Sieve of Pritchard is an algorithm for finding the prime numbers up to a given limit N, published in 1981. It considers many fewer composite numbers than the Sieve of Eratosthenes (and has a better asymptotic time complexity). However, unlike the latter, it cannot be modified to greatly reduce its space requirement, making it unsuitable for very large limits.\n\nConceptually, it works by building a wheel representing the repeating pattern of numbers not divisible by one of the first k primes, increasing k until the square of the k'th prime is at least N. Since wheels grow very quickly, the algorithm restricts attention to the initial portions of wheels up to N. (Small examples of the wheels constructed by the Sieve of Pritchard are used in the \"wheel-based optimizations\" mentioned in the Eratosthenes task.)\n\nFor example, the second-order wheel has circumference 6 (the product of the first two primes, 2 and 3) and is marked only at the numbers between 1 and 6 that are not multiples of 2 or 3, namely 1 and 5. As this wheel is rolled along the number line, it will pick up only numbers of the form 6k+1 or 6k+5 (that is, n where n mod 6 is in {1,5}). By the time it stops at 30 (2x3x5) it has added only 8 of the numbers between 6 and 30 as candidates for primality. Those that are multiples of 5 (only 2: 1\\*5 and 5\\*5) are obtained by multiplying the members of the second-order wheel. Removing them gives the next wheel, and so on.\n\nThis YouTube video presents the execution of the algorithm for N=150 in a format that permits single-stepping forward and backward through the run. In that implementation, the wheel is represented by a sparse global array s such that for each member w of the wheel, s[w] contains the next member of the wheel; along with a similar \"previous member\" value, this allows numbers to be removed in a constant number of operations. But the simple abstract algorithm is based on an ordered set, and there is plenty of scope for different implementations.\n\nTask\n\nWrite a program/subprogram that uses the Sieve of Pritchard algorithm to find all primes up to a specified limit. Show the result of running it with a limit of 150.\n\nRelated tasks\n\n* Sieve of Eratosthenes\n* Emirp primes\n* count in factors\n* prime decomposition\n* factors of an integer\n* extensible prime generator\n* primality by trial division\n* factors of a Mersenne number\n* trial factoring of a Mersenne number\n* partition an integer X into N primes\n* sequence of primes by Trial Division"}, {"role": "assistant", "content": "First, a direct translation of the implementation in the YouTube video:\n\n```\nunit sub MAIN($limit = 150);\n\nmy $maxS = 1;\nmy $length = 2;\nmy $p = 3;\nmy @s = ();\n\nwhile $p*$p <= $limit {\n  if $length < $limit {\n    extend-to [$p*$length, $limit].min;\n  }\n  delete-multiples-of($p);\n  $p = next(1);\n}\nif $length < $limit {\n  extend-to $limit;\n}\n\n# Done, build the list of actual primes from the array\n$p = 3;\nmy @primes = 2, |gather while $p <= $limit {\n  take $p;\n  $p = next($p);\n};\nsay @primes;\n\nexit;\n\nsub extend-to($n) {\n  my $w = 1;\n  my $x = $length + 1;\n  while $x <= $n {\n     append $x;\n     $w = next($w);\n     $x = $length + $w;\n  }\n  $length = $n;\n  if $length == $limit {\n    append $limit+2;\n  }\n}\n\nsub delete-multiples-of($p) {\n  my $f = $p;\n  while $p*$f <= $length {\n    $f = next($f);\n  }\n  while $f > 1 {\n    $f = prev($f);\n    delete($p*$f);\n  }\n}\n\nsub append($w) {\n  @s[$maxS-1] = $w;\n  @s[$w-2] = $maxS;\n  $maxS = $w;\n}\n\nsub next($w) { @s[$w-1]; }\nsub prev($w) { @s[$w-2]; }\n\nsub delete($pf) {\n  my $temp1 = @s[$pf-2];\n  my $temp2 = @s[$pf-1];\n  @s[$temp1-1] = $temp2;\n  @s[($temp2-2)%@s] = $temp1;\n}\n\n```\n\nOutput:\n\n```\n[2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149\n```\n\nThen a slightly more Raku-ish implementation based on the description in the Wikipedia article:\n\n```\nunit sub MAIN($limit = 150);\n\nclass Wheel {\n  has $.members is rw;\n  has $.length is rw;\n  method extend(*@limits) {\n    my @members = $.members.keys;\n    for @members -> $w {\n      my $n = $w + $.length;\n      while $n <= @limits.all {\n        $.members.set($n);\n        $n += $.length;\n      }\n    }\n    $.length = @limits.min;\n  }\n}\n\n# start with W₀=({1},1)\nmy $wheel = Wheel.new: :members(SetHash(1)), :length(1);\nmy $prime = 2;\nmy @primes = ();\n\nwhile $prime * $prime <= $limit {\n  if $wheel.length < $limit {\n    $wheel.extend($prime*$wheel.length, $limit);\n  }\n  for $wheel.members.keys.sort(-*) -> $w {\n    $wheel.members.unset($prime * $w);\n  }\n  @primes.push: $prime;\n  $prime = $prime == 2 ?? 3 !! $wheel.members.keys.grep(*>1).sort[0];\n}\n\nif $wheel.length < $limit {\n  $wheel.extend($limit);\n}\n@primes.append:  $wheel.members.keys.grep: * != 1;\nsay @primes.sort;\n\n```\n\nThe only difference in the output is that the result of `.sort` is a list rather than an array, so it's printed in parentheses instead of square brackets:\n\nOutput:\n\n```\n(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149)\n```"}]}
{"messages": [{"role": "user", "content": "Signum: Sign of an integer - represent the sign of an integer using a value from a set of 3 or 4 integers.\n\nTask\n\nCreate a function that takes a signed integer *x*, and returns another signed integer as follows:\n\n* if *x*<0, return -1,\n* if *x*>0, return 1 (positive 1),\n* if *x*=0, return 0.\n\nIf the integer representation used supports a signed zero, then the function should preserve the sign of the zero. That is,\n\n* if *x*=-0, return -0,\n* if *x*=+0, return +0.\n\nExample\n\n:   :   | input | output |\n        | --- | --- |\n        | -10 | -1 |\n        | 42 | 1 |\n        | 0 | 0 |\n\nAdditional example for integer types with a signed zero (uncommon)\n\n:   :   | input | output |\n        | --- | --- |\n        | -0 | -0 |"}, {"role": "assistant", "content": "Raku has IEEE 754 floating point numbers as part of it's numeric spectrum, so understands -0 as a concept, but does not make any attempt to keep negative zeros. Once a number is interpreted numerically, it is automatically \"narrowed\" to it's most compact form for display.\n\n```\nsay +($_ <=> 0), \": $_\" for 1, -5, 2⁷⁶, -7⁴⁴, π, Inf, -Inf, 0, -0;\n\n```\n\nOutput:\n\n```\n1: 1\n-1: -5\n1: 75557863725914323419136\n-1: -15286700631942576193765185769276826401\n1: 3.141592653589793\n1: Inf\n-1: -Inf\n0: 0\n0: 0\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a simple tool to track a small set of data.\n\nThe tool should have a command-line interface to enter at least two different values.\n\nThe entered data should be stored in a structured format and saved to disk.\n\nIt does not matter what kind of data is being tracked.   It could be a collection (CDs, coins, baseball cards, books), a diary, an electronic organizer (birthdays/anniversaries/phone numbers/addresses), etc.\n\nYou should track the following details:\n\n* A description of the item. (e.g., title, name)\n* A category or tag (genre, topic, relationship such as “friend” or “family”)\n* A date (either the date when the entry was made or some other date that is meaningful, like the birthday); the date may be generated or entered manually\n* Other optional fields\n\nThe command should support the following Command-line arguments to run:\n\n* Add a new entry\n* Print the latest entry\n* Print the latest entry for each category\n* Print all entries sorted by a date\n\nThe category may be realized as a tag or as structure (by making all entries in that category subitems)\n\nThe file format on disk should be human readable, but it need not be standardized.   A natively available format that doesn't need an external library is preferred.   Avoid developing your own format if you can use an already existing one.   If there is no existing format available, pick one of:\n\n:   :   :   * JSON\n            * S-Expressions\n            * YAML\n            * others\n\nRelated task\n\n* Take notes on the command line"}, {"role": "assistant", "content": "(formerly Perl 6)\nA generic client/server JSON database.  \n**server.raku:**\n\n```\n#!/usr/bin/env raku\nuse JSON::Fast ;\nsub MAIN( :$server='0.0.0.0', :$port=3333, :$dbfile='db' ) {\n    my %db;\n    my %index;\n    my $dbdata = slurp \"$dbfile.json\" ;\n    my $indexdata = slurp \"{$dbfile}_index.json\" ;\n    %db = from-json($dbdata) if $dbdata ;\n    %index = from-json($indexdata) if $indexdata ;\n  react {\n    whenever IO::Socket::Async.listen( $server , $port ) -> $conn {\n        whenever $conn.Supply.lines -> $line {\n            my %response = 'status' => '' ;\n            my $msg = from-json $line ;\n            say $msg.perl ;\n            given $msg<function> { \n                when 'set' {\n                    %db{ $msg<topic> } = $msg<message> ;\n                    %response<status> = 'ok' ;\n                    %index<last_> = $msg<topic> ;\n                    for %index<keys_>.keys -> $key {\n                        if $msg<message>{$key} {\n                            %index<lastkey_>{ $key }{ $msg<message>{$key} } = $msg<topic> ;    \n                            %index<idx_>{ $key }{ $msg<message>{$key} }{ $msg<topic> } = 1 ;\n                        }\n                    }\n                    spurt \"$dbfile.json\", to-json(%db);\n                    spurt \"{$dbfile}_index.json\", to-json(%index);\n                }\n                when 'get' {\n                    %response<topic> = $msg<topic> ;\n                    %response<message> = %db{ $msg<topic> } ;\n                    %response<status> = 'ok' ;\n                }\n                when 'dump' {\n                    %response{'data'} = %db ;\n                    %response<status> = 'ok' ;\n                }\n                when 'dumpindex' {\n                    %response{'data'} = %index ;\n                    %response<status> = 'ok' ;\n                }\n                when 'delete' {\n                    %db{ $msg<topic> }:delete;\n                    %response<status> = 'ok' ;\n                    spurt \"$dbfile.json\", to-json(%db);\n                    reindex();\n                }\n                when 'addindex' {\n                    %response<status> = 'ok' ;\n                    %index<keys_>{ $msg<key>} =1 ;\n                    reindex();\n                }\n                when 'reportlast' {\n                    %response{'data'} = %db{%index<last_>} ;\n                    %response<status> = 'ok' ;\n                }\n                when 'reportlastindex' {\n                    %response<key> = $msg<key> ;\n                    for %index<lastkey_>{$msg<key>}.keys -> $value {\n                        #%response{'data'}.push: %db{ %index<lastkey_>{ $msg<key>  }{ $value } } ;\n                        %response{'data'}{$value} = %db{ %index<lastkey_>{ $msg<key>  }{ $value } } ;\n                    }\n                    %response<status> = 'ok' ;\n                }\n                when 'reportindex' {\n                    %response<status> = 'ok' ;\n                    for %index<idx_>{$msg<key>}.keys.sort -> $value  {\n                        for %index<idx_>{ $msg<key> }{ $value }.keys.sort -> $topic {\n                            %response<data>.push:  %db{ $topic }  ;\n                            #%response<data>{$value} = %db{ $topic }  ;\n                        }\n                    }\n                }\n                when 'commit' {\n                    spurt \"$dbfile.json\", to-json(%db);\n                    spurt \"{$dbfile}_index.json\", to-json(%index);\n                    %response<status> = 'ok' ;\n                }\n                default {\n                    %response<status> = 'error';\n                    %response<error> = 'no function or not supported';\n                }\n            }\n            $conn.print( to-json(%response, :!pretty) ~ \"\\n\" ) ;\n            LAST { $conn.close ; }\n            QUIT { default { $conn.close ; say \"oh no, $_\";}}\n            CATCH { default { say .^name, ': ', .Str ,  \" handled in $?LINE\";}}\n        }\n    }\n  }\n    sub reindex {\n        %index<idx_>:delete;\n        for %db.keys -> $topic {\n            my $msg = %db{$topic} ;\n            for %index<keys_>.keys -> $key {\n                if $msg{$key} {\n                    %index<idx_>{ $key }{ $msg{$key} }{ $topic } = 1 ;\n                }\n            }\n        }\n        spurt \"{$dbfile}_index.json\", to-json(%index) ;\n    }\n}\n\n```\n\n**client.raku:**\n\n```\n#!/usr/bin/env raku\nuse JSON::Fast ;\nmulti MAIN('set', $topic,  $message='', :$server='localhost', :$port='3333', :$json='') {\n    my %msg = function => 'set' , topic=> $topic , message=> $message ;\n    %msg{\"message\"} = from-json( $json ) if $json ;\n    sendmsg( %msg , $server, $port) ;\n}\nmulti MAIN('add', $topic,  $json, :$server='localhost', :$port='3333' ) {\n    my %msg = function => 'set' , topic=> $topic;\n    %msg{\"message\"} = from-json( $json ) if $json ;\n    sendmsg( %msg , $server, $port) ;\n}\nmulti MAIN('get', $topic, :$server='localhost', :$port='3333') {\n    my %msg = function => 'get' , topic=> $topic ;\n    sendmsg( %msg , $server, $port) ;\n}\nmulti MAIN('delete', $topic, :$server='localhost', :$port='3333') {\n    my %msg = function => 'delete' , topic=> $topic ;\n    sendmsg( %msg , $server, $port) ;\n}\nmulti MAIN('dump', :$server='localhost', :$port='3333') {\n    my %msg = function => 'dump'  ;\n    sendmsg( %msg , $server, $port) ;\n}\nmulti MAIN('addindex', $key, :$server='localhost', :$port='3333') {\n    my %msg = function => 'addindex', key => $key  ;\n    sendmsg( %msg , $server, $port) ;\n}\nmulti MAIN('reportindex', $key, :$server='localhost', :$port='3333') {\n    my %msg = function => 'reportindex', key => $key  ;\n    sendmsg( %msg , $server, $port) ;\n}\nmulti MAIN('reportlastindex', $key, :$server='localhost', :$port='3333') {\n    my %msg = function => 'reportlastindex', key => $key  ;\n    sendmsg( %msg , $server, $port) ;\n}\nmulti MAIN('reportlast', :$server='localhost', :$port='3333') {\n    my %msg = function => 'reportlast' ;\n    sendmsg( %msg , $server, $port) ;\n}\nsub sendmsg( %msg , $server, $port){\n    my $conn = await IO::Socket::Async.connect( $server , $port );\n    $conn.print: to-json( %msg,:!pretty)~\"\\n\";\n    react {\n        whenever $conn.Supply -> $data {\n            print $data;\n            $conn.close;\n        }\n    }\n}\n\n```\n\nExample:\n\n```\n./client.raku addindex constructor\n./client.raku addindex date\n\n./client.raku add 2007 '{\"date\":\"2007-11-04\",\"constructor\":\"Ducati\",\"name\":\"Casey Stoner\"}'\n./client.raku add 2008 '{\"date\":\"2008-10-26\",\"constructor\":\"Yamaha\",\"name\":\"Valentino Rossi\"}'\n./client.raku add 2009 '{\"date\":\"2009-11-08\",\"constructor\":\"Yamaha\",\"name\":\"Valentino Rossi\"}'\n./client.raku add 2010 '{\"date\":\"2010-11-17\",\"constructor\":\"Yamaha\",\"name\":\"Jorge Lorenzo\"}'\n./client.raku add 2011 '{\"date\":\"2011-11-06\",\"constructor\":\"Honda\",\"name\":\"Casey Stoner\"}'\n./client.raku add 2012 '{\"date\":\"2012-11-11\",\"constructor\":\"Yamaha\",\"name\":\"Jorge Lorenzo\"}'\n./client.raku add 2013 '{\"date\":\"2013-11-10\",\"constructor\":\"Honda\",\"name\":\"Marc Márquez\"}'\n./client.raku add 2014 '{\"date\":\"2014-11-09\",\"constructor\":\"Honda\",\"name\":\"Marc Márquez\"}'\n./client.raku add 2015 '{\"date\":\"2015-11-08\",\"constructor\":\"Yamaha\",\"name\":\"Jorge Lorenzo\"}'\n./client.raku add 2016 '{\"date\":\"2016-11-13\",\"constructor\":\"Honda\",\"name\":\"Marc Márquez\"}'\n./client.raku add 2017 '{\"date\":\"2017-11-12\",\"constructor\":\"Honda\",\"name\":\"Marc Márquez\"}'\n\n./client.raku reportlast\n./client.raku reportlastindex constructor\n./client.raku reportindex date\n```"}]}
{"messages": [{"role": "user", "content": "The first turtle graphic discussed in Mindstorms: Children, Computers, and Powerful Ideas by Seymour Papert is a simple drawing of a house. It is a square with a triangle on top for the roof.\n\nFor a slightly more advanced audience, a more practical introduction to turtle graphics might be to draw a bar chart.\n\nTask\n:   :   * Create a function (or subroutine) that uses turtle graphics to draw a house of a specified size as depicted. Optionally make it lovely by adding details such as, for example, doors and windows.\n\n:   :   * Create a function (or subroutine) that takes a list (array, vector) of non-negative numbers and draws a bar chart from them, scaled to fit exactly in a square of a specified size. The enclosing square need not be drawn.\n\n:   :   * Both functions should return the turtle to the location it was at and facing in the same direction as it was immediately before the function was executed."}, {"role": "assistant", "content": "```\n# 20250303 Raku programming solution\n\nuse Cairo;\n\nsub house(Cairo::Context $cr, $x, $y, $size) {\n   $cr.save;\n   $cr.rgb(1.0, 1.0, 1.0);\n\n   $cr.rectangle($x, $y, $size, $size);\n   $cr.stroke;\n\n   $cr.move_to($x + $size / 2, $y - $size / 2);\n   $cr.line_to($x, $y);\n   $cr.line_to($x + $size, $y);\n   $cr.close_path;\n   $cr.stroke;\n\n   $cr.restore;\n}\n\nsub barchart(Cairo::Context $cr, @data, $x is copy, $y, $size) {\n   $cr.save;\n   $cr.rgb(1.0, 1.0, 1.0);\n\n   my $maxdata = @data.max || 1;\n   my $bar-width = $size / (@data.elems || 1);\n   my $bar-spacing = $bar-width * 0.1;\n\n   for @data -> $n {\n      my $bar-height = ($n / $maxdata) * $size;\n      $cr.rectangle($x, $y - $bar-height, $bar-width - $bar-spacing, $bar-height);\n      $cr.stroke;\n      $x += $bar-width;\n   }\n\n   $cr.restore;\n}\n\nsub testturtle($width = 400, $height = 600) {\n   my $image = Cairo::Image.create(Cairo::FORMAT_ARGB32, $width, $height);\n   my $cr = Cairo::Context.new($image);\n\n   $cr.rgb(0.0, 0.0, 0.0);\n   $cr.paint;\n\n   $cr.line_width = 2.0;\n\n   barchart($cr, [15, 10, 50, 35, 20], $width * 0.6, $height, $width / 3);\n   house($cr, $width / 4, $height / 3, $width / 3);\n\n   $image.write_png('turtle-raku.png');\n}\n\ntestturtle();\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a window that has:\n\n:   :   1. a label that says   \"There have been no clicks yet\"\n        2. a button that says   \"click me\"\n\nUpon clicking the button with the mouse, the label should change and show the number of times the button has been clicked."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Library:** GTK\n\n```\nuse GTK::Simple;\nuse GTK::Simple::App;\n\nmy GTK::Simple::App $app .= new(title => 'Simple Windowed Application');\n\n$app.size-request(350, 100);\n\n$app.set-content(\n    GTK::Simple::VBox.new(\n        my $label  = GTK::Simple::Label.new( text  => 'There have been no clicks yet'),\n        my $button = GTK::Simple::Button.new(label => 'click me'),\n    )\n);\n\n$app.border-width = 40;\n\n$button.clicked.tap: { \n    state $clicks += 1;\n    $label.text = \"There has been $clicks click{ 's' if $clicks != 1 }\";\n}\n\n$app.run;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSend simulated keystrokes to a GUI window, or terminal.\n\nYou should specify whether the target may be externally created\n(i.e., if the keystrokes are going to an application\nother than the application that is creating them)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nUse libxdo bindings to send text / keystrokes to any application that will accept keystrokes from X11.\n\n```\nuse X11::libxdo;\n\nmy $xdo = Xdo.new;\n\nmy $active = $xdo.get-active-window;\n\nmy $command = $*VM.config<os> eq 'darwin' ?? 'open' !! 'xdg-open';\n\nshell \"$command https://www.google.com\";\n\nsleep 1;\n\nmy $match = rx[^'Google '];\n\nsay my $w = $xdo.search(:name($match))<ID>;\n\nsleep .25;\n\nif $w {\n    $xdo.activate-window($w);\n    say \"Window name: \", $xdo.get-window-name( $w );\n    $xdo.type($w, 'Raku language');\n    sleep .25;\n    $xdo.send-sequence($w, 'Tab');\n    sleep .5;\n    $xdo.send-sequence($w, 'Tab');\n    sleep .5;\n    $xdo.send-sequence($w, 'Tab');\n    sleep .5;\n    $xdo.send-sequence($w, 'Return');\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Simulate the click of a mouse button by the user. Specify if the target GUI may be externally created."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nUsing bindings to libxdo so any window managed by an X11 display server can receive mouse events.\n\n```\nuse X11::libxdo;\nmy $xdo = Xdo.new;\n\nmy ($dw, $dh) = $xdo.get-desktop-dimensions( 0 );\n\nsleep .25;\n\nfor ^$dw -> $mx {\n    my $my = (($mx / $dh * τ).sin * 500).abs.Int + 200;\n    $xdo.move-mouse( $mx, $my, 0 );\n    my ($x, $y, $window-id, $screen) = $xdo.get-mouse-info;\n    my $name = (try $xdo.get-window-name($window-id) if $window-id)\n       // 'No name set';\n\n    my $line = \"Mouse location: x=$x : y=$y\\nWindow under mouse:\\nWindow ID: \" ~\n       $window-id ~ \"\\nWindow name: \" ~ $name ~ \"\\nScreen #: $screen\";\n\n    print \"\\e[H\\e[J\", $line;\n    sleep .001;\n}\n\nsay '';\n\n#`[ There are several available routines controlling mouse position and button events.\n\n.move-mouse( $x, $y, $screen ) # Move the mouse to a specific location.\n\n.move-mouse-relative( $delta-x, $delta-y ) # Move the mouse relative to it's current position.\n\n.move-mouse-relative-to-window( $x, $y, $window ) # Move the mouse to a specific location relative to the top-left corner of a window.\n\n.get-mouse-location() # Get the current mouse location (coordinates and screen ID number).\n\n.get-mouse-info() # Get all mouse location-related data.\n\n.wait-for-mouse-to-move-from( $origin-x, $origin-y ) # Wait for the mouse to move from a location.\n\n.wait-for-mouse-to-move-to( $dest-x, $dest-y ) # Wait for the mouse to move to a location.\n\n.mouse-button-down( $window, $button ) # Send a mouse press (aka mouse down) for a given button at the current mouse location.\n\n.mouse-button-up( $window, $button ) # Send a mouse release (aka mouse up) for a given button at the current mouse location.\n\n.mouse-button-click( $window, $button ) # Send a click for a specific mouse button at the current mouse location.\n\n.mouse-button-multiple( $window, $button, $repeat = 2, $delay? ) # Send a one or more clicks of a specific mouse button at the current mouse location.\n]\n\n```"}]}
{"messages": [{"role": "user", "content": "Quoted from the Wikipedia page : **Simulated annealing (SA)** is a probabilistic technique for approximating the global optimum of a given function. Simulated annealing interprets slow cooling as a slow decrease in the probability of temporarily accepting worse solutions as it explores the solution space.\n\n**Pseudo code** from Wikipedia\n\n```\nNotations :\n  T : temperature. Decreases to 0.\n  s : a system state\n  E(s) : Energy at s. The function we want to minimize\n  ∆E : variation of E, from state s to state s_next\n  P(∆E , T) : Probability to move from s to s_next. \n  \tif  ( ∆E < 0 ) P = 1\n  \t      else P = exp ( - ∆E / T) . Decreases as T →  0\n  \nPseudo-code:\n    Let s = s0  -- initial state\n    For k = 0 through kmax (exclusive):\n        T ← temperature(k , kmax)\n        Pick a random neighbour state , s_next ← neighbour(s)\n        ∆E ← E(s) - E(s_next) \n        If P(∆E , T) ≥ random(0, 1), move to the new state:\n            s ← s_next\n    Output: the final state s\n\n```\n\n**Problem statement**\n\nWe want to apply SA to the travelling salesman problem. There are 100 cities, numbered 0 to 99, located on a plane, at integer coordinates i,j : 0 <= i,j < 10 . The city at (i,j) has number 10\\*i + j. The cities are **all** connected : the graph is complete : you can go from one city to any other city in one step.\n\nThe salesman wants to start from city 0, visit all cities, each one time, and go back to city 0. The travel cost between two cities is the euclidian distance between them. The total travel cost is the total path length.\n\nA path **s** is a sequence (0 a b ...z 0) where (a b ..z) is a permutation of the numbers (1 2 .. 99). The path length = E(s) is the sum d(0,a) + d(a,b) + ... + d(z,0) , where d(u,v) is the distance between two cities. Naturally, we want to minimize E(s).\n\nDefinition : The neighbours of a city are the closest cities at distance 1 horizontally/vertically, or √2 diagonally. A corner city (0,9,90,99) has 3 neighbours. A center city has 8 neighbours.\n\n```\nDistances between cities\nd ( 0, 7) → 7\nd ( 0, 99) → 12.7279\nd ( 23, 78) → 7.0711\nd ( 33, 44) → 1.4142 // sqrt(2)\n\n```\n\n**Task**\n\nApply SA to the travelling salesman problem, using the following set of parameters/functions :\n\n* kT = 1 (Multiplication by kT is a placeholder, representing computing temperature as a function of 1-k/kmax):\n* temperature (k, kmax) = kT \\* (1 - k/kmax)\n* neighbour (s) : Pick a random city u > 0 . Pick a random neighbour city v > 0 of u , among u's 8 (max) neighbours on the grid. Swap u and v in s . This gives the new state *s\\_next*.\n* kmax = 1000\\_000\n* s0 = a random permutation\n\nFor k = 0 to kmax by step kmax/10 , display k, T, E(s). Display the final state s\\_final, and E(s\\_final).\n\nYou will see that the Energy may grow to a local optimum, before decreasing to a global optimum.\n\n**Illustrated example**\nTemperature charts\n\n**Numerical example**\n\n```\nkT = 1\nE(s0) = 529.9158\n\nk:  0         T:  1       Es:  529.9158\nk:  100000    T:  0.9     Es:  201.1726\nk:  200000    T:  0.8     Es:  178.1723\nk:  300000    T:  0.7     Es:  154.7069\nk:  400000    T:  0.6     Es:  158.1412 <== local optimum\nk:  500000    T:  0.5     Es:  133.856\nk:  600000    T:  0.4     Es:  129.5684\nk:  700000    T:  0.3     Es:  112.6919\nk:  800000    T:  0.2     Es:  105.799\nk:  900000    T:  0.1     Es:  102.8284\nk:  1000000   T:  0       Es:  102.2426\n\nE(s_final) =    102.2426    \nPath  s_final =   ( 0 10 11 21 31 20 30 40 50 60 70 80 90 91 81 71 73 83 84 74 64 54 55 65 75 76 66\n 67 77 78 68 58 48 47 57 56 46 36 37 27 26 16 15 5 6 7 17 18 8 9 19 29 28 38 39 49 59 69 \n79 89 99 98 88 87 97 96 86 85 95 94 93 92 82 72 62 61 51 41 42 52 63 53 43 32 22 12 13 \n23 33 34 44 45 35 25 24 14 4 3 2 1 0)  \n\n```\n\n**Extra credit**\n\nTune the parameters kT, kmax, or use different temperature() and/or neighbour() functions to demonstrate a quicker convergence, or a better optimum."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Go\n\n```\n# simulation setup\nmy \\cities = 100;  # number of cities\nmy \\kmax   = 1e6;  # iterations to run\nmy \\kT     = 1;    # initial 'temperature'\n\ndie 'City count must be a perfect square.' if cities.sqrt != cities.sqrt.Int;\n\n# locations of (up to) 8 neighbors, with grid size derived from number of cities\nmy \\gs = cities.sqrt;\nmy \\neighbors = [1, -1, gs, -gs, gs-1, gs+1, -(gs+1), -(gs-1)];\n\n# matrix of distances between cities\nmy \\D = [;];\nfor 0 ..^ cities² -> \\j {\n    my (\\ab, \\cd)       = (j/cities, j%cities)».Int;\n    my (\\a, \\b, \\c, \\d) = (ab/gs, ab%gs, cd/gs, cd%gs)».Int;\n    D[ab;cd] = sqrt (a - c)² + (b - d)²\n}\n\nsub T(\\k, \\kmax, \\kT)      { (1 - k/kmax) × kT }                                 # temperature function, decreases to 0\nsub P(\\ΔE, \\k, \\kmax, \\kT) { exp( -ΔE / T(k, kmax, kT)) }                        # probability to move from s to s_next\nsub Es(\\path)              { sum (D[ path[$_]; path[$_+1] ] for 0 ..^ +path-1) } # energy at s, to be minimized\n\n# variation of E, from state s to state s_next\nsub delta-E(\\s, \\u, \\v) {\n    my (\\a,   \\b,  \\c,  \\d) = D[s[u-1];s[u]], D[s[u+1];s[u]], D[s[v-1];s[v]], D[s[v+1];s[v]];\n    my (\\na, \\nb, \\nc, \\nd) = D[s[u-1];s[v]], D[s[u+1];s[v]], D[s[v-1];s[u]], D[s[v+1];s[u]];\n    if    v == u+1 { return (na + nd) - (a + d) }\n    elsif u == v+1 { return (nc + nb) - (c + b) }\n    else           { return (na + nb + nc + nd) - (a + b + c + d) }\n}\n\n# E(s0), initial state\nmy \\s = @ = flat 0, (1 ..^ cities).pick(*), 0;\nmy \\E-min-global = my \\E-min = $ = Es(s);\n\nfor 0 ..^ kmax -> \\k {\n    printf \"k:%8u  T:%4.1f  Es: %3.1f\\n\" , k, T(k, kmax, kT), Es(s)\n            if k % (kmax/10) == 0;\n\n    # valid candidate cities (exist, adjacent)\n    my \\cv = neighbors[(^8).roll] + s[ my \\u = 1 + (^(cities-1)).roll ];\n    next if cv ≤ 0 or cv ≥ cities or D[s[u];cv] > sqrt(2);\n\n    my \\v  = s[cv];\n    my \\ΔE = delta-E(s, u, v);\n    if ΔE < 0 or P(ΔE, k, kmax, kT) ≥ rand { # always move if negative\n        (s[u], s[v]) = (s[v], s[u]);\n        E-min += ΔE;\n        E-min-global = E-min if E-min < E-min-global;\n    }\n}\n\nsay \"\\nE(s_final): \" ~ E-min-global.fmt('%.1f');\nsay \"Path:\\n\" ~ s».fmt('%2d').rotor(20,:partial).join: \"\\n\";\n\n```\n\nOutput:\n\n```\nk:       0  T: 1.0  Es: 522.0\nk:  100000  T: 0.9  Es: 185.3\nk:  200000  T: 0.8  Es: 166.1\nk:  300000  T: 0.7  Es: 174.7\nk:  400000  T: 0.6  Es: 146.9\nk:  500000  T: 0.5  Es: 140.2\nk:  600000  T: 0.4  Es: 127.5\nk:  700000  T: 0.3  Es: 115.9\nk:  800000  T: 0.2  Es: 111.9\nk:  900000  T: 0.1  Es: 109.4\n\nE(s_final): 109.4\nPath:\n 0 10 20 30 40 50 60 84 85 86 96 97 87 88 98 99 89 79 78 77\n67 68 69 59 58 57 56 66 76 95 94 93 92 91 90 80 70 81 82 83\n73 72 71 62 63 64 74 75 65 55 54 53 52 61 51 41 31 21 22 32\n42 43 44 45 46 35 34 24 23 33 25 15 16 26 36 47 37 27 17 18\n28 38 48 49 39 29 19  9  8  7  6  5  4 14 13 12 11  2  3  1\n 0\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGenerate a sine wave:\n\n:   :   1. you choose the frequency of the wave\n        2. generate a sine wave for 5 seconds\n        3. play sound"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.04.01\n\nWhat a horribly underspecified task. Ah well, gives me lots of wiggle room to cheat in various ways.\n\n```\nmy ($rows,$cols) = qx/stty size/.words;\nmy $v = floor $rows / 2;\nprint \"\\e[H\\e[J\", 'Generating sine wave of zero amplitude and zero frequency for 5 seconds...',\n  \"\\e[$v;0H\", '_' x $cols;\nsleep 5;\nsay \"\\e[H\\e[J\", 'No?, ok how about this:';\n\nuse SVG;\nmy $filename = 'sine.svg';\nmy $out = open($filename, :w) orelse .die;\n$out.say: SVG.serialize(\n    svg => [\n        width => 400, height => 150, style => 'stroke:rgb(0,0,255)',\n        :rect[:width<100%>, :height<100%>, :fill<white>],\n        :path[ :fill<none>, :d('M0,25 C36.42,25,63.58,125,100,125 M100,125 C136.42,125,163.58,25,200,25 M200,25 C236.42,25,263.58,125,300,125 M300,125 C336.42,125,363.58,25,400,25') ],\n    ],\n);\nclose $out;\nsay \"Sine wave generated to {$filename.IO.absolute}, better open it quickly...\";\nsleep 5;\nunlink $filename;\nsay 'Oops, too late.';\nsay 'Still no? Ok how about:';\nshell 'play -n -c1 synth 5.0 sin %-12';\n\n```"}]}
{"messages": [{"role": "user", "content": "A Global Singleton is a class of which only one instance exists within a program.\n\nAny attempt to use non-static members of the class involves performing operations on this one instance."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nclass Singleton {\n    # We create a lexical variable in the class block that holds our single instance.\n    my Singleton $instance = Singleton.bless; # You can add initialization arguments here.\n    method new {!!!} # Singleton.new dies.\n    method instance { $instance; }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Define the data structure for a singly-linked list element. Said element should contain a data member capable of holding a numeric value, and the link to the next element should be mutable.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n#### With Pair\n\nA Pair (constructed with the `=>` operator) can be treated as a cons cell, and thus used to build a linked lists:\n\n```\nmy $elem = 42 => $nextelem;\n\n```\n\nHowever, because this is not the primary purpose of the Pair type, it suffers from the following limitations:\n\n* The naming of Pair's accessor methods is not idiomatic for this use case (`.key` for the cell's value, and `.value` for the link to the next cell).\n* A Pair (unlike an Array) does not automatically wrap its keys/values in item containers – so each cell of the list will be immutable once created, making element insertion/deletion impossible (except inserting at the front).\n* It provides no built-in convenience methods for iterating/modifying/transforming such a list.\n\n#### With custom type\n\nFor more flexibility, one would create a custom type:\n\n```\nclass Cell {\n    has      $.value is rw;\n    has Cell $.next  is rw;\n    \n    # ...convenience methods here...\n}\n\nsub cons ($value, $next) { Cell.new(:$value, :$next) }\n\nmy $list = cons 10, (cons 20, (cons 30, Nil));\n\n```"}]}
{"messages": [{"role": "user", "content": "Using the link element defined in Singly-Linked List (element), define a method to insert an element into a singly-linked list following a given element.\n\nUsing this method, insert an element C into a list comprised of elements A->B, following element A.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nExtending class Cell from Singly-linked\\_list/Element\\_definition#Raku:\n\n```\n    method insert ($value) {\n        $.next = Cell.new(:$value, :$.next)\n    }\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDefine a method to remove an element from a singly-linked list and demonstrate its use.\n\nYou may wish to use the link element defined in Singly-Linked List (element) for the purposes of this task.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nExtending class Cell from Singly-linked\\_list/Element\\_definition#Raku:\n\n```\n    method delete ($value --> Cell) {\n        my $prev = Nil;\n        my $cell = self;\n        my $new-head = self;\n        \n        while $cell {\n            my $next = $cell.next;\n            if $cell.value == $value {\n                $prev.next = $next if $prev;\n                $cell.next = Nil;\n                $new-head = $next if $cell === $new-head;\n            }\n            else {\n                $prev = $cell;\n            }\n            $cell = $next;\n        }\n        \n        return $new-head;\n    }\n\n```\n\nUsage:\n\n```\nmy $list = cons 10, (cons 20, (cons 10, (cons 30, Nil)));\n\n$list = $list.delete(10);\n\n```"}]}
{"messages": [{"role": "user", "content": ":   I don't even know how to reverse a linked-list, and I don't even know what that is. -- a YouTuber.\n\nReverse a linked list. Obviously you can do it by turning it into a normal list and back, but feel free to use a smarter, possibly more efficient way."}, {"role": "assistant", "content": "Extending code from the Singly-linked\\_list/Element\\_definition#Raku Task\n\n```\n# 20240220 Raku programming solution\n\nclass Cell { has ($.value, $.next) is rw;\n\n   method reverse {\n      my ($list, $prev) = self, Nil;\n      while $list.defined {\n         my $next = $list.next;\n         $list.next = $prev;\n         ($list, $prev) = ($next, $list)\n      }\n      return $prev;\n   }\n\n   method gist {\n      my $cell = self;\n      return ( gather while $cell.defined {\n         take $cell.value andthen $cell = $cell.next;\n      } ).Str\n   }\n}\n\nsub cons ($value, $next = Nil) { Cell.new(:$value, :$next) }\n\nmy $list = cons 10, (cons 20, (cons 30, (cons 40, Nil)));\n\nsay $list = $list.reverse;\nsay $list = $list.reverse;\n\n```\n\nOutput:\n\n```\n40 30 20 10\n10 20 30 40\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Traverse from the beginning of a singly-linked list to the end.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### With Pair\n\nBuilt-in list processing in Raku is not specifically based on singly-linked lists,\nbut works at a higher abstraction level that encapsulates such implementation choices. Nonetheless, it's trivial to use the Pair type to build what is essentially a Lisp-style cons list, and in fact, the => pair constructor is right associative for precisely that reason.\nWe traverse such a list here using a 3-part loop:\n\n```\nmy $list = 1 => 2 => 3 => 4 => 5 => 6 => Mu;\n\nloop (my $l = $list; $l; $l.=value) {\n    say $l.key;\n}\n\n```\n\nOutput:\n\n```\n1\n2\n3\n4\n5\n6\n```\n\nIt would be pretty easy to make such lists iterable as normal Raku lists,\nif anyone really cared to...\n\nWell, shoot, let's just go ahead and do it.\nWe'll pretend the Pair type is really a list type.\n(And we show how you turn an ordinary list into a cons list using a reduction.\nNote how the [=>] reduction is also right associative,\njust like the base operator.)\n\n```\nuse MONKEY-TYPING;\naugment class Pair {\n    method traverse () {\n        gather loop (my $l = self; $l; $l.=value) {\n            take $l.key;\n        }\n    }\n}\n\nmy $list = [=>] 'Ⅰ' .. 'Ⅻ', Mu;\nsay ~$list.traverse;\n\n```\n\nOutput:\n\n```\nⅠ Ⅱ Ⅲ Ⅳ Ⅴ Ⅵ Ⅶ Ⅷ Ⅸ Ⅹ Ⅺ Ⅻ\n```\n\n### With custom type\n\nExtending class Cell from Singly-linked\\_list/Element\\_definition#Raku:\n\n```\n    method Seq {\n        self, *.next ...^ !*\n    }\n\n```\n\nUsage:\n\n```\nmy $list = (cons 10, (cons 20, (cons 30, Nil)));\n\nfor $list.Seq -> $cell {\n    say $cell.value;\n}\n\n```\n\nOutput:\n\n```\n10\n20\n30\n```"}]}
{"messages": [{"role": "user", "content": "A\n{\\displaystyle {\\displaystyle A}}\n is any m by n matrix, square or rectangular. Its rank is r. We will diagonalize this A, but not by \n\nX\n\n−\n1\nA\nX\n{\\displaystyle {\\displaystyle X^{-1}AX}}\n.\nThe eigenvectors in \n\nX\n{\\displaystyle {\\displaystyle X}}\n have three big problems: They are usually not orthogonal, there\nare not always enough eigenvectors, and \n\nA\nx\n{\\displaystyle {\\displaystyle Ax}}\n = \n\nλ\nx\n{\\displaystyle {\\displaystyle \\lambda x}}\n requires \n\nA\n{\\displaystyle {\\displaystyle A}}\n to be a square matrix. The\nsingular vectors of \n\nA\n{\\displaystyle {\\displaystyle A}}\n solve all those problems in a perfect way.\n\nThe Singular Value Decomposition (SVD)\n\nAccording to the web page above, for any rectangular matrix \n\nA\n{\\displaystyle {\\displaystyle A}}\n, we can decomposite it as \n\nA\n=\nU\nΣ\n\nV\n\nT\n{\\displaystyle {\\displaystyle A=U\\Sigma V^{T}}}\n\n**Task Description**\n\nFirstly, input two numbers \"m\" and \"n\".\n\nThen, input a square/rectangular matrix \n\nA\n\nm\n×\nn\n{\\displaystyle {\\displaystyle A^{m\\times n}}}\n.\n\nFinally, output \n\nU\n,\n \nΣ\n,\n \nV\n{\\displaystyle {\\displaystyle U,~\\Sigma ,\\ V}}\n with respect to \n\nA\n{\\displaystyle {\\displaystyle A}}\n.\n\n**Example**\n\n**Sample Input**\n\n```\n2 2\n3 0\n4 5\n\n```\n\nFrom the input above we can know that \n\nA\n{\\displaystyle {\\displaystyle A}}\n is a 2 by 2 matrix.\n\n**Sample Output**\n\n```\n   \n0.31622776601683794 -0.9486832980505138\n0.9486832980505138 0.31622776601683794\n\n6.708203932499369 0\n0 2.23606797749979\n\n0.7071067811865475 -0.7071067811865475\n0.7071067811865475 0.7071067811865475\n\n```\n\nThe output may vary depending your choice of the data types.\n\n**Remark**\n\n1. It’s encouraged to implement the algorithm by yourself while using libraries is still acceptible.\n\n2. The algorithm should be applicable for general case(\n\nm\n×\nn\n{\\displaystyle {\\displaystyle m\\times n}}\n)."}, {"role": "assistant", "content": "```\n# 20230108 Raku programming solution\n\nuse Math::Libgsl::Matrix;\nuse Math::Libgsl::LinearAlgebra;\n\nmy @M = <3 0>, <4 5>;\nmy Math::Libgsl::Matrix \\M .= new: @M.elems, @M.first.elems;\n(^M.size1)>>.&{ M.set-row: $_, @M[$_;*] }\n\nmy (\\V,\\S) = SV-decomp M;\n\nsay \"U factor: \"        and say (^M.size1)>>.&{ M.get-row($_)>>.fmt: '%.10g' }\nsay \"singular values: \" and say (^S.size )>>.&{     S.get($_)>>.fmt: '%.10g' }\nsay \"Vt factor: \"       and say (^V.size1)>>.&{ V.get-row($_)>>.fmt: '%.10g' }\n\n```\n\nOutput:\n\n```\nU factor: \n([-0.316227766 -0.9486832981] [-0.9486832981 0.316227766])\nsingular values: \n((6.708203932) (2.236067977))\nVt factor: \n([-0.7071067812 -0.7071067812] [-0.7071067812 0.7071067812])\n```"}]}
{"messages": [{"role": "user", "content": "The **Sisyphus sequence** is an infinite sequence of positive integers that was devised in 2022 by Eric Angelini and Carole Dubois.\n\nThe first term is 1. Subsequent terms are found by applying the following rule:\n\n* If the previous term was even, then halve it.\n\n* If the previous term was odd, then add the smallest prime number that has not yet been added.\n\n1 is odd and so the second term is: 1 + 2 = 3, because 2 is the smallest prime not yet added.\n\n3 is odd and so the third term is: 3 + 3 = 6, because 3 is the smallest prime not yet added.\n\n6 is even and so the fourth term is : 6 ÷ 2 = 3, and so on.\n\nTask\n\nFind and show on this page (in 10 lines of 10 terms), the first 100 terms of the sequence.\n\nWhat are the **1,000**th, **10,000**th, **100,000**th and **1,000,000**th terms of the sequence and, in each case, what is the highest prime needed to reach them?\n\nIf it is difficult or impossible for your language or output device to meet all of these requirements, then just do what you reasonably can.\n\nStretch\n\nWhat are the **10 millionth** and **100 millionth** terms and the highest prime needed to reach each one?\n\nBy the time the **100 millionth** term is reached, which number(s) **under 250**:\n\n* Have not yet occurred in the sequence.\n\n* Have occurred the most times and their number of occurrences.\n\nExtreme stretch\n\nWhat is the number of the first term to equal 36?\n\nThis was originally set as a challenge by Neil Sloane who was worried by its non-appearance and found by Russ Cox.\n\nReferences\n\n* OEIS sequence A350877: The Sisyphus sequence"}, {"role": "assistant", "content": "```\nuse Math::Primesieve;\nuse Lingua::EN::Numbers;\n\nmy ($exp1, $exp2, $limit1, $limit2)  = 3, 8, 100, 250;\nmy ($n, $s0, $s1, $p, @S1, %S) =  1, 1, Any, Any, 1;\nmy $iterator = Math::Primesieve::iterator.new;\nmy @Nth = ($exp1..$exp2)».exp(10);\nmy $S2 = BagHash.new;\n\nrepeat {\n    $n++;\n    $s1 = $s0 %% 2 ?? $s0 div 2 !! $s0 + ($p = $iterator.next);\n    @S1.push: $s1 if  $n ≤ $limit1;\n    $S2.add:  $s1 if $s1 ≤ $limit2;\n    %S{$n}{'value', 'prime'} = $s1, $p if $n ∈ @Nth;\n    $s0 = $s1;\n} until $n == @Nth[*-1];\n\nsay \"The first $limit1 members of the Sisyphus sequence are:\";\nsay @S1.batch(10)».fmt('%4d').join(\"\\n\") ~ \"\\n\";\nprintf \"%12sth member is: %13s with prime: %11s\\n\", ($_, %S{$_}{'value'}, %S{$_}{'prime'})».&comma for @Nth;\nsay \"\\nNumbers under $limit2 that do not occur in the first {comma @Nth[*-1]} terms:\";\nsay (1..$limit2).grep: * ∉ $S2.keys;\nsay \"\\nNumbers under $limit2 that occur the most ({$S2.values.max} times) in the first {comma @Nth[*-1]} terms:\";\nsay $S2.keys.grep({ $S2{$_} == $S2.values.max}).sort;\n\n```\n\nOutput:\n\n```\nThe first 100 members of the Sisyphus sequence are:\n   1    3    6    3    8    4    2    1    8    4\n   2    1   12    6    3   16    8    4    2    1\n  18    9   28   14    7   30   15   44   22   11\n  42   21   58   29   70   35   78   39   86   43\n  96   48   24   12    6    3   62   31   92   46\n  23   90   45  116   58   29  102   51  130   65\n 148   74   37  126   63  160   80   40   20   10\n   5  106   53  156   78   39  146   73  182   91\n 204  102   51  178   89  220  110   55  192   96\n  48   24   12    6    3  142   71  220  110   55\n\n       1,000th member is:           990 with prime:       2,273\n      10,000th member is:        24,975 with prime:      30,713\n     100,000th member is:       265,781 with prime:     392,111\n   1,000,000th member is:     8,820,834 with prime:   4,761,697\n  10,000,000th member is:    41,369,713 with prime:  55,900,829\n 100,000,000th member is: 1,179,614,168 with prime: 640,692,323\n\nNumbers under 250 that do not occur in the first 100,000,000 terms:\n36 72 97 107 115 127 144 167 194 211 214 230 232\n\nNumbers under 250 that occur the most (7 times) in the first 100,000,000 terms:\n7 14 28\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program that does the following in this order:\n\n* Input an amount of time to sleep in whatever units are most natural for your language (milliseconds, seconds, ticks, etc.). This unit should be noted in comments or in a description.\n* Print \"Sleeping...\"\n* Sleep the main thread for the given amount of time.\n* Print \"Awake!\"\n* End.\n\nRelated task\n\n* Nautical bell"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe sleep function argument is in units of seconds, but these may be fractional (to the limits of your system's clock).\n\n```\nmy $sec = prompt(\"Sleep for how many microfortnights? \") * 1.2096;\nsay \"Sleeping...\";\nsleep $sec;\nsay \"Awake!\";\n\n```\n\nNote that 1.2096 is a rational number in Raku, not floating point, so precision can be maintained even when dealing with very small powers of ten."}]}
{"messages": [{"role": "user", "content": "Background on the task\n\nIn decision theory, The Sleeping Beauty Problem\nis a problem invented by Arnold Zoboff and first publicized on Usenet. The experimental\nsubject, named Sleeping Beauty, agrees to an experiment as follows:\nSleeping Beauty volunteers to be put into a deep sleep on a Sunday. There is then a fair coin toss.\nIf this coin toss comes up heads, Sleeping Beauty wakes once (on Monday) and is asked to\nestimate the probability that the coin toss was heads. Her estimate is recorded and she is\nthen put back to sleep for 2 days until Wednesday, at which time the experiment's results are tallied.\n\nIf instead the coin toss is tails, Sleeping Beauty wakes as before on Monday and asked to\nestimate the probability the coin toss was heads, but is then given a drug which makes her forget\nthat she had been woken on Monday before being put back to sleep again. She then wakes only 1 day\nlater, on Tuesday. She is then asked (on Tuesday) again to guess the probability that the coin toss\nwas heads or tails. She is then put back to sleep and awakes as before 1 day later, on Wednesday.\n\nSome decision makers have argued that since the coin toss was fair Sleeping Beauty should always\nestimate the probability of heads as 1/2, since she does not have any additional information. Others\nhave disagreed, saying that if Sleeping Beauty knows the study design she also knows that she is twice\nas likely to wake up and be asked to estimate the coin flip on tails than on heads, so the estimate\nshould be 1/3 heads.\n\nTask\n\nGiven the above problem, create a Monte Carlo estimate of the actual results. The program should find the\nproportion of heads on waking and asking Sleeping Beauty for an estimate, as a credence or as a percentage of the times Sleeping Beauty\nis asked the question."}, {"role": "assistant", "content": "```\nsub sleeping-beauty ($trials) {\n    my $gotheadsonwaking = 0;\n    my $wakenings = 0;\n    ^$trials .map: {\n        given <Heads Tails>.roll {\n            ++$wakenings;\n            when 'Heads' { ++$gotheadsonwaking }\n            when 'Tails' { ++$wakenings }\n        }\n    }\n    say \"Wakenings over $trials experiments: \", $wakenings;\n    $gotheadsonwaking / $wakenings\n}\n\nsay \"Results of experiment:  Sleeping Beauty should estimate a credence of: \", sleeping-beauty(1_000_000);\n\n```\n\nOutput:\n\n```\nWakenings over 1000000 experiments: 1500040\nResults of experiment:  Sleeping Beauty should estimate a credence of: 0.333298\n```"}]}
{"messages": [{"role": "user", "content": "The **smallest enclosing circle problem** (aka **minimum covering circle problem**, **bounding circle problem**) is a mathematical problem of computing the smallest circle that contains all of a given set of points in the Euclidean plane.\n\nInitially it was proposed by the English mathematician James Joseph Sylvester in 1857.\n\nTask\n\nFind circle of smallest radius containing all of given points.\n\n* Circle is defined by it's center and radius;\n* Points are defined by their coordinates in n-dimensional space;\n* Circle (sphere) contains point when *distance between point and circle center <= circle radius*."}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\nclass P { has ($.x, $.y) is rw;                # Point\n   method gist { \"({$.x~\", \"~$.y})\" }\n}\n\nclass C { has (P $.c, Numeric $.r);            # Circle\n   method gist { \"Center = \" ~$.c.gist ~ \" and Radius = $.r\\n\" }\n\n   # tests whether a circle contains the point 'p'\n   method contains(P \\p --> Bool) { distSq($.c, p) ≤ $.r² }\n\n   # tests whether a circle contains a slice of point\n   method encloses(@ps --> Bool) { [and] @ps.map: { $.contains($_) } } \n}\n\nsub infix:<−> (P \\a, P \\b) { a.x - b.x, a.y - b.y } # note: Unicode 'minus'\n\n# returns the square of the distance between two points\nsub distSq (P \\a, P \\b) { [+] (a − b)»² }\n\nsub getCenter (\\bx, \\by, \\cx, \\cy --> P) {\n   my (\\b,\\c,\\d) = bx²+by², cx²+cy², bx*cy - by*cx;\n   P.new: x => (cy*b - by*c) / (2 * d), y => (bx*c - cx*b) / (2 * d)\n} # returns the center of a circle defined by 3 points\n\nsub circleFrom3 (P \\a, P \\b, P \\c --> C)  {\n   my \\k = $ = getCenter |(b − a), |(c − a);\n   k.x, k.y Z[+=] a.x, a.y;\n   C.new: c => k, r => distSq(k, a).sqrt\n} # returns a unique circle that intersects 3 points\n\nsub circleFrom2 (P \\a, P \\b --> C ) {\n   my \\center = P.new: x => ((a.x + b.x) / 2), y => ((a.y + b.y) / 2) ;\n   C.new: c => center, r => (distSq(a, b).sqrt / 2)\n} # returns smallest circle that intersects 2 points\n\nsub secTrivial( @rs --> C ) {\n   given @rs {\n      when * == 0 { return C.new: c => (P.new: x => 0, y => 0), r => 0 }\n      when * == 1 { return C.new: c => @rs[0], r => 0 }\n      when * == 2 { return circleFrom2 |@rs }\n      when * == 3 { #`{ no-op } }\n      when *  > 3 { die \"There shouldn't be more than 3 points.\" }\n   }\n   for 0, 1 X 1, 2 -> ( \\i, \\j ) {\n      return $_ if .encloses(@rs) given circleFrom2 |@rs[i,j]\n   }\n   circleFrom3 |@rs\n} # returns smallest enclosing circle for n ≤ 3\n\nsub Welzl-helper( @ps is copy, @rs is copy , \\n --> C ) {\n   return secTrivial(@rs) if n == 0 or @rs == 3;\n   my \\p = @ps.shift;\n   return $_ if .contains(p) given Welzl-helper @ps, @rs, n-1;\n   Welzl-helper @ps, @rs.append(p), n-1\n} # helper function for Welzl method\n\n# applies the Welzl algorithm to find the SEC\nsub welzl(@ps --> C) { Welzl-helper @ps.pick(*), [], @ps }\n\nmy @tests = (\n   [ (0,0), (0,1), (1,0) ],\n   [ (5,-2), (-3,-2), (-2,5), (1,6), (0,2) ]\n).map: {\n   @_.map: { P.new: x => $_[0], y => $_[1] }\n}\n\nsay \"Solution for smallest circle enclosing {$_.gist} :\\n\", welzl $_ for @tests;\n\n```\n\nOutput:\n\n```\nSolution for smallest circle enclosing ((0, 0) (0, 1) (1, 0)) :\nCenter = (0.5, 0.5) and Radius = 0.7071067811865476\n\nSolution for smallest circle enclosing ((5, -2) (-3, -2) (-2, 5) (1, 6) (0, 2)) :\nCenter = (1, 1) and Radius = 5\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nTask description is taken from Project Euler\n  \n(https://projecteuler.net/problem=5)\n  \n2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.\n  \nWhat is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?\n\nRelated\n\n* Least common multiple"}, {"role": "assistant", "content": "Exercise with some larger values as well.\n\n```\nsay \"$_: \", [lcm] 2..$_ for <10 20 200 2000>\n\n```\n\nOutput:\n\n```\n10: 2520\n20: 232792560\n200: 337293588832926264639465766794841407432394382785157234228847021917234018060677390066992000\n2000: 151117794877444315307536308337572822173736308853579339903227904473000476322347234655122160866668946941993951014270933512030194957221371956828843521568082173786251242333157830450435623211664308500316844478617809101158220672108895053508829266120497031742749376045929890296052805527212315382805219353316270742572401962035464878235703759464796806075131056520079836955770415021318508272982103736658633390411347759000563271226062182345964184167346918225243856348794013355418404695826256911622054015423611375261945905974225257659010379414787547681984112941581325198396634685659217861208771400322507388161967513719166366839894214040787733471287845629833993885413462225294548785581641804620417256563685280586511301918399010451347815776570842790738545306707750937624267501103840324470083425714138183905657667736579430274197734179172691637931540695631396056193786415805463680000\n```"}]}
{"messages": [{"role": "user", "content": "Generate the sequence of numbers **a(k)**, where each **k** is the smallest positive integer such that **k + 2m** is composite for every positive integer **m** less than **k**.\n\nFor example\n\nSuppose k == 7; test m == 1 through m == 6. If any are prime, the test fails.\n\nIs 7 + 21 (9) prime? False\n\nIs 7 + 22 (11) prime? True\n\nSo 7 is not an element of this sequence.\n\nIt is only necessary to test odd natural numbers k. An even number, plus any positive integer power of 2 is always composite.\n\nTask\n\nFind and display, here on this page, the first **5** elements of this sequence.\n\nSee also\n\nOEIS:A033919 - Odd k for which k+2^m is composite for all m < k"}, {"role": "assistant", "content": "```\nput (1..∞).hyper(:250batch).map(* × 2 + 1).grep( -> $k { !(1 ..^ $k).first: ($k + 1 +< *).is-prime } )[^5]\n\n```\n\nOutput:\n\n```\n773 2131 2491 4471 5101\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSmallest positive integer   **k**   such that the decimal expansion of   **kk**   contains   **n**,   where   **n  <  51**"}, {"role": "assistant", "content": "```\nsub smallest ( $n ) {\n    state  @powers = '', |map { $_ ** $_ }, 1 .. *;\n\n    return @powers.first: :k, *.contains($n);\n}\n\n.say for (^51).map(&smallest).batch(10)».fmt('%2d');\n\n```\n\nOutput:\n\n```\n( 9  1  3  5  2  4  4  3  7  9)\n(10 11  5 19 22 26  8 17 16 19)\n( 9  8 13  7 17  4 17  3 11 18)\n(13  5 23 17 18  7 17 15  9 18)\n(16 17  9  7 12 28  6 23  9 24)\n(23)\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow the smallest (non-negative integer) power of   **6**   whose decimal expansion contains   **n,**     where   **n   <   22**"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\n\nmy @po6 = ^Inf .map: *.exp: 6;\n\nput join \"\\n\", (flat ^22, 120).map: -> $n {\n    sprintf \"%3d: 6%-4s %s\", $n, .&super, comma @po6[$_]\n    given @po6.first: *.contains($n), :k\n};\n\n```\n\nOutput:\n\n```\n  0: 6⁹    10,077,696\n  1: 6⁰    1\n  2: 6³    216\n  3: 6²    36\n  4: 6⁶    46,656\n  5: 6⁶    46,656\n  6: 6¹    6\n  7: 6⁵    7,776\n  8: 6¹²   2,176,782,336\n  9: 6⁴    1,296\n 10: 6⁹    10,077,696\n 11: 6¹⁶   2,821,109,907,456\n 12: 6⁴    1,296\n 13: 6¹³   13,060,694,016\n 14: 6²⁸   6,140,942,214,464,815,497,216\n 15: 6¹⁸   101,559,956,668,416\n 16: 6³    216\n 17: 6¹⁰   60,466,176\n 18: 6¹⁵   470,184,984,576\n 19: 6²¹   21,936,950,640,377,856\n 20: 6²⁶   170,581,728,179,578,208,256\n 21: 6³    216\n120: 6¹⁴⁷  2,444,746,349,972,956,194,083,608,044,935,243,159,422,957,210,683,702,349,648,543,934,214,737,968,217,920,868,940,091,707,112,078,529,114,392,164,827,136\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind the smallest  (decimal integer)  squares that begin with      **n**      for    0 < **n** < 50"}, {"role": "assistant", "content": "```\n# 20210319 Raku programming solution\n\nmy @needles  = (1..49);\nmy @haystack = (1..*) Z× (1..*);\n# my @haystack = ( 1, 4, -> \\a, \\b { 2*b - a + 2 } ... * );\n# my @haystack = ( 1, { (++$)² } ... * );\nfor @needles -> \\needle {\n   for @haystack -> \\hay {\n      { say needle, \" => \", hay and last } if hay.starts-with: needle\n   }\n}\n\n```\n\nOutput:\n\n```\n1 => 1\n2 => 25\n3 => 36\n4 => 4\n5 => 529\n6 => 64\n7 => 729\n8 => 81\n9 => 9\n10 => 100\n11 => 1156\n12 => 121\n13 => 1369\n14 => 144\n15 => 1521\n16 => 16\n17 => 1764\n18 => 1849\n19 => 196\n20 => 2025\n21 => 2116\n22 => 225\n23 => 2304\n24 => 2401\n25 => 25\n26 => 2601\n27 => 2704\n28 => 289\n29 => 2916\n30 => 3025\n31 => 3136\n32 => 324\n33 => 3364\n34 => 3481\n35 => 35344\n36 => 36\n37 => 3721\n38 => 3844\n39 => 3969\n40 => 400\n41 => 41209\n42 => 4225\n43 => 4356\n44 => 441\n45 => 45369\n46 => 4624\n47 => 4761\n48 => 484\n49 => 49\n\n```\n\nAs the desired range is so small, there is not much gained by caching the squares. Less efficient, but less verbose:\n\n```\nsay $_ => ^Inf .map(*²).first: *.starts-with: $_ for 1..49;\n\n```\n\nSame output."}]}
{"messages": [{"role": "user", "content": "The Smarandache prime-digital sequence (SPDS for brevity) is the sequence of primes whose digits are themselves prime.\n\nFor example 257 is an element of this sequence because it is prime itself and its digits: 2, 5 and 7 are also prime.\n\nTask\n\n* Show the first 25 SPDS primes.\n* Show the hundredth SPDS prime.\n\nSee also\n\n* OEIS A019546: Primes whose digits are primes.\n* https://www.scribd.com/document/214851583/On-the-Smarandache-prime-digital-subsequence-sequences"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Library:** ntheory\n\n```\nuse Lingua::EN::Numbers;\nuse ntheory:from<Perl5> <:all>;\n\n# Implemented as a lazy, extendable list\nmy $spds = grep { .&is_prime }, flat [2,3,5,7], [23,27,33,37,53,57,73,77], -> $p\n  { state $o++; my $oom = 10**(1+$o); [ flat (2,3,5,7).map: -> $l { (|$p).map: $l×$oom + * } ] } … *;\n\nsay 'Smarandache prime-digitals:';\nprintf \"%22s: %s\\n\", ordinal(1+$_).tclc, comma $spds[$_] for flat ^25, 99, 999, 9999, 99999;\n\n```\n\nOutput:\n\n```\nSmarandache prime-digitals:\n                 First: 2\n                Second: 3\n                 Third: 5\n                Fourth: 7\n                 Fifth: 23\n                 Sixth: 37\n               Seventh: 53\n                Eighth: 73\n                 Ninth: 223\n                 Tenth: 227\n              Eleventh: 233\n               Twelfth: 257\n            Thirteenth: 277\n            Fourteenth: 337\n             Fifteenth: 353\n             Sixteenth: 373\n           Seventeenth: 523\n            Eighteenth: 557\n            Nineteenth: 577\n             Twentieth: 727\n          Twenty-first: 733\n         Twenty-second: 757\n          Twenty-third: 773\n         Twenty-fourth: 2,237\n          Twenty-fifth: 2,273\n         One hundredth: 33,223\n        One thousandth: 3,273,527\n        Ten thousandth: 273,322,727\nOne hundred thousandth: 23,325,232,253\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nA **Smarandache-Wellin number** (S-W number for short) is an integer that in a given base is the concatenation of the first n prime numbers written in that base. A base of 10 will be assumed for this task.\n\nA **Derived S-W number** (not an 'official' term) is an integer formed from a S-W number by working out the number of times each of the digits 0 to 9 occurs in that number, concatenating those frequencies in the same order (i.e. frequency of '0' first, frequency of '1' second etc) and removing any leading zeros.\n\nExamples\n\n'23571113' is the sixth S-W number formed by concatenating the first 6 primes: 2, 3, 5, 7, 11 and 13.\n\nThe corresponding Derived S-W number is '312010100' because '1' occurs 3 times, '3' occurs twice and '2', '5' and '7' all occur once.\n\nTask\n\n* Find and show the first three S-W numbers which are prime.\n\n* Find and show the first three Derived S-W numbers which are prime.\n\nStretch (requires 'big integer' support)\n\nFind and show the index in the sequence (starting from 1), the total number of digits and the last prime used to form the fourth, fifth, sixth, seventh and (optionally) the eighth S-W numbers which are prime or probably prime with reasonable certainty. It is unknown whether there are any more but, if you fancy searching for one, good luck! You can start from an index of 22,077.\n\nAlso find and show up to the first twenty Derived S-W numbers which are prime and their index in the sequence.\n\nReferences\n\n* Wikipedia: Smarandache-Wellin number\n* OEIS:A019518 - Smarandache-Wellin numbers\n* OEIS:A069151 - Smarandache-Wellin primes"}, {"role": "assistant", "content": "The first seven Smarandache-Wellin primes are found in a few seconds on my system. The eighth adds over five minutes to the run time.\n\n```\nuse Lingua::EN::Numbers;\n\nmy @primes = (^∞).grep: &is-prime;\n\nmy @Smarandache-Wellin = [\\~] @primes;\n\nsink @Smarandache-Wellin[1500]; # pre-reify for concurrency\n\nsub derived ($n) { my %digits = $n.comb.Bag; (0..9).map({ %digits{$_} // 0 }).join }\n\nsub abbr ($_) { .chars < 41 ?? $_ !! .substr(0,20) ~ '…' ~ .substr(*-20) ~ \" ({.chars} digits)\" }\n\nsay \"Smarandache-Wellin primes:\";\nsay ordinal-digit(++$,:u).fmt(\"%4s\") ~ $_ for (^∞).hyper(:4batch).map({\n    next unless (my $sw = @Smarandache-Wellin[$_]).is-prime;\n    sprintf \": Index: %4d, Last prime: %5d, %s\", $_, @primes[$_], $sw.&abbr\n})[^8];\n\nsay \"\\nSmarandache-Wellin derived primes:\";\nsay ordinal-digit(++$,:u).fmt(\"%4s\") ~ $_ for (^∞).hyper(:8batch).map({\n    next unless (my $sw = @Smarandache-Wellin[$_].&derived).is-prime;\n    sprintf \": Index: %4d, %s\", $_, $sw\n})[^20];\n\n```\n\nOutput:\n\n```\nSmarandache-Wellin primes:\n 1ˢᵗ: Index:    0, Last prime:     2, 2\n 2ⁿᵈ: Index:    1, Last prime:     3, 23\n 3ʳᵈ: Index:    3, Last prime:     7, 2357\n 4ᵗʰ: Index:  127, Last prime:   719, 23571113171923293137…73677683691701709719 (355 digits)\n 5ᵗʰ: Index:  173, Last prime:  1033, 23571113171923293137…10131019102110311033 (499 digits)\n 6ᵗʰ: Index:  341, Last prime:  2297, 23571113171923293137…22732281228722932297 (1171 digits)\n 7ᵗʰ: Index:  434, Last prime:  3037, 23571113171923293137…30013011301930233037 (1543 digits)\n 8ᵗʰ: Index: 1428, Last prime: 11927, 23571113171923293137…11903119091192311927 (5719 digits)\n\nSmarandache-Wellin derived primes:\n 1ˢᵗ: Index:   31, 4194123321127\n 2ⁿᵈ: Index:   71, 547233879626521\n 3ʳᵈ: Index:   72, 547233979727521\n 4ᵗʰ: Index:  133, 13672766322929571043\n 5ᵗʰ: Index:  224, 3916856106393739943689\n 6ᵗʰ: Index:  302, 462696313560586013558131\n 7ᵗʰ: Index:  308, 532727113760586013758133\n 8ᵗʰ: Index:  362, 6430314317473636515467149\n 9ᵗʰ: Index:  461, 8734722823685889120488197\n10ᵗʰ: Index:  489, 9035923128899919621189209\n11ᵗʰ: Index:  494, 9036023329699969621389211\n12ᵗʰ: Index:  521, 9337023533410210710923191219\n13ᵗʰ: Index:  537, 94374237357103109113243102223\n14ᵗʰ: Index:  623, 117416265406198131121272110263\n15ᵗʰ: Index:  720, 141459282456260193137317129313\n16ᵗʰ: Index:  737, 144466284461264224139325131317\n17ᵗʰ: Index:  789, 156483290479273277162351153339\n18ᵗʰ: Index:  851, 164518312512286294233375158359\n19ᵗʰ: Index: 1086, 208614364610327343341589284471\n20ᵗʰ: Index: 1187, 229667386663354357356628334581\n```"}]}
{"messages": [{"role": "user", "content": "Smith numbers are numbers such that the sum of the decimal digits of the integers that make up that number is the same as the sum of the decimal digits of its prime factors excluding 1.\n\nBy definition, all primes are *excluded* as they (naturally) satisfy this condition!\n\nSmith numbers are also known as   *joke*   numbers.\n\nExample\n\nUsing the number **166**  \nFind the prime factors of **166** which are: **2** x **83**  \nThen, take those two prime factors and sum all their decimal digits: **2 + 8 + 3** which is **13**  \nThen, take the decimal digits of **166** and add their decimal digits: **1 + 6 + 6** which is **13**  \nTherefore, the number **166** is a Smith number.\n\nTask\n\nWrite a program to find all Smith numbers *below* 10000.\n\nSee also\n\n* from Wikipedia:   [Smith number].\n* from MathWorld:   [Smith number].\n* from OEIS A6753:   [OEIS sequence A6753].\n* from OEIS A104170:   [Number of Smith numbers below 10^n].\n* from The Prime pages:   [Smith numbers]."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nconstant @primes = 2, |(3, 5, 7 ... *).grep: *.is-prime;\n \nmulti factors ( 1 ) { 1 }\nmulti factors ( Int $remainder is copy ) {\n  gather for @primes -> $factor {\n \n    # if remainder < factor², we're done\n    if $factor * $factor > $remainder {\n      take $remainder if $remainder > 1;\n      last;\n    }\n \n    # How many times can we divide by this prime?\n    while $remainder %% $factor {\n        take $factor;\n        last if ($remainder div= $factor) === 1;\n    }\n  }\n}\n# Code above here is verbatim from RC:Count_in_factors#Raku\n\nsub is_smith_number ( Int $n ) {\n  (!$n.is-prime) and ( [+] $n.comb ) == ( [+] factors($n).join.comb );\n}\n\nmy @s = grep &is_smith_number, 2 ..^ 10_000;\nsay \"{@s.elems} Smith numbers below 10_000\";\nsay 'First 10: ', @s[  ^10      ];\nsay 'Last  10: ', @s[ *-10 .. * ];\n\n```\n\nOutput:\n\n```\n376 Smith numbers below 10_000\nFirst 10: (4 22 27 58 85 94 121 166 202 265)\nLast  10: (9843 9849 9861 9880 9895 9924 9942 9968 9975 9985)\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Snake\\_(video\\_game). The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nSnake is a game where the player maneuvers a line which grows in length every time the snake reaches a food source.\n\nTask\n\nImplement a variant of the Snake game, in any interactive environment, in which a sole player attempts to eat items by running into them with the head of the snake.\n\nEach item eaten makes the snake longer and a new item is randomly generated somewhere else on the plane.\n\nThe game ends when the snake attempts to eat himself."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.08\n\nThis is a variation of a demo script included in the examples folder for the Raku SDL2::Raw library bindings.\n\n```\nuse SDL2::Raw;\nuse Cairo;\n\nconstant W = 1280;\nconstant H = 960;\n\nconstant FIELDW = W div 32;\nconstant FIELDH = H div 32;\n\nSDL_Init(VIDEO);\n\nmy $window = SDL_CreateWindow(\n    'Snake',\n    SDL_WINDOWPOS_CENTERED_MASK,\n    SDL_WINDOWPOS_CENTERED_MASK,\n    W, H,\n    OPENGL\n);\n\nmy $render = SDL_CreateRenderer($window, -1, ACCELERATED +| PRESENTVSYNC);\n\nmy $snake_image = Cairo::Image.record(\n    -> $_ {\n        .save;\n        .rectangle: 0, 0, 64, 64;\n        .clip;\n        .rgb: 0, 1, 0;\n        .rectangle: 0, 0, 64, 64;\n        .fill :preserve;\n        .rgb: 0, 0, 0;\n        .stroke;\n        .restore;\n\n        .save;\n        .translate: 64, 0;\n        .rectangle: 0, 0, 64, 64;\n        .clip;\n        .rgb: 1, 0, 0;\n        .arc: 32, 32, 30, 0, 2 * pi;\n        .fill :preserve;\n        .rgb: 0, 0, 0;\n        .stroke;\n        .restore;\n    }, 128, 128, Cairo::FORMAT_ARGB32);\n\nmy $snake_texture = SDL_CreateTexture(\n    $render,\n    %PIXELFORMAT<ARGB8888>,\n    STATIC,\n    128,\n    128\n);\n\nSDL_UpdateTexture(\n    $snake_texture,\n    SDL_Rect.new(\n        :x(0),\n        :y(0),\n        :w(128),\n        :h(128)\n    ),\n    $snake_image.data,\n    $snake_image.stride // 128 * 4\n);\n\nSDL_SetTextureBlendMode($snake_texture, 1);\n\nSDL_SetRenderDrawBlendMode($render, 1);\n\nmy $snakepiece_srcrect = SDL_Rect.new(:w(64), :h(64));\nmy $nompiece_srcrect   = SDL_Rect.new(:w(64), :h(64), :x(64));\n\nmy $event = SDL_Event.new;\n\nenum GAME_KEYS (\n    K_UP    => 82,\n    K_DOWN  => 81,\n    K_LEFT  => 80,\n    K_RIGHT => 79,\n);\n\nmy Complex @snakepieces = 10+10i;\nmy Complex @noms;\nmy Complex $snakedir = 1+0i;\nmy $nomspawn   = 0;\nmy $snakespeed = 0.1;\nmy $snakestep  = 0;\nmy $nom        = 4;\n\nmy $last_frame_start = now;\nmain: loop {\n    my $start = now;\n    my $dt = $start - $last_frame_start // 0.00001;\n    while SDL_PollEvent($event) {\n        my $casted_event = SDL_CastEvent($event);\n        given $casted_event {\n            when *.type == QUIT    { last main }\n            when *.type == KEYDOWN {\n                if GAME_KEYS(.scancode) -> $comm {\n                    given $comm {\n                        when 'K_LEFT'  { $snakedir = -1+0i unless $snakedir ==  1+0i }\n                        when 'K_RIGHT' { $snakedir =  1+0i unless $snakedir == -1+0i }\n                        when 'K_UP'    { $snakedir =  0-1i unless $snakedir ==  0+1i }\n                        when 'K_DOWN'  { $snakedir =  0+1i unless $snakedir ==  0-1i }\n                    }\n                }\n            }\n        }\n    }\n\n    if ($nomspawn -= $dt) < 0 {\n        $nomspawn += 1;\n        @noms.push: (^FIELDW).pick + (^FIELDH).pick * i unless @noms > 3;\n        @noms.pop if @noms[*-1] == any(@snakepieces);\n    }\n\n    if ($snakestep -= $dt) < 0 {\n        $snakestep += $snakespeed;\n\n        @snakepieces.unshift: do given @snakepieces[0] {\n            ($_.re + $snakedir.re) % FIELDW\n            + (($_.im + $snakedir.im) % FIELDH) * i\n        }\n\n        if @snakepieces[2..*].first( * == @snakepieces[0], :k ) -> $idx {\n            @snakepieces = @snakepieces[0..($idx + 1)];\n        }\n\n        @noms .= grep(\n            { $^piece == @snakepieces[0] ?? ($nom += 1) && False !! True }\n        );\n\n        if $nom == 0 {\n            @snakepieces.pop;\n        } else {\n            $nom = $nom - 1;\n        }\n    }\n\n    for @snakepieces {\n        SDL_SetTextureColorMod(\n            $snake_texture,\n            255,\n            (cos((++$) / 2) * 100 + 155).round,\n            255\n        );\n\n        SDL_RenderCopy(\n            $render,\n            $snake_texture,\n            $snakepiece_srcrect,\n            SDL_Rect.new(.re * 32, .im * 32, 32, 32)\n        );\n    }\n\n    SDL_SetTextureColorMod($snake_texture, 255, 255, 255);\n\n    for @noms {\n        SDL_RenderCopy(\n            $render,\n            $snake_texture,\n            $nompiece_srcrect,\n            SDL_Rect.new(.re * 32, .im * 32, 32, 32)\n        )\n    }\n\n    SDL_RenderPresent($render);\n    SDL_SetRenderDrawColor($render, 0, 0, 0, 0);\n    SDL_RenderClear($render);\n\n    $last_frame_start = $start;\n    sleep(1 / 50);\n}\n\nSDL_Quit();\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a Snakes and Ladders game where the computer plays against a human player.\n\nThis game is also known as   **Chutes and Ladders**.\n\nFor a board example you can use this image here: snakes & ledders.\n\n(A **ledder** is the Old English word for a **ladder**.)\n\nThe way you'll represent the board and the players' tokens is totally up to you: graphics or ASCII graphics or even just text.\n\nHappy coding."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.01\n\nSnakes and ladders is entirely chance based, so human interaction is not really required. This version allows up to one human player against any number of computer players and asks for input... but doesn't really *need* or even *use* it. I didn't bother to implement a graphical interface.\n\n```\n        # board layout\nmy %snl =  4, 14,  9, 31, 17,  7, 20, 38, 28, 84, 40, 59, 51, 67, 54, 34,\n          62, 19, 63, 81, 64, 60, 71, 91, 87, 24, 93, 73, 95, 75, 99, 78;\n\nmy @players = 1, 1, 1; # three players, starting on square 1\nmy $human = 1;         # player 1 is human. set to 0 for all computer players\n\nloop {\n    for ^@players -> $player {\n        turn(@players[$player], $player + 1);\n    }\n    say '';\n}\n\nsub turn ($square is rw, $player) {\n    if $player == $human {\n        prompt \"You are on square $square. Hit enter to roll the die.\";\n    }\n    my $roll = (1..6).roll;\n    my $turn = $square + $roll;\n    printf \"Player $player on square %2d rolls a $roll\", $square;\n    if $turn > 100 {\n        say \" but cannot move. Next players turn.\";\n        return $square;\n    }\n    if %snl{$turn} {\n        $square = %snl{$turn};\n        if $turn > $square {\n            say \". Oops! Landed on a snake. Slither down to $square.\"\n        } else {\n            say \". Yay! Landed on a ladder. Climb up to $square.\"\n        }\n    } else {\n        $square = $turn;\n        say \" and moves to square $square\";\n    }\n    say \"Player $player wins!\" and exit if $square == 100;\n    return $square;\n}\n\n```\n\nSample output:\n\n```\nYou are on square 1. Hit enter to roll the die.\nPlayer 1 on square  1 rolls a 1 and moves to square 2\nPlayer 2 on square  1 rolls a 4 and moves to square 5\nPlayer 3 on square  1 rolls a 1 and moves to square 2\n\nYou are on square 2. Hit enter to roll the die.\nPlayer 1 on square  2 rolls a 1 and moves to square 3\nPlayer 2 on square  5 rolls a 2 and moves to square 7\nPlayer 3 on square  2 rolls a 3 and moves to square 5\n\nYou are on square 3. Hit enter to roll the die.\nPlayer 1 on square  3 rolls a 4 and moves to square 7\nPlayer 2 on square  7 rolls a 1 and moves to square 8\nPlayer 3 on square  5 rolls a 2 and moves to square 7\n\nYou are on square 7. Hit enter to roll the die.\nPlayer 1 on square  7 rolls a 2. Yay! Landed on a ladder. Climb up to 31.\nPlayer 2 on square  8 rolls a 3 and moves to square 11\nPlayer 3 on square  7 rolls a 2. Yay! Landed on a ladder. Climb up to 31.\n\n  ... about 15 turns omitted ...\n\nYou are on square 90. Hit enter to roll the die.\nPlayer 1 on square 90 rolls a 3. Oops! Landed on a snake. Slither down to 73.\nPlayer 2 on square 55 rolls a 3 and moves to square 58\nPlayer 3 on square 90 rolls a 4 and moves to square 94\n\nYou are on square 73. Hit enter to roll the die.\nPlayer 1 on square 73 rolls a 6 and moves to square 79\nPlayer 2 on square 58 rolls a 5. Yay! Landed on a ladder. Climb up to 81.\nPlayer 3 on square 94 rolls a 3 and moves to square 97\n\nYou are on square 79. Hit enter to roll the die.\nPlayer 1 on square 79 rolls a 3 and moves to square 82\nPlayer 2 on square 81 rolls a 6. Oops! Landed on a snake. Slither down to 24.\nPlayer 3 on square 97 rolls a 5 but cannot move. Next players turn.\n\nYou are on square 82. Hit enter to roll the die.\nPlayer 1 on square 82 rolls a 5. Oops! Landed on a snake. Slither down to 24.\nPlayer 2 on square 24 rolls a 6 and moves to square 30\nPlayer 3 on square 97 rolls a 4 but cannot move. Next players turn.\n\nYou are on square 24. Hit enter to roll the die.\nPlayer 1 on square 24 rolls a 4. Yay! Landed on a ladder. Climb up to 84.\nPlayer 2 on square 30 rolls a 5 and moves to square 35\nPlayer 3 on square 97 rolls a 4 but cannot move. Next players turn.\n\nYou are on square 84. Hit enter to roll the die.\nPlayer 1 on square 84 rolls a 1 and moves to square 85\nPlayer 2 on square 35 rolls a 2 and moves to square 37\nPlayer 3 on square 97 rolls a 3 and moves to square 100\nPlayer 3 wins!\n```"}]}
{"messages": [{"role": "user", "content": "In this task, the goal is to create a SOAP client which accesses functions defined at **http://example.com/soap/wsdl**, and calls the functions **soapFunc( )** and **anotherSoapFunc( )**.\n\nThis task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# Reference:\n# https://github.com/retupmoca/P6-SOAP\n# http://wiki.dreamfactory.com/DreamFactory/Tutorials/Temp_Conversion_SOAP_API\n\nuse v6;\nuse SOAP::Client;\n\nmy $request = SOAP::Client.new('http://www.w3schools.com/xml/tempconvert.asmx?WSDL') or die;\n\nsay $request.call('CelsiusToFahrenheit', Celsius => 100 ) or die;\n\nsay $request.call('FahrenheitToCelsius', Fahrenheit => 212 ) or die;\n\n```\n\nOutput:\n\n```\n{CelsiusToFahrenheitResult => [212]}\n{FahrenheitToCelsiusResult => [100]}\n\n```"}]}
{"messages": [{"role": "user", "content": "For this exercise a program is open a socket to localhost on port 256 and send the message \"hello socket world\" before closing the socket.\n\nCatching any exceptions or errors is not required."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.03\n\nWill fail with a connect error if there is not a socket server of some kind available on the specified host and port.\n\n```\nmy $host = '127.0.0.1';\nmy $port = 256;\n\nmy $client = IO::Socket::INET.new(:$host, :$port);\n$client.print( 'hello socket world' );\n$client.close;\n\n```"}]}
{"messages": [{"role": "user", "content": "Demonstrate how to find a solution to a given Sokoban level. For the purpose of this task (formally, a PSPACE-complete problem) any method may be used. However a move-optimal or push-optimal (or any other -optimal) solutions is preferred.\n\nSokoban levels are usually stored as a character array where\n\n* *space* is an empty square\n* # is a wall\n* @ is the player\n* $ is a box\n* . is a goal\n* + is the player on a goal\n* \\* is a box on a goal\n\n```\n#######\n#     #\n#     #\n#. #  #\n#. $$ #\n#.$$  #\n#.#  @#\n#######\n\n```\n\nSokoban solutions are usually stored in the LURD format, where lowercase l, u, r and d represent a move in that (**l**eft, **u**p, **r**ight, **d**own) direction and capital LURD represents a push.\n\nPlease state if you use some other format for either the input or output, and why.\n\nFor more information, see the Sokoban wiki."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Go\n\n```\nsub MAIN() {\n    my $level = q:to//;\n#######\n#     #\n#     #\n#. #  #\n#. $$ #\n#.$$  #\n#.#  @#\n#######\n\n    say 'level:';\n    print $level;\n    say 'solution:';\n    say solve($level);\n}   \n \nclass State {\n    has Str $.board;\n    has Str $.sol;\n    has Int $.pos;\n\n    method move(Int $delta --> Str) {\n        my $new = $!board;\n        if $new.substr($!pos,1) eq '@' {\n            substr-rw($new,$!pos,1) = ' ';\n        } else {\n            substr-rw($new,$!pos,1) = '.';\n        }\n        my $pos := $!pos + $delta;\n        if $new.substr($pos,1) eq ' ' {\n            substr-rw($new,$pos,1) = '@';\n        } else {\n            substr-rw($new,$pos,1) = '+';\n        }\n        return $new;\n    }\n     \n    method push(Int $delta --> Str) {\n        my $pos := $!pos + $delta;\n        my $box := $pos + $delta;\n        return '' unless $!board.substr($box,1) eq ' ' | '.';\n        my $new = $!board;\n        if $new.substr($!pos,1) eq '@' {\n            substr-rw($new,$!pos,1) = ' ';\n        } else {\n            substr-rw($new,$!pos,1) = '.';\n        }\n        if $new.substr($pos,1) eq '$' {\n            substr-rw($new,$pos,1) = '@';\n        } else {\n            substr-rw($new,$pos,1) = '+';\n        }\n        if $new.substr($box,1) eq ' ' {\n            substr-rw($new,$box,1) = '$';\n        } else {\n            substr-rw($new,$box,1) = '*';\n        }\n        return $new;\n    }\n}\n \nsub solve(Str $start --> Str) {\n    my $board = $start;\n    my $width = $board.lines[0].chars + 1;\n    my @dirs =\n        [\"u\", \"U\", -$width],\n        [\"r\", \"R\", 1],\n        [\"d\", \"D\", $width],\n        [\"l\", \"L\", -1];\n\n    my %visited = $board => True;\n\n    my $pos = $board.index('@');\n    my @open = State.new(:$board, :sol(''), :$pos);\n    while @open {\n        my $state = @open.shift;\n        for @dirs -> [$move, $push, $delta] {\n            my $board;\n            my $sol;\n            my $pos = $state.pos + $delta;\n            given $state.board.substr($pos,1) {\n                when '$' | '*' {\n                    $board = $state.push($delta);\n                    next if $board eq \"\" || %visited{$board};\n                    $sol = $state.sol ~ $push;\n                    return $sol unless $board ~~ /<[ . + ]>/;\n                }\n                when ' ' | '.' {\n                    $board = $state.move($delta);\n                    next if %visited{$board};\n                    $sol = $state.sol ~ $move;\n                }\n                default { next }\n            }\n            @open.push: State.new: :$board, :$sol, :$pos;\n            %visited{$board} = True;\n        }\n    }\n    return \"No solution\";\n}\n\n```\n\nOutput:\n\n```\nLevel:\n#######\n#     #\n#     #\n#. #  #\n#. $$ #\n#.$$  #\n#.#  @#\n#######\nSolution:\nulULLulDDurrrddlULrruLLrrUruLLLulD\n```"}]}
{"messages": [{"role": "user", "content": "Soloway's Recurring Rainfall is commonly used to assess general programming knowledge by requiring basic program structure, input/output, and program exit procedure.\n\n**The problem:**\n\nWrite a program that will read in integers and output their average. Stop reading when the value 99999 is input.\n\nFor languages that aren't traditionally interactive, the program can read in values as makes sense and stopping once 99999 is encountered. The classic rainfall problem comes from identifying success of Computer Science programs with their students, so the original problem statement is written above -- though it may not strictly apply to a given language in the modern era.\n\n**Implementation Details:**\n\n* Only Integers are to be accepted as input\n* Output should be floating point\n* Rainfall can be negative (https://www.geographyrealm.com/what-is-negative-rainfall/)\n* For languages where the user is inputting data, the number of data inputs can be \"infinite\"\n* A complete implementation should handle error cases reasonably (asking the user for more input, skipping the bad value when encountered, etc)\n\nThe purpose of this problem, as originally proposed in the 1980's through its continued use today, is to just show fundamentals of CS: iteration, branching, program structure, termination, management of data types, input/output (where applicable), etc with things like input validation or management of numerical limits being more \"advanced\". It isn't meant to literally be a rainfall calculator so implementations should strive to implement the solution clearly and simply.\n\n**References:**\n\n* http://cs.brown.edu/~kfisler/Pubs/icer14-rainfall/icer14.pdf\n* https://www.curriculumonline.ie/getmedia/8bb01bff-509e-48ed-991e-3ab5dad74a78/Seppletal-2015-DoweknowhowdifficulttheRainfallProblemis.pdf\n* https://en.wikipedia.org/wiki/Moving\\_average#Cumulative\\_average"}, {"role": "assistant", "content": "This task seems to be more about following (kind of vague) instructions and anticipating error conditions rather than solving a rather simple problem.\n\nI notice that units are specified for neither measurement; time nor rainfall accumulation. Time is assumed to always increment in units of one, rainfall in some non-negative integer. \"Integer\" gets a little leeway in this entry. Floating point numbers or Rational numbers that are exactly equal to an Integer are allowed, even if they are technically not integers.\n\n#### After update to spec:\n\nNot going to bother to allow negative rainfall amounts. The \"Negative rainfall\" cited in the linked article references \"total accumulated groundwater\" **NOT** precipitation. Evaporation isn't rainfall. Much like dew or fog is not rainfall.\n\n**Further**, the linked reference article for Soloway's Recurring Rainfall ***SPECIFICALLY*** discusses marking an implementation as incorrect, or at least lacking, if it doesn't ignore and discard negative entries. You can't have it both ways.\n\n```\n# Write a program that will read in integers and\n# output their average. Stop reading when the\n# value 99999 is input.\n\n\nmy ($periods, $accumulation, $rainfall) = 0, 0;\n\nloop {\n    loop {\n        $rainfall = prompt 'Integer units of rainfall in this time period? (999999 to finalize and exit)>: ';\n        last if $rainfall.chars and $rainfall.Numeric !~~ Failure and $rainfall.narrow ~~ Int and $rainfall ≥ 0;\n        say 'Invalid input, try again.';\n    }\n    last if $rainfall == 999999;\n    ++$periods;\n    $accumulation += $rainfall;\n    say-it;\n}\n\nsay-it;\n\nsub say-it { printf \"Average rainfall %.2f units over %d time periods.\\n\", ($accumulation / $periods) || 0, $periods }\n\n```\n\nOutput:\n\n```\n# Normal operation\nInteger units of rainfall in this time period? (999999 to finalize and exit)>: 0\nAverage rainfall 0.00 units over 1 time periods.\nInteger units of rainfall in this time period? (999999 to finalize and exit)>: 2\nAverage rainfall 1.00 units over 2 time periods.\nInteger units of rainfall in this time period? (999999 to finalize and exit)>: 4\nAverage rainfall 2.00 units over 3 time periods.\nInteger units of rainfall in this time period? (999999 to finalize and exit)>: 6\nAverage rainfall 3.00 units over 4 time periods.\nInteger units of rainfall in this time period? (999999 to finalize and exit)>: 8\nAverage rainfall 4.00 units over 5 time periods.\nInteger units of rainfall in this time period? (999999 to finalize and exit)>: 999999\nAverage rainfall 4.00 units over 5 time periods.\n\n\n# Invalid entries and valid but not traditional \"Integer\" entries demonstrated  \nInteger units of rainfall in this time period? (999999 to finalize and exit)>: a\nInvalid input, try again.\nInteger units of rainfall in this time period? (999999 to finalize and exit)>: 1.1\nInvalid input, try again.\nInteger units of rainfall in this time period? (999999 to finalize and exit)>:\nInvalid input, try again.\nInteger units of rainfall in this time period? (999999 to finalize and exit)>: 2.0\nAverage rainfall 2.00 units over 1 time periods.\nInteger units of rainfall in this time period? (999999 to finalize and exit)>: .3e1\nAverage rainfall 2.50 units over 2 time periods.\nInteger units of rainfall in this time period? (999999 to finalize and exit)>: 999999\nAverage rainfall 2.50 units over 2 time periods.\n\n\n# Valid summary with no entries demonstrated.\nInteger units of rainfall in this time period? (999999 to finalize and exit)>: 999999\nAverage rainfall 0.00 units over 0 time periods.\n```"}]}
{"messages": [{"role": "user", "content": "The task is to write a program which solves Hidato (aka Hidoku) puzzles.\n\nThe rules are:\n\n* You are given a grid with some numbers placed in it. The other squares in the grid will be blank.\n  + The grid is not necessarily rectangular.\n  + The grid may have holes in it.\n  + The grid is always connected.\n  + The number “1” is always present, as is another number that is equal to the number of squares in the grid. Other numbers are present so as to force the solution to be unique.\n  + It may be assumed that the difference between numbers present on the grid is not greater than lucky 13.\n* The aim is to place a natural number in each blank square so that in the sequence of numbered squares from “1” upwards, each square is in the wp:Moore neighborhood of the squares immediately before and after it in the sequence (except for the first and last squares, of course, which only have one-sided constraints).\n  + Thus, if the grid was overlaid on a chessboard, a king would be able to make legal moves along the path from first to last square in numerical order.\n  + A square may only contain one number.\n* In a proper Hidato puzzle, the solution is unique.\n\nFor example the following problem\n\nSample Hidato problem, from Wikipedia\n\nhas the following solution, with path marked on it:\n\nSolution to sample Hidato problem\n\nRelated tasks\n\n* A\\* search algorithm\n* N-queens problem\n* Solve a Holy Knight's tour\n* Knight's tour\n* Solve a Hopido puzzle\n* Solve a Numbrix puzzle\n* Solve the no connection puzzle;"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis uses a Warnsdorff solver, which cuts down the number of tries by more than a factor of six over the brute force approach. This same solver is used in:\n\n* Solve a Hidato puzzle\n* Solve a Hopido puzzle\n* Solve a Holy Knight's tour\n* Solve a Numbrix puzzle\n* Solve the no connection puzzle\n\n```\nmy @adjacent = [-1, -1], [-1, 0], [-1, 1],\n               [ 0, -1],          [ 0, 1],\n               [ 1, -1], [ 1, 0], [ 1, 1];\n\nsolveboard q:to/END/;\n        __ 33 35 __ __ .. .. ..\n        __ __ 24 22 __ .. .. ..\n        __ __ __ 21 __ __ .. ..\n        __ 26 __ 13 40 11 .. ..\n        27 __ __ __  9 __  1 ..\n        .. .. __ __ 18 __ __ ..\n        .. .. .. .. __  7 __ __\n        .. .. .. .. .. ..  5 __\n        END\n \nsub solveboard($board) {\n    my $max = +$board.comb(/\\w+/);\n    my $width = $max.chars;\n\n    my @grid;\n    my @known;\n    my @neigh;\n    my @degree;\n \n    @grid = $board.lines.map: -> $line {\n        [ $line.words.map: { /^_/ ?? 0 !! /^\\./ ?? Rat !! $_ } ]\n    }\n \n    sub neighbors($y,$x --> List) {\n        eager gather for @adjacent {\n            my $y1 = $y + .[0];\n            my $x1 = $x + .[1];\n            take [$y1,$x1] if defined @grid[$y1][$x1];\n        }\n    }\n\n    for ^@grid -> $y {\n        for ^@grid[$y] -> $x {\n            if @grid[$y][$x] -> $v {\n                @known[$v] = [$y,$x];\n            }\n            if @grid[$y][$x].defined {\n                @neigh[$y][$x] = neighbors($y,$x);\n                @degree[$y][$x] = +@neigh[$y][$x];\n            }\n        }\n    }\n    print \"\\e[0H\\e[0J\";\n\n    my $tries = 0;\n\n    try_fill 1, @known[1];\n\n    sub try_fill($v, $coord [$y,$x] --> Bool) {\n        return True if $v > $max;\n        $tries++;\n\n        my $old = @grid[$y][$x];\n\n        return False if +$old and $old != $v;\n        return False if @known[$v] and @known[$v] !eqv $coord;\n\n        @grid[$y][$x] = $v;               # conjecture grid value\n\n        print \"\\e[0H\";                    # show conjectured board\n        for @grid -> $r {\n            say do for @$r {\n                when Rat { ' ' x $width }\n                when 0   { '_' x $width }\n                default  { .fmt(\"%{$width}d\") }\n            }\n        }\n\n\n        my @neighbors = @neigh[$y][$x][];\n\n        my @degrees;\n        for @neighbors -> \\n [$yy,$xx] {\n            my $d = --@degree[$yy][$xx];  # conjecture new degrees\n            push @degrees[$d], n;         # and categorize by degree\n        }\n\n        for @degrees.grep(*.defined) -> @ties {\n            for @ties.reverse {           # reverse works better for this hidato anyway\n                return True if try_fill $v + 1, $_;\n            }\n        }\n\n        for @neighbors -> [$yy,$xx] {\n            ++@degree[$yy][$xx];          # undo degree conjectures\n        }\n\n        @grid[$y][$x] = $old;             # undo grid value conjecture\n        return False;\n    }\n     \n    say \"$tries tries\";\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Chess coaches have been known to inflict a kind of torture on beginners by taking a chess board, placing pennies on some squares and requiring that a Knight's tour be constructed that avoids the squares with pennies.\n\nThis kind of knight's tour puzzle is similar to   Hidato.\n\nThe present task is to produce a solution to such problems. At least demonstrate your program by solving the following:\n\nExample\n\n```\n  0 0 0 \n  0   0 0 \n  0 0 0 0 0 0 0\n0 0 0     0   0\n0   0     0 0 0\n1 0 0 0 0 0 0\n    0 0   0\n      0 0 0\n\n```\n\nNote that the zeros represent the available squares, not the pennies.\n\nExtra credit is available for other interesting examples.\n\nRelated tasks\n\n* A\\* search algorithm\n* Knight's tour\n* N-queens problem\n* Solve a Hidato puzzle\n* Solve a Hopido puzzle\n* Solve a Numbrix puzzle\n* Solve the no connection puzzle"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis uses a Warnsdorff solver, which cuts down the number of tries by more than a factor of six over the brute force approach. This same solver is used in:\n\n* Solve a Hidato puzzle\n* Solve a Hopido puzzle\n* Solve a Holy Knight's tour\n* Solve a Numbrix puzzle\n* Solve the no connection puzzle\n\n```\nmy @adjacent =\n               [ -2, -1],  [ -2, 1],\n      [-1,-2],                       [-1,+2],\n      [+1,-2],                       [+1,+2],\n               [ +2, -1],  [ +2, 1];\n\nput \"\\n\" xx 60;\n\nsolveboard q:to/END/;\n    . 0 0 0\n    . 0 . 0 0\n    . 0 0 0 0 0 0 0\n    0 0 0 . . 0 . 0\n    0 . 0 . . 0 0 0\n    1 0 0 0 0 0 0\n    . . 0 0 . 0\n    . . . 0 0 0\n    END\n\nsub solveboard($board) {\n    my $max = +$board.comb(/\\w+/);\n    my $width = $max.chars;\n\n    my @grid;\n    my @known;\n    my @neigh;\n    my @degree;\n \n    @grid = $board.lines.map: -> $line {\n        [ $line.words.map: { /^_/ ?? 0 !! /^\\./ ?? Rat !! $_ } ]\n    }\n \n    sub neighbors($y,$x --> List) {\n        eager gather for @adjacent {\n            my $y1 = $y + .[0];\n            my $x1 = $x + .[1];\n            take [$y1,$x1] if defined @grid[$y1][$x1];\n        }\n    }\n\n    for ^@grid -> $y {\n        for ^@grid[$y] -> $x {\n            if @grid[$y][$x] -> $v {\n                @known[$v] = [$y,$x];\n            }\n            if @grid[$y][$x].defined {\n                @neigh[$y][$x] = neighbors($y,$x);\n                @degree[$y][$x] = +@neigh[$y][$x];\n            }\n        }\n    }\n    print \"\\e[0H\\e[0J\";\n\n    my $tries = 0;\n\n    try_fill 1, @known[1];\n\n    sub try_fill($v, $coord [$y,$x] --> Bool) {\n        return True if $v > $max;\n        $tries++;\n\n        my $old = @grid[$y][$x];\n\n        return False if +$old and $old != $v;\n        return False if @known[$v] and @known[$v] !eqv $coord;\n\n        @grid[$y][$x] = $v;               # conjecture grid value\n\n        print \"\\e[0H\";                    # show conjectured board\n        for @grid -> $r {\n            say do for @$r {\n                when Rat { ' ' x $width }\n                when 0   { '_' x $width }\n                default  { .fmt(\"%{$width}d\") }\n            }\n        }\n\n\n        my @neighbors = @neigh[$y][$x][];\n\n        my @degrees;\n        for @neighbors -> \\n [$yy,$xx] {\n            my $d = --@degree[$yy][$xx];  # conjecture new degrees\n            push @degrees[$d], n;         # and categorize by degree\n        }\n\n        for @degrees.grep(*.defined) -> @ties {\n            for @ties.reverse {           # reverse works better for this hidato anyway\n                return True if try_fill $v + 1, $_;\n            }\n        }\n\n        for @neighbors -> [$yy,$xx] {\n            ++@degree[$yy][$xx];          # undo degree conjectures\n        }\n\n        @grid[$y][$x] = $old;             # undo grid value conjecture\n        return False;\n    }\n     \n    say \"$tries tries\";\n}\n\n```\n\nOutput:\n\n```\n   25 14 27\n   36    24 15\n   31 26 13 28 23  6 17\n35 12 29       16    22\n30    32        7 18  5\n 1 34 11  8 19  4 21\n       2 33     9\n         10  3 20\n84 tries\n```"}]}
{"messages": [{"role": "user", "content": "Hopido puzzles are similar to Hidato. The most important difference is that the only moves allowed are: hop over one tile diagonally; and over two tiles horizontally and vertically. It should be possible to start anywhere in the path, the end point isn't indicated and there are no intermediate clues. Hopido Design Post Mortem contains the following:\n\n\"Big puzzles represented another problem. Up until quite late in the project our puzzle solver was painfully slow with most puzzles above 7×7 tiles. Testing the solution from each starting point could take hours. If the tile layout was changed even a little, the whole puzzle had to be tested again. We were just about to give up the biggest puzzles entirely when our programmer suddenly came up with a magical algorithm that cut the testing process down to only minutes. Hooray!\"\n\nKnowing the kindness in the heart of every contributor to Rosetta Code, I know that we shall feel that as an act of humanity we must solve these puzzles for them in let's say milliseconds.\n\nExample:\n\n```\n. 0 0 . 0 0 .\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n. 0 0 0 0 0 .\n. . 0 0 0 . .\n. . . 0 . . .\n\n```\n\nExtra credits are available for other interesting designs.\n\nRelated tasks\n\n* A\\* search algorithm\n* Solve a Holy Knight's tour\n* Knight's tour\n* N-queens problem\n* Solve a Hidato puzzle\n* Solve a Holy Knight's tour\n* Solve a Numbrix puzzle\n* Solve the no connection puzzle"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis uses a Warnsdorff solver, which cuts down the number of tries by more than a factor of six over the brute force approach. This same solver is used in:\n\n* Solve a Hidato puzzle\n* Solve a Hopido puzzle\n* Solve a Holy Knight's tour\n* Solve a Numbrix puzzle\n* Solve the no connection puzzle\n\n```\nmy @adjacent = [3, 0],\n      [2, -2],         [2, 2],\n   [0, -3],                [0, 3],\n      [-2, -2],        [-2, 2],\n               [-3, 0];\n\nsolveboard q:to/END/;\n    . _ _ . _ _ .\n    _ _ _ _ _ _ _\n    _ _ _ _ _ _ _\n    . _ _ _ _ _ .\n    . . _ _ _ . .\n    . . . 1 . . .\n    END\n\nsub solveboard($board) {\n    my $max = +$board.comb(/\\w+/);\n    my $width = $max.chars;\n\n    my @grid;\n    my @known;\n    my @neigh;\n    my @degree;\n \n    @grid = $board.lines.map: -> $line {\n        [ $line.words.map: { /^_/ ?? 0 !! /^\\./ ?? Rat !! $_ } ]\n    }\n \n    sub neighbors($y,$x --> List) {\n        eager gather for @adjacent {\n            my $y1 = $y + .[0];\n            my $x1 = $x + .[1];\n            take [$y1,$x1] if defined @grid[$y1][$x1];\n        }\n    }\n\n    for ^@grid -> $y {\n        for ^@grid[$y] -> $x {\n            if @grid[$y][$x] -> $v {\n                @known[$v] = [$y,$x];\n            }\n            if @grid[$y][$x].defined {\n                @neigh[$y][$x] = neighbors($y,$x);\n                @degree[$y][$x] = +@neigh[$y][$x];\n            }\n        }\n    }\n    print \"\\e[0H\\e[0J\";\n\n    my $tries = 0;\n\n    try_fill 1, @known[1];\n\n    sub try_fill($v, $coord [$y,$x] --> Bool) {\n        return True if $v > $max;\n        $tries++;\n\n        my $old = @grid[$y][$x];\n\n        return False if +$old and $old != $v;\n        return False if @known[$v] and @known[$v] !eqv $coord;\n\n        @grid[$y][$x] = $v;               # conjecture grid value\n\n        print \"\\e[0H\";                    # show conjectured board\n        for @grid -> $r {\n            say do for @$r {\n                when Rat { ' ' x $width }\n                when 0   { '_' x $width }\n                default  { .fmt(\"%{$width}d\") }\n            }\n        }\n\n\n        my @neighbors = @neigh[$y][$x][];\n\n        my @degrees;\n        for @neighbors -> \\n [$yy,$xx] {\n            my $d = --@degree[$yy][$xx];  # conjecture new degrees\n            push @degrees[$d], n;         # and categorize by degree\n        }\n\n        for @degrees.grep(*.defined) -> @ties {\n            for @ties.reverse {           # reverse works better for this hidato anyway\n                return True if try_fill $v + 1, $_;\n            }\n        }\n\n        for @neighbors -> [$yy,$xx] {\n            ++@degree[$yy][$xx];          # undo degree conjectures\n        }\n\n        @grid[$y][$x] = $old;             # undo grid value conjecture\n        return False;\n    }\n     \n    say \"$tries tries\";\n}\n\n```\n\nOutput:\n\n```\n   21  4    20  3   \n26 12 15 25 11 14 24\n17  6  9 18  5  8 19\n   22 27 13 23  2   \n      16  7 10      \n          1         \n59 tries\n```"}]}
{"messages": [{"role": "user", "content": "Numbrix puzzles are similar to Hidato.\nThe most important difference is that it is only possible to move 1 node left, right, up, or down (sometimes referred to as the Von Neumann neighborhood).\nPublished puzzles also tend not to have holes in the grid and may not always indicate the end node.\nTwo examples follow:\n\nExample 1\n\nProblem.\n\n```\n 0  0  0  0  0  0  0  0  0\n 0  0 46 45  0 55 74  0  0\n 0 38  0  0 43  0  0 78  0\n 0 35  0  0  0  0  0 71  0\n 0  0 33  0  0  0 59  0  0\n 0 17  0  0  0  0  0 67  0\n 0 18  0  0 11  0  0 64  0\n 0  0 24 21  0  1  2  0  0\n 0  0  0  0  0  0  0  0  0\n\n```\n\nSolution.\n\n```\n 49 50 51 52 53 54 75 76 81\n 48 47 46 45 44 55 74 77 80\n 37 38 39 40 43 56 73 78 79\n 36 35 34 41 42 57 72 71 70\n 31 32 33 14 13 58 59 68 69\n 30 17 16 15 12 61 60 67 66\n 29 18 19 20 11 62 63 64 65\n 28 25 24 21 10  1  2  3  4\n 27 26 23 22  9  8  7  6  5\n\n```\n\nExample 2\n\nProblem.\n\n```\n 0  0  0  0  0  0  0  0  0\n 0 11 12 15 18 21 62 61  0\n 0  6  0  0  0  0  0 60  0\n 0 33  0  0  0  0  0 57  0\n 0 32  0  0  0  0  0 56  0\n 0 37  0  1  0  0  0 73  0\n 0 38  0  0  0  0  0 72  0\n 0 43 44 47 48 51 76 77  0\n 0  0  0  0  0  0  0  0  0\n\n```\n\nSolution.\n\n```\n  9 10 13 14 19 20 63 64 65\n  8 11 12 15 18 21 62 61 66\n  7  6  5 16 17 22 59 60 67\n 34 33  4  3 24 23 58 57 68\n 35 32 31  2 25 54 55 56 69\n 36 37 30  1 26 53 74 73 70\n 39 38 29 28 27 52 75 72 71\n 40 43 44 47 48 51 76 77 78\n 41 42 45 46 49 50 81 80 79\n\n```\n\nTask\n\nWrite a program to solve puzzles of this ilk,\ndemonstrating your program by solving the above examples.\nExtra credit for other interesting examples.\n\nRelated tasks\n\n* A\\* search algorithm\n* Solve a Holy Knight's tour\n* Knight's tour\n* N-queens problem\n* Solve a Hidato puzzle\n* Solve a Holy Knight's tour\n* Solve a Hopido puzzle\n* Solve the no connection puzzle"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis uses a Warnsdorff solver, which cuts down the number of tries by more than a factor of six over the brute force approach. This same solver is used in:\n\n* Solve a Hidato puzzle\n* Solve a Hopido puzzle\n* Solve a Holy Knight's tour\n* Solve a Numbrix puzzle\n* Solve the no connection puzzle\n\n```\nmy @adjacent =           [-1, 0],\n               [ 0, -1],          [ 0, 1],\n                         [ 1, 0];\nput \"\\n\" xx 60;\n\nsolveboard q:to/END/;\n    __ __ __ __ __ __ __ __ __\n    __ __ 46 45 __ 55 74 __ __\n    __ 38 __ __ 43 __ __ 78 __\n    __ 35 __ __ __ __ __ 71 __\n    __ __ 33 __ __ __ 59 __ __\n    __ 17 __ __ __ __ __ 67 __\n    __ 18 __ __ 11 __ __ 64 __\n    __ __ 24 21 __  1  2 __ __\n    __ __ __ __ __ __ __ __ __\n    END\n\n# And\nput \"\\n\" xx 60;\n\nsolveboard q:to/END/;\n    0  0  0  0  0  0  0  0  0\n    0 11 12 15 18 21 62 61  0\n    0  6  0  0  0  0  0 60  0\n    0 33  0  0  0  0  0 57  0\n    0 32  0  0  0  0  0 56  0\n    0 37  0  1  0  0  0 73  0\n    0 38  0  0  0  0  0 72  0\n    0 43 44 47 48 51 76 77  0\n    0  0  0  0  0  0  0  0  0\n    END\n\n\nsub solveboard($board) {\n    my $max = +$board.comb(/\\w+/);\n    my $width = $max.chars;\n\n    my @grid;\n    my @known;\n    my @neigh;\n    my @degree;\n\n    @grid = $board.lines.map: -> $line {\n        [ $line.words.map: { /^_/ ?? 0 !! /^\\./ ?? Rat !! $_ } ]\n    }\n\n    sub neighbors($y,$x --> List) {\n        eager gather for @adjacent {\n            my $y1 = $y + .[0];\n            my $x1 = $x + .[1];\n            take [$y1,$x1] if defined @grid[$y1][$x1];\n        }\n    }\n\n    for ^@grid -> $y {\n        for ^@grid[$y] -> $x {\n            if @grid[$y][$x] -> $v {\n                @known[$v] = [$y,$x];\n            }\n            if @grid[$y][$x].defined {\n                @neigh[$y][$x] = neighbors($y,$x);\n                @degree[$y][$x] = +@neigh[$y][$x];\n            }\n        }\n    }\n    print \"\\e[0H\\e[0J\";\n\n    my $tries = 0;\n\n    try_fill 1, @known[1];\n\n    sub try_fill($v, $coord [$y,$x] --> Bool) {\n        return True if $v > $max;\n        $tries++;\n\n        my $old = @grid[$y][$x];\n\n        return False if +$old and $old != $v;\n        return False if @known[$v] and @known[$v] !eqv $coord;\n\n        @grid[$y][$x] = $v;               # conjecture grid value\n\n        print \"\\e[0H\";                    # show conjectured board\n        for @grid -> $r {\n            say do for @$r {\n                when Rat { ' ' x $width }\n                when 0   { '_' x $width }\n                default  { .fmt(\"%{$width}d\") }\n            }\n        }\n\n\n        my @neighbors = @neigh[$y][$x][];\n\n        my @degrees;\n        for @neighbors -> \\n [$yy,$xx] {\n            my $d = --@degree[$yy][$xx];  # conjecture new degrees\n            push @degrees[$d], n;         # and categorize by degree\n        }\n\n        for @degrees.grep(*.defined) -> @ties {\n            for @ties.reverse {           # reverse works better for this hidato anyway\n                return True if try_fill $v + 1, $_;\n            }\n        }\n\n        for @neighbors -> [$yy,$xx] {\n            ++@degree[$yy][$xx];          # undo degree conjectures\n        }\n\n        @grid[$y][$x] = $old;             # undo grid value conjecture\n        return False;\n    }\n\n    say \"$tries tries\";\n}\n\n```\n\nOutput:\n\n```\n49 50 51 52 53 54 75 76 81\n48 47 46 45 44 55 74 77 80\n37 38 39 40 43 56 73 78 79\n36 35 34 41 42 57 72 71 70\n31 32 33 14 13 58 59 68 69\n30 17 16 15 12 61 60 67 66\n29 18 19 20 11 62 63 64 65\n28 25 24 21 10  1  2  3  4\n27 26 23 22  9  8  7  6  5\n1275 tries\n\n\n 9 10 13 14 19 20 63 64 65\n 8 11 12 15 18 21 62 61 66\n 7  6  5 16 17 22 59 60 67\n34 33  4  3 24 23 58 57 68\n35 32 31  2 25 54 55 56 69\n36 37 30  1 26 53 74 73 70\n39 38 29 28 27 52 75 72 71\n40 43 44 47 48 51 76 77 78\n41 42 45 46 49 50 81 80 79\n4631 tries\n```\n\nOddly, reversing the tiebreaker rule that makes hidato run twice as fast causes this last example to run four times slower. Go figure..."}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a program that is capable of solving a   Rubik's Cube   as efficiently as possible.\n\nOther names are:\n\n:   :   * Magic Cube\n        * Speed Cube\n        * Puzzle Cube\n        * Cube\n\nYou may use any sort of input you wish."}, {"role": "assistant", "content": "This is a translation of the Perl competition code, by Stefan Pochmann.\n\n```\n# 20230401 Raku programming solution\n\nmy @data=<UL DL RF UB FD BR DB UF DR UR BL FL FDR BLU DLB URB RUF FLD BRD FUL>;\nmy @goal=<UF UR UB UL DF DR DB DL FR FL BR BL UFR URB UBL ULF DRF DFL DLB DBR>;\n\nsub printAlg ($x) { #--- Algorithms.\n\n   my $algo  = 'x0F0DN0EB0H00N0B0R0KB0L0QB0G1A1M11C1I1E1OFI2'~\n               'DN2IEOB2H22N2B2GRM2MKGB2GLM2QBK23D3EN3E3B3N33H3';\n   $algo ~~ s:g \n      !(\\D*)(\\d)!{ \n      $0 ~ <ILOFCLKHRNQCL OBIRALOBIRAL CEJHPEIMIG DFNRHRDKMQ>[$1] \n      #  ~ [~] reverse map { TR/G..R/M..X/ }, \" $0\".comb }!;\n         ~ \" $0\".trans( ['G'..'R'] => ['M'..'X'] ).flip }!;\n\n   my @algo = $algo.split: ' ';\n\n   #`[[[ or use the following to save some CPU power and time # my @algo = <  \n      xILOFCLKHRNQCLx  FILOFCLKHRNQCLF    DNILOFCLKHRNQCLTD EBILOFCLKHRNQCLBE \n      HILOFCLKHRNQCLN  ILOFCLKHRNQCL      NILOFCLKHRNQCLT   BILOFCLKHRNQCLB \n      RILOFCLKHRNQCLX  KBILOFCLKHRNQCLBQ  LILOFCLKHRNQCLR   QBILOFCLKHRNQCLBW \n      GOBIRALOBIRALM   AOBIRALOBIRALA     MOBIRALOBIRALS    OBIRALOBIRAL \n      COBIRALOBIRALC   IOBIRALOBIRALO     EOBIRALOBIRALE    OFICEJHPEIMIGOFU \n      DNCEJHPEIMIGTD   IEOBCEJHPEIMIGBUEO HCEJHPEIMIGN      CEJHPEIMIG \n      NCEJHPEIMIGT     BCEJHPEIMIGB       GRMCEJHPEIMIGSXM  MKGBCEJHPEIMIGBMQS \n      GLMCEJHPEIMIGSRM QBKCEJHPEIMIGQBW   DFNRHRDKMQ        DDFNRHRDKMQD \n      ENDFNRHRDKMQTE   EDFNRHRDKMQE       BDFNRHRDKMQB      NDFNRHRDKMQT \n      DFNRHRDKMQ       HDFNRHRDKMQN >; #]]]\n\n   say [~] my @moves = map { \n      substr('UDFBLR', (my $ord=.ord-65) % 6, 1) ~ substr(\"2 '\", $ord div 6, 1)\n   }, @algo[$x].comb; \n   \n   return @moves.elems\n}\n\nmy $total = 0;\n\nfor 1..18 -> $x { #--- Orient.\n   until @data[$x] ∈ @goal {\n      $total += printAlg $x;\n      @data[$x]                 ~~ s/(.)(.+)/$1$0/;\n      @data[$x < 12 ?? 0 !! 19] ~~ s/(.+)(.)/$1$0/;\n   } \n}\n\nfor ^41 { #--- Permute.\n   for ^20 -> $w { \n      next if @data[$w] eq @goal[$w];\n      my $x = 0;\n      until @data[$w] eq @goal[$x] { $x++ };\n      $x < 12 ?? ( @data[0,$x,12,15] = @data[$x,0,15,12] ) \n              !! ( @data[12,$x]      = @data[$x,12]      );\n      $total += printAlg $x+=18 and last\n   }\n}\n\nsay \"\\nTotal number of moves : $total\";\n\n```\n\nOutput:\n\n```\nB2D'F R F'R2F2R L D R'D'L'F2R DB2\nD F R F'R2F2R L D R'D'L'F2R D'\nU F'D2F R'U2R F'D2F R'U2R U'\nU2F'D2F R'U2R F'D2F R'U2R U2\nU2F'D2F R'U2R F'D2F R'U2R U2\nF2F'D2F R'U2R F'D2F R'U2R F2\nF F'D2F R'U2R F'D2F R'U2R F'\nF F'D2F R'U2R F'D2F R'U2R F'\nL2F'D2F R'U2R F'D2F R'U2R L2\nL2F'D2F R'U2R F'D2F R'U2R L2\nF L2F'D2F2L2B D B'L2F U'F U D2FL2F'\nB2D'F2L2B D B'L2F U'F U DB2\nU R'U'F2L2B D B'L2F U'F U URU'\nF2L2B D B'L2F U'F U \nU R U'F2L2B D B'L2F U'F U UR'U'\nL'D2L F2L2B D B'L2F U'F U L'D2L\nU'L U D2F2L2B D B'L2F U'F U D2U'L'U\nF'R2F F2L2B D B'L2F U'F U F'R2F\nD2F2L2B D B'L2F U'F U D2\nB2B2R2D'R'D R'B2L U'L'B2\nL2D'B2R2D'R'D R'B2L U'L'DL2\nB2R2D'R'D R'B2L U'L'\nD B2R2D'R'D R'B2L U'L'D'\nL2B2R2D'R'D R'B2L U'L'L2\nD2B2R2D'R'D R'B2L U'L'D2\n\nTotal number of moves : 352\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nLet given equations:\n  \n3x + y = -1 and 2x - 3y = -19\n  \nSolve it with substitution method.\n\nSee related\n\n* Reduced row echelon form\n* Gaussian elimination"}, {"role": "assistant", "content": "```\nsub solve-system-of-two-linear-equations ( [ \\a1, \\b1, \\c1 ], [ \\a2, \\b2, \\c2 ] ) {\n    my \\X = ( b2 * c1   -   b1 * c2 )\n          / ( b2 * a1   -   b1 * a2 );\n\n    my \\Y = ( a1 * X    -   c1 ) / -b1;\n\n    return X, Y;\n}\nsay solve-system-of-two-linear-equations( (3,1,-1), (2,-3,-19) );\n\n```\n\nOutput:\n\n```\n(-2 5)\n```"}]}
{"messages": [{"role": "user", "content": "There are some columns of lanterns hanging from the ceiling. If you remove the lanterns one at a time, at each step removing the bottommost lantern from one column, how many legal sequences will let you take all of the lanterns down?\n\nFor example, there are some lanterns hanging like this:\n\n```\n🏮 🏮 🏮\n   🏮 🏮\n      🏮\n\n```\n\nIf we number the lanterns like so:\n\n```\n1 2 4\n  3 5\n    6\n\n```\n\nYou can take like this: [6,3,5,2,4,1] or [3,1,6,5,2,4]  \nBut not like this: [6,3,2,4,5,1], because at that time 5 is under 4.\n\nIn total, there are 60 ways to take them down.\n\n---\n\nTask\n\n**Input:**  \nFirst an integer (n): the number of columns.  \nThen n integers: the number of lanterns in each column.  \n**Output:**  \nAn integer: the number of sequences.\n\nFor example, the input of the example above could be:\n\n```\n3\n1\n2\n3\n\n```\n\nAnd the output is:\n\n```\n60\n\n```\n\n---\n\nOptional task\n\nOutput all the sequences using this format:\n\n```\n[1,2,3,…]\n[2,1,3,…]\n……\n\n```\n\nRelated\n\n* Permutations\\_with\\_some\\_identical\\_elements"}, {"role": "assistant", "content": "Note: All of these solutions accept the list of column sizes as command-line arguments and infer the number of columns from the number of sizes provided, rather than requiring that a count be supplied as an extra distinct parameter.\n\n### Directly computing the count\n\n**Translation of**: Pascal\n\nIf all we need is the count, then we can compute that directly:\n\n```\nunit sub MAIN(*@columns);\n\nsub postfix:<!>($n) { [*] 1..$n }\n\nsay [+](@columns)! / [*](@columns»!);\n\n```\n\nOutput:\n\n```\n$ raku lanterns.raku 1 2 3\n60\n```\n\n### Sequence as column numbers\n\n**Translation of**: Julia\n\nIf we want to list all of the sequences, we have to do some more work. This version outputs the sequences as lists of column numbers (assigned from 1 to N left to right); at each step the bottommost lantern from the numbered column is removed.\n\n```\nunit sub MAIN(*@columns, :v(:$verbose)=False);\n\nmy @sequences = @columns\n              . pairs\n              . map({ (.key+1) xx .value })\n              . flat\n              . permutations\n              . map( *.join(',') )\n              . unique;\n\nif ($verbose) {\n  say \"There are {+@sequences} possible takedown sequences:\";\n  say \"[$_]\" for @sequences;\n} else {\n  say +@sequences;\n}\n\n```\n\nOutput:\n\n```\n$ raku lanterns.raku --verbose 1 2 3\nThere are 60 possible takedown sequences:\n[1,2,2,3,3,3]\n[1,2,3,2,3,3]\n[1,2,3,3,2,3]\n[1,2,3,3,3,2]\n[1,3,2,2,3,3]\n[1,3,2,3,2,3]\n...\n[3,3,2,2,3,1]\n[3,3,2,3,1,2]\n[3,3,2,3,2,1]\n[3,3,3,1,2,2]\n[3,3,3,2,1,2]\n[3,3,3,2,2,1]\n```\n\n### Sequence as lantern numbers\n\nIf we want individually-numbered lanterns in the sequence instead of column numbers, as in the example given in the task description, that requires yet more work:\n\n```\nunit sub MAIN(*@columns, :v(:$verbose)=False);\n\nmy @sequences = @columns\n              . pairs\n              . map({ (.key+1) xx .value })\n              . flat\n              . permutations\n              . map( *.join(',') )\n              . unique;\n\nif ($verbose) {\n  my @offsets = |0,|(1..@columns).map: { [+] @columns[0..$_-1] };\n  my @matrix;\n  for ^@columns.max -> $i {\n    for ^@columns -> $j {\n      my $value = $i < @columns[$j] ?? ($i+@offsets[$j]+1) !! Nil;\n      @matrix[$j][$i] = $value if $value;;\n      print \"\\t\" ~ ($value // \" \");\n    }\n    say '';\n  }\n  say \"There are {+@sequences} possible takedown sequences:\";\n  for @sequences».split(',') -> @seq {\n    my @work = @matrix».clone;\n    my $seq = '[';\n    for @seq -> $col {\n      $seq ~= @work[$col-1].pop ~ ',';\n    }\n    $seq ~~ s/','$/]/;\n    say $seq;\n  }\n} else {\n  say +@sequences;\n}\n\n```\n\nOutput:\n\n```\n$ raku lanterns.raku -v 1 2 3                                                   \n        1       2       4\n                3       5\n                        6\nThere are 60 possible takedown sequences:\n[1,3,2,6,5,4]\n[1,3,6,2,5,4]\n[1,3,6,5,2,4]\n...\n[6,5,4,1,3,2]\n[6,5,4,3,1,2]\n[6,5,4,3,2,1]\n```"}]}
{"messages": [{"role": "user", "content": "You are given a box with eight holes labelled   A-to-H,   connected by fifteen straight lines in the pattern as shown below:\n\n```\n             A   B\n            /│\\ /│\\\n           / │ X │ \\\n          /  │/ \\│  \\\n         C───D───E───F\n          \\  │\\ /│  /\n           \\ │ X │ /\n            \\│/ \\│/\n             G   H\n\n```\n\nYou are also given eight pegs numbered   1-to-8.\n\nObjective\n\nPlace the eight pegs in the holes so that the (absolute) difference between any two numbers connected by any line is greater than one.\n\nExample\n\nIn this attempt:\n\n```\n             4   7\n            /│\\ /│\\\n           / │ X │ \\\n          /  │/ \\│  \\\n         8───1───6───2\n          \\  │\\ /│  /\n           \\ │ X │ /\n            \\│/ \\│/\n             3   5\n\n```\n\nNote that   **7**   and   **6**   are connected and have a difference of   **1**,   so it is   *not*   a solution.\n\nTask\n\nProduce and show here   *one*   solution to the puzzle.\n\nRelated tasks\n:   * A\\* search algorithm\n    * Solve a Holy Knight's tour\n    * Knight's tour\n    * N-queens problem\n    * Solve a Hidato puzzle\n    * Solve a Holy Knight's tour\n    * Solve a Hopido puzzle\n    * Solve a Numbrix puzzle\n    * 4-rings or 4-squares puzzle\n\nSee also\n\nNo Connection Puzzle (youtube)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis uses a Warnsdorff solver, which cuts down the number of tries by more than a factor of six over the brute force approach. This same solver is used in:\n\n* Solve a Hidato puzzle\n* Solve a Hopido puzzle\n* Solve a Holy Knight's tour\n* Solve a Numbrix puzzle\n* Solve the no connection puzzle\n\nThe idiosyncratic adjacency diagram is dealt with by the simple expedient of bending the two vertical lines || into two bows )(, such that adjacency can be calculated simply as a distance of 2 or less.\n\n```\nmy @adjacent = gather -> $y, $x {\n    take [$y,$x] if abs($x|$y) > 2;\n} for flat -5 .. 5 X -5 .. 5;\n\nsolveboard q:to/END/;\n    . _ . . _ .\n    . . . . . .\n    _ . _ 1 . _\n    . . . . . .\n    . _ . . _ .\n    END\n \nsub solveboard($board) {\n    my $max = +$board.comb(/\\w+/);\n    my $width = $max.chars;\n\n    my @grid;\n    my @known;\n    my @neigh;\n    my @degree;\n \n    @grid = $board.lines.map: -> $line {\n        [ $line.words.map: { /^_/ ?? 0 !! /^\\./ ?? Rat !! $_ } ]\n    }\n \n    sub neighbors($y,$x --> List) {\n        eager gather for @adjacent {\n            my $y1 = $y + .[0];\n            my $x1 = $x + .[1];\n            take [$y1,$x1] if defined @grid[$y1][$x1];\n        }\n    }\n\n    for ^@grid -> $y {\n        for ^@grid[$y] -> $x {\n            if @grid[$y][$x] -> $v {\n                @known[$v] = [$y,$x];\n            }\n            if @grid[$y][$x].defined {\n                @neigh[$y][$x] = neighbors($y,$x);\n                @degree[$y][$x] = +@neigh[$y][$x];\n            }\n        }\n    }\n    print \"\\e[0H\\e[0J\";\n\n    my $tries = 0;\n\n    try_fill 1, @known[1];\n\n    sub try_fill($v, $coord [$y,$x] --> Bool) {\n        return True if $v > $max;\n        $tries++;\n\n        my $old = @grid[$y][$x];\n\n        return False if +$old and $old != $v;\n        return False if @known[$v] and @known[$v] !eqv $coord;\n\n        @grid[$y][$x] = $v;               # conjecture grid value\n\n        print \"\\e[0H\";                    # show conjectured board\n        for @grid -> $r {\n            say do for @$r {\n                when Rat { ' ' x $width }\n                when 0   { '_' x $width }\n                default  { .fmt(\"%{$width}d\") }\n            }\n        }\n\n\n        my @neighbors = @neigh[$y][$x][];\n\n        my @degrees;\n        for @neighbors -> \\n [$yy,$xx] {\n            my $d = --@degree[$yy][$xx];  # conjecture new degrees\n            push @degrees[$d], n;         # and categorize by degree\n        }\n\n        for @degrees.grep(*.defined) -> @ties {\n            for @ties.reverse {           # reverse works better for this hidato anyway\n                return True if try_fill $v + 1, $_;\n            }\n        }\n\n        for @neighbors -> [$yy,$xx] {\n            ++@degree[$yy][$xx];          # undo degree conjectures\n        }\n\n        @grid[$y][$x] = $old;             # undo grid value conjecture\n        return False;\n    }\n     \n    say \"$tries tries\";\n}\n\n```\n\nOutput:\n\n```\n  4     3  \n           \n2   8 1   7\n           \n  6     5  \n18 tries\n```"}]}
{"messages": [{"role": "user", "content": "An   IQ Puzzle   is a triangle of 15 golf tee's.\n\nThis puzzle is typically seen at Cracker Barrel   (a USA sales store)   where one tee is missing and the remaining tees jump over each other   (with removal of the jumped tee, like checkers)   until one tee is left.\n\nThe fewer tees left,   the higher the IQ score.\n\nPeg   #1   is the top centre through to the bottom row which are pegs 11 through to 15.\n\n```\n         ^\n        / \\        \n       /   \\\n      /     \\\n     /   1   \\     \n    /  2   3  \\\n   / 4   5  6  \\ \n  / 7  8  9  10 \\\n /11 12 13 14  15\\\n/_________________\\\n\n```\n\nReference picture:   http://www.joenord.com/puzzles/peggame/\n  \nUpdated link (June 2021):  \nhttps://www.joenord.com/triangle-peg-board-game-solutions-to-amaze-your-friends/\n\nTask\n\nPrint a solution to solve the puzzle leaving one peg not implemented variations.\n\nStart with empty peg in   **X**   and solve with one peg in position   **Y**."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.05\n\n**Translation of**: Sidef\n\n```\nconstant @start =  <\n        0\n       1 1\n      1 1 1\n     1 1 1 1\n    1 1 1 1 1\n>».Int;\n\nconstant @moves =\n    [ 0, 1, 3],[ 0, 2, 5],[ 1, 3, 6],\n    [ 1, 4, 8],[ 2, 4, 7],[ 2, 5, 9],\n    [ 3, 4, 5],[ 3, 6,10],[ 3, 7,12],\n    [ 4, 7,11],[ 4, 8,13],[ 5, 8,12],\n    [ 5, 9,14],[ 6, 7, 8],[ 7, 8, 9],\n    [10,11,12],[11,12,13],[12,13,14];\n\nmy $format = (1..5).map: {' ' x 5-$_, \"%d \" x $_, \"\\n\"};\n\nsub solve(@board, @move) {\n    return \"   Solved\" if @board.sum == 1;\n    return Nil if @board[@move[1]] == 0;\n    my $valid = do given @board[@move[0]] {\n        when 0 {\n            return Nil if @board[@move[2]] == 0;\n            \"move {@move[2]} to {@move[0]}\\n \";\n        }\n        default {\n            return Nil if @board[@move[2]] == 1;\n            \"move {@move[0]} to {@move[2]}\\n \";\n        }\n    }\n\n    my @new-layout = @board;\n    @new-layout[$_] = 1 - @new-layout[$_] for @move;\n    my $result;\n    for @moves -> @this-move {\n        $result = solve(@new-layout, @this-move);\n        last if $result\n    }\n    $result ?? \"$valid\\n \" ~ sprintf($format, |@new-layout) ~ $result !! $result\n}\n\nprint \"Starting with\\n \", sprintf($format, |@start);\n\nmy $result;\nfor @moves -> @this-move {\n    $result = solve(@start, @this-move);\n    last if $result\n};\nsay $result ?? $result !! \"No solution found\";\n\n```\n\nOutput:\n\n```\nStarting with\n      0  \n     1 1  \n    1 1 1  \n   1 1 1 1  \n  1 1 1 1 1  \nmove 3 to 0\n \n      1  \n     0 1  \n    0 1 1  \n   1 1 1 1  \n  1 1 1 1 1  \nmove 8 to 1\n \n      1  \n     1 1  \n    0 0 1  \n   1 1 0 1  \n  1 1 1 1 1  \nmove 10 to 3\n \n      1  \n     1 1  \n    1 0 1  \n   0 1 0 1  \n  0 1 1 1 1  \nmove 1 to 6\n \n      1  \n     0 1  \n    0 0 1  \n   1 1 0 1  \n  0 1 1 1 1  \nmove 11 to 4\n \n      1  \n     0 1  \n    0 1 1  \n   1 0 0 1  \n  0 0 1 1 1  \nmove 2 to 7\n \n      1  \n     0 0  \n    0 0 1  \n   1 1 0 1  \n  0 0 1 1 1  \nmove 9 to 2\n \n      1  \n     0 1  \n    0 0 0  \n   1 1 0 0  \n  0 0 1 1 1  \nmove 0 to 5\n \n      0  \n     0 0  \n    0 0 1  \n   1 1 0 0  \n  0 0 1 1 1  \nmove 6 to 8\n \n      0  \n     0 0  \n    0 0 1  \n   0 0 1 0  \n  0 0 1 1 1  \nmove 13 to 11\n \n      0  \n     0 0  \n    0 0 1  \n   0 0 1 0  \n  0 1 0 0 1  \nmove 5 to 12\n \n      0  \n     0 0  \n    0 0 0  \n   0 0 0 0  \n  0 1 1 0 1  \nmove 11 to 13\n \n      0  \n     0 0  \n    0 0 0  \n   0 0 0 0  \n  0 0 0 1 1  \nmove 14 to 12\n \n      0  \n     0 0  \n    0 0 0  \n   0 0 0 0  \n  0 0 1 0 0  \n   Solved\n\n```"}]}
{"messages": [{"role": "user", "content": "The Sørensen–Dice coefficient, also known as the Sørensen–Dice index (or sdi, or sometimes by one of the individual names: sorensen or dice) is a statistic used to gauge the similarity of two population samples.\n\nThe original use was in botany as a measure of similarity between populations of flora and fauna in different areas, but it has uses in other fields as well. It can be used as a text similarity function somewhat similar to the Levenshtein edit distance function, though its characteristics are quite different.\n\nLevenshtein can be useful for spelling correction, but relies on the tested word or phrase being quite similar to the desired one, and can be very slow for long words or phrases.\n\nSørensen–Dice is more useful for 'fuzzy' matching partial and poorly spelled words or phrases, possibly in improper order.\n\nThere are several different methods to tokenize objects for Sørensen–Dice comparisons. The most typical tokenizing scheme for text is to break the words up into bi-grams: groups of two consecutive letters.\n\nFor instance, the word 'differ' would be tokenized to the group:\n\n```\n   di if ff fe er\n\n```\n\nDifferent implementations may do slightly different transforms. For our purposes, fold case so that all characters are the same case, split words, and ignore white-space, but keep punctuation.\n\nThe phrase \"Don't Panic!\" will be tokenized to the bi-grams:\n\n```\n   do on n' 't pa an ni ic c! \n\n\n```\n\nSørensen–Dice measures the similarity of two groups by dividing twice the intersection token count by the total token count of both groups:\n\n```\n   SDC = 2 × |A∩B| / (|A| + |B|)\n\n```\n\nwhere A, B and A∩B are to be understood as multisets, and that if an item, x, has multiplicity a in A and b in B, then it will have multiplicity min(a,b) in A∩B.\n\nThe Sørensen–Dice coefficient is thus a ratio between 0.0 and 1.0 giving the \"percent similarity\" between the two populations.\n\nSDC *can* by used for spellchecking, but it's not really good at it, especially for short words. Where it really shines is for fuzzy matching of short phrases like book or movie titles. It may not return exactly what you are looking for, but often gets remarkably close with some pretty poor inputs.\n\nTask\n\n* Use the list of Rosetta Code task and draft task names as your \"dictionary\" to search.\n* Using that dictionary, search for the mangled task names: '**Primordial primes'**, '**Sunkist-Giuliani formula'**, '**Sieve of Euripides'**, '**Chowder numbers'**.\n* Show the search term and the coefficient / match for the five closest, most similar matches.\n\nHow you get the task names is peripheral to the task. You can web-scrape them or download them to a file, whatever.\n\nIf there is a built-in or easily, freely available library implementation for Sørensen–Dice coefficient calculations, it is acceptable to use that with a pointer to where it may be obtained."}, {"role": "assistant", "content": "Using the library Text::Sorensen from the Raku ecosystem.\n\nSee the Raku entry for Text completion for a bespoke implementation of Sorenson-Dice. (Which is *very* similar to the library implementation.)\n\n```\nuse Text::Sorensen :sdi;\n\nmy %tasks = './tasks.txt'.IO.slurp.lines.race.map: { $_ => .&bi-gram };\n\nsub fuzzy-search (Str $string) { sdi($string, %tasks, :ge(.2) ).head(5).join: \"\\n\" }\n\nsay \"\\n$_ >\\n\" ~ .&fuzzy-search for\n  'Primordial primes',\n  'Sunkist-Giuliani formula',\n  'Sieve of Euripides',\n  'Chowder numbers';\n\n```\n\nOutput:\n\n```\nPrimordial primes >\n0.685714 Sequence of primorial primes\n0.666667 Factorial primes\n0.571429 Primorial numbers\n0.545455 Prime words\n0.521739 Almost prime\n\nSunkist-Giuliani formula >\n0.565217 Almkvist-Giullera formula for pi\n0.378378 Faulhaber's formula\n0.342857 Haversine formula\n0.333333 Check Machin-like formulas\n0.307692 Resistance calculator\n\nSieve of Euripides >\n0.461538 Four sides of square\n0.461538 Sieve of Pritchard\n0.413793 Sieve of Eratosthenes\n0.4 Piprimes\n0.384615 Sierpinski curve\n\nChowder numbers >\n0.782609 Chowla numbers\n0.64 Powerful numbers\n0.608696 Fermat numbers\n0.608696 Rhonda numbers\n0.6 Lah numbers\n```"}]}
{"messages": [{"role": "user", "content": "Object identifiers (OID) are strings used to identify objects in network data.\n\nTask\n\nShow how to sort a list of OIDs, in their natural sort order.\n\nDetails\n\n* An OID consists of one or more non-negative integers in base 10, separated by dots. It starts and ends with a number.\n* Their natural sort order is lexicographical with regard to the dot-separated fields, using numeric comparison between fields.\n\nTest case\n\n:   :   :   :   | Input *(list of strings)* | Output *(list of strings)* |\n                | --- | --- |\n                | `1.3.6.1.4.1.11.2.17.19.3.4.0.10`  `1.3.6.1.4.1.11.2.17.5.2.0.79`  `1.3.6.1.4.1.11.2.17.19.3.4.0.4`  `1.3.6.1.4.1.11150.3.4.0.1`  `1.3.6.1.4.1.11.2.17.19.3.4.0.1`  `1.3.6.1.4.1.11150.3.4.0` | `1.3.6.1.4.1.11.2.17.5.2.0.79`  `1.3.6.1.4.1.11.2.17.19.3.4.0.1`  `1.3.6.1.4.1.11.2.17.19.3.4.0.4`  `1.3.6.1.4.1.11.2.17.19.3.4.0.10`  `1.3.6.1.4.1.11150.3.4.0`  `1.3.6.1.4.1.11150.3.4.0.1` |\n\nRelated tasks\n\n* Natural sorting\n* Sort using a custom comparator\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe sort routine accepts a sort key callback as the first argument. Here we generate a list of integers as the sort key for each OID, which gets sorted lexicographically with numeric comparison by default.\n\n```\n.say for sort *.comb(/\\d+/)».Int, <\n    1.3.6.1.4.1.11.2.17.19.3.4.0.10\n    1.3.6.1.4.1.11.2.17.5.2.0.79\n    1.3.6.1.4.1.11.2.17.19.3.4.0.4\n    1.3.6.1.4.1.11150.3.4.0.1\n    1.3.6.1.4.1.11.2.17.19.3.4.0.1\n    1.3.6.1.4.1.11150.3.4.0\n>;\n\n```\n\nOutput:\n\n```\n1.3.6.1.4.1.11.2.17.5.2.0.79\n1.3.6.1.4.1.11.2.17.19.3.4.0.1\n1.3.6.1.4.1.11.2.17.19.3.4.0.4\n1.3.6.1.4.1.11.2.17.19.3.4.0.10\n1.3.6.1.4.1.11150.3.4.0\n1.3.6.1.4.1.11150.3.4.0.1\n\n```\n\nAlternatively, using the sprintf-based approach used by the Perl solution, for comparison *(input elided)*:\n\n```\n.say for sort *.split('.').fmt('%08d'), <...>;\n\n```\n\nOr if using a third-party module is acceptable:\n\n```\nuse Sort::Naturally;\n\n.say for sort &naturally, <...>;\n\n```"}]}
{"messages": [{"role": "user", "content": "Sort an array of composite structures by a key.\n\nFor example, if you define a composite structure that presents a name-value pair (in pseudo-code):\n\n```\nDefine structure pair such that: \n   name as a string\n   value as a string\n\n```\n\nand an array of such pairs:\n\n```\n   x: array of pairs\n\n```\n\nthen define a sort routine that sorts the array *x* by the key *name*.\n\nThis task can always be accomplished with Sorting Using a Custom Comparator.\n\nIf your language is not listed here, please see the other article."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.05\n\n```\nmy class Employee {\n   has Str $.name;\n   has Rat $.wage;\n}\n\nmy $boss     = Employee.new( name => \"Frank Myers\"     , wage => 6755.85 );\nmy $driver   = Employee.new( name => \"Aaron Fast\"      , wage => 2530.40 );\nmy $worker   = Employee.new( name => \"John Dude\"       , wage => 2200.00 );\nmy $salesman = Employee.new( name => \"Frank Mileeater\" , wage => 4590.12 );\n\nmy @team = $boss, $driver, $worker, $salesman;\n\nmy @orderedByName = @team.sort( *.name )».name;\nmy @orderedByWage = @team.sort( *.wage )».name;\n\nsay \"Team ordered by name (ascending order):\";\nsay @orderedByName.join('  ');\nsay \"Team ordered by wage (ascending order):\";\nsay @orderedByWage.join('  ');\n\n```\n\nthis produces the following output:\n\n```\nTeam ordered by name (ascending order): \nAaron Fast   Frank Mileeater   Frank Myers   John Dude   \nTeam ordered by wage (ascending order): \nJohn Dude   Aaron Fast   Frank Mileeater   Frank Myers   \n\n```\n\nNote that when the sort receives a unary function, it automatically generates an appropriate comparison function based on the type of the data."}]}
{"messages": [{"role": "user", "content": "Task\n\nSort an array (or list) of integers in ascending numerical order.\n\nUse a sorting facility provided by the language/library if possible."}, {"role": "assistant", "content": "(formerly Perl 6)\nIf `@a` contains only numbers:\n\n```\nmy @sorted = sort @a;\n\n```\n\nFor an in-place sort:\n\n```\n@a .= sort;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite and test a function over an indented plain text outline which either:\n\n1. Returns a copy of the outline in which the sub-lists at every level of indentation are sorted, or\n2. reports that the indentation characters or widths are not consistent enough to make the outline structure clear.\n\nYour code should detect and warn of at least two types of inconsistent indentation:\n\n* inconsistent use of whitespace characters (e.g. mixed use of tabs and spaces)\n* inconsistent indent widths. For example, an indentation with an odd number of spaces in an outline in which the unit indent appears to be 2 spaces, or 4 spaces.\n\nYour code should be able to detect and handle both tab-indented, and space-indented (e.g. 4 space, 2 space etc) outlines, without being given any advance warning of the indent characters used, or the size of the indent units.\n\nYou should also be able to specify different types of sort, for example, as a minimum, both ascending and descending lexical sorts.\n\nYour sort should not alter the type or size of the indentation units used in the input outline.\n\n(For an application of Indent Respectful Sort, see the Sublime Text package of that name. The Python source text [1] is available for inspection on Github).\n\n**Tests**\n\n* Sort every level of the (4 space indented) outline below lexically, once ascending and once descending.\n\n```\nzeta\n    beta\n    gamma\n        lambda\n        kappa\n        mu\n    delta\nalpha\n    theta\n    iota\n    epsilon\n```\n\n* Do the same with a tab-indented equivalent of the same outline.\n\n```\nzeta\n\tgamma\n\t\tmu\n\t\tlambda\n\t\tkappa\n\tdelta\n\tbeta\nalpha\n\ttheta\n\tiota\n\tepsilon\n```\n\nThe output sequence of an ascending lexical sort of each level should be:\n\n```\nalpha\n    epsilon\n    iota\n    theta\nzeta\n    beta\n    delta\n    gamma\n        kappa\n        lambda\n        mu\n```\n\nThe output sequence of a descending lexical sort of each level should be:\n\n```\nzeta\n    gamma\n        mu\n        lambda\n        kappa\n    delta\n    beta\nalpha\n    theta\n    iota\n    epsilon\n```\n\n* Attempt to separately sort each of the following two outlines, reporting any inconsistencies detected in their indentations by your validation code.\n\n```\nalpha\n    epsilon\n\tiota\n    theta\nzeta\n    beta\n    delta\n    gamma\n    \tkappa\n        lambda\n        mu\n```\n\n```\nzeta\n    beta\n   gamma\n        lambda\n         kappa\n        mu\n    delta\nalpha\n    theta\n    iota\n    epsilon\n```\n\nRelated tasks\n\n:   * Functional\\_coverage\\_tree\n    * Display\\_an\\_outline\\_as\\_a\\_nested\\_table"}, {"role": "assistant", "content": "Rather than a monolithic verify-and-sort-and-print routine, implement as a series of routines that can be chained together or used separately as desired.\n\n* Routine to check indent characters and return the indent white-space if it is consistent.\n\n* Routine to import a text \"outline\" into a native data structure\n\n* Routine(s) to output the data structure in the desire sort order.\n\n```\nmy @tests = q:to/END/.split( /\\n\\n+/ )».trim;\nzeta\n    beta\n    gamma\n        lambda\n        kappa\n        mu\n    delta\nalpha\n    theta\n    iota\n    epsilon\n\nzeta\n\tgamma\n\t\tmu\n\t\tlambda\n\t\tkappa\n\tdelta\n\tbeta\nalpha\n\ttheta\n\tiota\n\tepsilon\n\nalpha\n    epsilon\n\tiota\n    theta\nzeta\n    beta\n    delta\n    gamma\n    \tkappa\n        lambda\n        mu\n\nzeta\n    beta\n   gamma\n        lambda\n         kappa\n        mu\n    delta\nalpha\n    theta\n    iota\n    epsilon\nEND\n\nfor @tests -> $t {\n    say \"{'=' x 55}\\nUnsorted:\\n$t\";\n    my $indent = try detect-indent $t;\n    next unless $indent;\n    say \"\\nSorted ascending:\";\n    pretty-print import($t, :level($indent) ).List, :ws($indent);\n    say \"\\nSorted descending:\";\n    pretty-print import($t, :level($indent) ).List, :ws($indent), :desc;\n}\n\nsub detect-indent ($text) {\n    my $consistent = $text.lines.map(* ~~ / ^ (\\h*) /).join.comb.Set;\n    note \"\\nUnwilling to continue; Inconsistent indent characters.\" and return '' if +$consistent > 1;\n    my @ws = $text.lines.map: (* ~~ / ^ (\\h*) /)».Str;\n    my $indent = @ws.grep( *.chars > 0 ).min.first;\n    note \"\\nUnwilling to continue; Inconsistent indentation.\" and return '' unless all\n      @ws.map: { next unless .[0]; (.[0].chars %% $indent.chars) }\n    $indent\n}\n\nsub import (Str $trees, :$level) {\n    my $forest = '[';\n    my $last = -Inf;\n    for $trees.lines -> $branch {\n        $branch ~~ / ($($level))* /;\n        my $this = +$0;\n        $forest ~= do {\n            given $this cmp $last {\n                when More { (?$this ?? q[ => \\[ ] !! \"\" )~ \"'{$branch.trim}'\" }\n                when Same { \", '{$branch.trim}'\" }\n                when Less { \"{']' x $last - $this}, '{$branch.trim}' \" }\n            }\n        }\n        $last = $this;\n    }\n    $forest ~= ']' x 1 + $last;\n    use MONKEY-SEE-NO-EVAL;\n    $forest.EVAL;\n}\n\nmulti pretty-print (List $struct, :$level = 0, :$ws = '    ', :$desc = False) {\n    if $desc {\n        pretty-print($_, :level($level), :$ws, :$desc ) for $struct.flat.sort.reverse.List\n    } else {\n        pretty-print($_, :level($level), :$ws, :$desc ) for $struct.flat.sort.List\n    }\n}\n\nmulti pretty-print (Pair $struct, :$level = 0, :$ws = '    ', :$desc = False) {\n    say $ws x $level, $struct.key;\n    pretty-print( $struct.value.sort( ).List, :level($level + 1), :$ws, :$desc )\n}\n\nmulti pretty-print (Str $struct, :$level = 0, :$ws = '    ', :$desc = False) {\n    say $ws x $level , $struct;\n}\n\n```\n\nOutput:\n\n```\n=======================================================\nUnsorted:\nzeta\n    beta\n    gamma\n        lambda\n        kappa\n        mu\n    delta\nalpha\n    theta\n    iota\n    epsilon\n\nSorted ascending:\nalpha\n    epsilon\n    iota\n    theta\nzeta\n    beta\n    delta\n    gamma\n        kappa\n        lambda\n        mu\n\nSorted descending:\nzeta\n    gamma\n        mu\n        lambda\n        kappa\n    delta\n    beta\nalpha\n    theta\n    iota\n    epsilon\n=======================================================\nUnsorted:\nzeta\n\tgamma\n\t\tmu\n\t\tlambda\n\t\tkappa\n\tdelta\n\tbeta\nalpha\n\ttheta\n\tiota\n\tepsilon\n\nSorted ascending:\nalpha\n\tepsilon\n\tiota\n\ttheta\nzeta\n\tbeta\n\tdelta\n\tgamma\n\t\tkappa\n\t\tlambda\n\t\tmu\n\nSorted descending:\nzeta\n\tgamma\n\t\tmu\n\t\tlambda\n\t\tkappa\n\tdelta\n\tbeta\nalpha\n\ttheta\n\tiota\n\tepsilon\n=======================================================\nUnsorted:\nalpha\n    epsilon\n\tiota\n    theta\nzeta\n    beta\n    delta\n    gamma\n    \tkappa\n        lambda\n        mu\n\nUnwilling to continue; Inconsistent indent characters.\n=======================================================\nUnsorted:\nzeta\n    beta\n   gamma\n        lambda\n         kappa\n        mu\n    delta\nalpha\n    theta\n    iota\n    epsilon\n\nUnwilling to continue; Inconsistent indentation.\n```"}]}
{"messages": [{"role": "user", "content": "Given a list of values and a set of integer indices into that value list, the task is to sort the values at the given indices, while preserving the values at indices outside the set of those to be sorted.\n\nMake your example work with the following list of values and set of indices:\n\n:   :   Values: `[7, 6, 5, 4, 3, 2, 1, 0]`\n\n:   :   Indices: `{6, 1, 7}`\n\nWhere the correct result would be:\n\n:   :   `[7, 0, 5, 4, 3, 2, 1, 6]`.\n\nIn case of one-based indexing, rather than the zero-based indexing above, you would use the indices `{7, 2, 8}` instead.\n\nThe indices are described as a set rather than a list but any collection-type of those indices without duplication may be used as long as the example is insensitive to the order of indices given.\n\nCf.\n\n* Order disjoint list items"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\n### Inline\n\nUsing L-value slice of the array, and `sort` as a mutating method:\n\n```\nmy @values  = 7, 6, 5, 4, 3, 2, 1, 0;\nmy @indices = 6, 1, 7;\n\n@values[ @indices.sort ] .= sort;\n\nsay @values;\n\n```\n\nOutput:\n\n```\n[7, 0, 5, 4, 3, 2, 1, 6]\n```\n\n### Iterative\n\n```\nsub disjointSort( @values, @indices --> List ) {\n   my @sortedValues = @values[ @indices ].sort ;\n   for @indices.sort -> $insert {\n      @values[ $insert ] = @sortedValues.shift ;\n   }\n   return @values ;\n}\n\nmy @values = ( 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0 ) ;\nmy @indices = ( 6 , 1 , 7 ) ;\nmy @sortedValues = disjointSort( @values , @indices ) ;\nsay @sortedValues ;\n\n```\n\nOutput:\n\n```\n[7, 0, 5, 4, 3, 2, 1, 6]\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven an integer   **n**,   return   **1──►n**   (inclusive)   in lexicographical order.\n\nShow all output here on this page.\n\nExample\n\nGiven   **13**,\n  \nreturn:   **[1,10,11,12,13,2,3,4,5,6,7,8,9].**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.06\n\nIt is somewhat odd that the task name is sort **numbers** lexicographically but immediately backtracks in the task header to sorting **integers** lexicographically. Why only integers? This will sort ANY real numbers lexicographically. For a non-integer, assumes that the given number is a hard boundary and 1 is a \"soft\" boundary. E.G. The given number is definitely included; 1 is only a threshold, it is included if it matches exactly. (Could be the other way around, this it the way I choose.)\n\n```\nsub lex (Real $n, $step = 1) {\n    ($n < 1 ?? ($n, * + $step …^ * > 1)\n            !! ($n, * - $step …^ * < 1)).sort: ~*\n}\n\n# TESTING\nfor 13, 21, -22, (6, .333), (-4, .25), (-5*π, e) {\n    my ($bound, $step) = |$_, 1;\n    say \"Boundary:$bound, Step:$step >> \", lex($bound, $step).join: ', ';\n}\n\n```\n\nOutput:\n\n```\nBoundary:13, Step:1 >> 1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9\nBoundary:21, Step:1 >> 1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 3, 4, 5, 6, 7, 8, 9\nBoundary:-22, Step:1 >> -1, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -2, -20, -21, -22, -3, -4, -5, -6, -7, -8, -9, 0, 1\nBoundary:6, Step:0.333 >> 1.005, 1.338, 1.671, 2.004, 2.337, 2.67, 3.003, 3.336, 3.669, 4.002, 4.335, 4.668, 5.001, 5.334, 5.667, 6\nBoundary:-4, Step:0.25 >> -0.25, -0.5, -0.75, -1, -1.25, -1.5, -1.75, -2, -2.25, -2.5, -2.75, -3, -3.25, -3.5, -3.75, -4, 0, 0.25, 0.5, 0.75, 1\nBoundary:-15.707963267948966, Step:2.718281828459045 >> -10.271399611030876, -12.989681439489921, -15.707963267948966, -2.116554125653742, -4.834835954112787, -7.553117782571832, 0.6017277028053032\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nLet given list:\n  \nPrimes = [2,43,81,122,63,13,7,95,103]\n  \nShow on this page the ascending ordered list of primes from given list."}, {"role": "assistant", "content": "```\nput <2 43 81 122 63 13 7 95 103>.grep( &is-prime ).sort\n\n```\n\nOutput:\n\n```\n2 7 13 43 103\n```\n\n*Of course \"ascending\" is a little ambiguous. That ^^^ is numerically. This vvv is lexicographically.*\n\n```\nput <2 43 81 122 63 13 7 95 103>.grep( &is-prime ).sort: ~*\n\n```\n\nOutput:\n\n```\n103 13 2 43 7\n```"}]}
{"messages": [{"role": "user", "content": "When sorting records in a table by a particular column or field, a stable sort will always retain the relative order of records that have the same key.\n\nExample\n\nIn this table of countries and cities, a stable sort on the *second* column, the cities, would keep the   **US Birmingham**   above the   **UK Birmingham**.\n\n(Although an unstable sort *might*, in this case, place the   **US Birmingham**   above the   **UK Birmingham**,   a stable sort routine would *guarantee* it).\n\n```\nUK  London\nUS  New York\nUS  Birmingham\nUK  Birmingham\n\n```\n\nSimilarly, stable sorting on just the first column would generate **UK London** as the first item and **US Birmingham** as the last item   (since the order of the elements having the same first word –   **UK** or **US**   – would be maintained).\n\nTask\n:   1. Examine the documentation on any in-built sort routines supplied by a language.\n    2. Indicate if an in-built routine is supplied\n    3. If supplied, indicate whether or not the in-built routine is stable.\n\n(This Wikipedia table shows the stability of some common sort routines)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe sort built-in (available as sub and method) is stable.\n\nShort demonstration for sorting only on the second item of each array:\n\n```\nuse v6;\nmy @cities =\n    ['UK', 'London'],\n    ['US', 'New York'],\n    ['US', 'Birmingham'],\n    ['UK', 'Birmingham'],\n    ;\n\n.say for @cities.sort: { .[1] };\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function/program/subroutine/procedure to sort the characters of a string in lexicographical order.\n\nA *character* for this purpose should be whatever is natural for your language.\n\nShow the results here on this page.   White-space may be optionally removed.\n\nThe case   (uppercase and lowercase)   of any letters should be preserved.\n\nWrite the function even if your language has a built-in function for it."}, {"role": "assistant", "content": "### Semi-realistic version\n\n```\nsub sort_within_string ( $_ is copy ) {\n    constant @lexographic_order = sort *.fc, map &chr, 1..255;\n\n    return join '', gather for @lexographic_order -> $l {\n        my $count = s:g/$l//;\n        take $l x $count;\n        LAST { warn \"Original string had non-ASCII chars: {.raku}\" if .chars }\n    }\n}\nsay trim .&sort_within_string for q:to/END/.lines;\nThe quick brown fox jumps over the lazy dog, apparently\nNow is the time for all good men to come to the aid of their country.\nEND\n\n```\n\nOutput:\n\n```\n,aaabcdeeeefghhijkllmnnoooopppqrrrsTttuuvwxyyz\n.aaccddeeeeeeffghhhiiiillmmmNnnooooooooorrrstttttttuwy\n\n```\n\n### Following the actual task title / description\n\nFollowing a strict interpretation of the actual task title and description.\n\n* Sorts letters. Only letters. Into alphabetical order. Regardless of case. **EVERYTHING** else is ignored / pushed to the end of the \"sorted\" string. Not **ASCII** order. Not **EBCDIC** order. Only **alphabetical** order. If it ain't in the alphabet, it ain't sorted.\n* Sorts letters of the string two characters at a time **as a string**. No breaking up the string into a list or array, sorting that then joining back together; or picking characters out of a string to generate a new string. Sorts a string, as a string, in place.\n\nSorted output is wrapped in double guillemots to make it easier to see where it starts and ends.\n\n```\nsub moronic-sort ($string is copy) {\n    my $chars = $string.chars;\n    loop {\n        for ^$chars {\n            if ($string.substr($_, 1).fc gt $string.substr($_ + 1, 1).fc and $string.substr($_ + 1, 1) ~~ /<:L>/)\n               or $string.substr($_, 1) ~~ /<:!L>/ {\n                $string = $string.substr(0, $_) ~ $string.substr($_ , 2).flip ~ $string.substr($_ + 2 min $chars);\n            }\n        }\n        last if $++ >= $chars;\n    }\n    $string\n}\n\nsub wrap ($whatever) { '»»' ~ $whatever ~ '««' }\n\n\n# Test sort the exact string as specified in the task title.\nsay \"moronic-sort 'string'\\n\" ~ wrap moronic-sort 'string';\n\n\n# Other tests demonstrating the extent of the stupidity of this task.\nsay \"\\nLonger test sentence\\n\" ~ \nwrap moronic-sort q[This is a moronic sort. It's only concerned with sorting letters, so everything else is pretty much ignored / pushed to the end. It also doesn't much care about letter case, so there is no upper / lower case differentiation.];\n\n\nsay \"\\nExtended test string:\\n\" ~ my $test = (32..126)».chr.pick(*).join;\nsay wrap moronic-sort $test;\n\n```\n\nOutput:\n\n```\nmoronic-sort 'string'\n»»ginrst««\n\nLonger test sentence\n»»aaaaaaabccccccccddddddeeeeeeeeeeeeeeeeeeeeeeeeeffggghhhhhhhhiiiIiiiiiIiiiillllllmmmnnnnnnnnnnnnoooooooooooooooopppprrrrrrrrrrrrrrssssssssssssssssTtttttttttttttttttttuuuuuvwwyyy    ,      /   .    . '     ,        /    .   ' ««\n\nExtended test string:\n!kjyxAa+,LGh_8?3lXEwW-D]Ku|SY[@VF\\.op{=q>MT 1tJ/$nN(Z*%&9^v57\")`PCiOHQe'RUb<gs;6}#cfmrzd42B~0I:\n»»AabBCcDdEeFfGghHiIjJkKLlMmnNoOpPqQRrSsTtuUVvwWxXyYZz[@\\.{=> 1/$(*%&9^57\")`'<;6}#42~0:!+,_8?3-]|««\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSort   (the values of)   three variables   (**X**,   **Y**,   and   **Z**)   that contain any value   (numbers and/or literals).\n\nIf that isn't possible in your language, then just sort numbers   (and note if they can be floating point, integer, or other).\n\nI.E.:   (for the three variables   **x**,   **y**,   and   **z**),   where:\n\n```\n                        x =  'lions, tigers, and'\n                        y =  'bears, oh my!'\n                        z =  '(from the \"Wizard of OZ\")'\n\n```\n\nAfter sorting, the three variables would hold:\n\n```\n                        x =  '(from the \"Wizard of OZ\")'\n                        y =  'bears, oh my!'\n                        z =  'lions, tigers, and'\n\n```\n\nFor numeric value sorting, use:\nI.E.:   (for the three variables   **x**,   **y**,   and   **z**),   where:\n\n```\n                        x =  77444\n                        y =    -12\n                        z =      0\n\n```\n\nAfter sorting, the three variables would hold:\n\n```\n                        x =    -12\n                        y =      0\n                        z =  77444\n\n```\n\nThe variables should contain some form of a number, but specify if the algorithm\nused can be for floating point or integers.   Note any limitations.\n\nThe values may or may not be unique.\n\nThe method used for sorting can be any algorithm;   the goal is to use the most idiomatic in the computer programming language used.\n\nMore than one algorithm could be shown if one isn't clearly the better choice.\n\nOne algorithm could be:\n\n```\n                        •  store the three variables   x, y, and z\n                                 into an array (or a list)   A\n                         \n                        •  sort  (the three elements of)  the array   A\n                         \n                        •  extract the three elements from the array and place them in the\n                                 variables x, y, and z   in order of extraction\n\n```\n\nAnother algorithm   (only for numeric values):\n\n```\n       x= 77444 \n       y=   -12 \n       z=     0      \n    low= x                                          \n    mid= y                                          \n   high= z \n      x= min(low,  mid,  high)            /*determine the lowest value of X,Y,Z. */    \n      z= max(low,  mid,  high)            /*    \"      \"  highest  \"    \" \" \" \"  */    \n      y=     low + mid + high - x - z     /*    \"      \"  middle   \"    \" \" \" \"  */      \n\n```\n\nShow the results of the sort here on this page using at least the values of those shown above."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku has a built in sort routine which uses a variation of quicksort. The built in sort routine will automatically select a numeric sort if given a list of Real numeric items and a lexical Unicode sort if given a list that contains strings. The default numeric sort won't sort complex numbers unless you give it a custom comparator. It is trivial to modify the sort comparator function to get whatever ordering you want though.\n\nThe list (77444, -12, 0) is a poor choice to demonstrate numeric sort since it will sort the same numerically or lexically. Instead we'll use (7.7444e4, -12, 18/2). ( A Num, an Int, and a Rat. )\n\n```\n# Sorting strings. Added a vertical bar between strings to make them discernable\nmy ($a, $b, $c) = 'lions, tigers, and', 'bears,  oh my!', '(from \"The Wizard of Oz\")';\nsay \"sorting: {($a, $b, $c).join('|')}\";\nsay ($a, $b, $c).sort.join('|'), ' - standard lexical string sort';\n\n# Sorting numeric things\nmy ($x, $y, $z) = 7.7444e4, -12, 18/2;\nsay \"\\nsorting: $x $y $z\";\nsay ($x, $y, $z).sort, ' - standard numeric sort, low to high';\n\n# Or, with a modified comparitor:\nfor  -*,       ' - numeric sort high to low',\n     ~*,       ' - lexical \"string\" sort',\n     *.chars,  ' - sort by string length short to long',\n     -*.chars, ' - or long to short'\n  -> $comparitor, $type {\n    my ($x, $y, $z) = 7.7444e4, -12, 18/2;\n    say ($x, $y, $z).sort( &$comparitor ), $type;\n}\nsay '';\n\n# sort ALL THE THINGS\n# sorts by lexical order with numeric values by magnitude.\n.say for ($a, $b, $c, $x, $y, $z).sort;\n\n```\n\nOutput:\n\n```\nsorting: lions, tigers, and|bears,  oh my!|(from \"The Wizard of Oz\")\n(from \"The Wizard of Oz\")|bears,  oh my!|lions, tigers, and - standard lexical string sort\n\nsorting: 77444 -12 9\n(-12 9 77444) - standard numeric sort, low to high\n(77444 9 -12) - numeric sort high to low\n(-12 77444 9) - lexical \"string\" sort\n(9 -12 77444) - sort by string length short to long\n(77444 -12 9) - or long to short\n\n(from \"The Wizard of Oz\")\n-12\n9\n77444\nbears,  oh my!\nlions, tigers, and\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSort an array (or list) of strings in order of descending length, and in ascending lexicographic order for strings of equal length.\n\nUse a sorting facility provided by the language/library, combined with your own callback comparison function.\n\n**Note:**   Lexicographic order is case-insensitive."}, {"role": "assistant", "content": "(formerly Perl 6)  \nPrimary sort by length of string, then break ties by sorting alphabetically (ignoring case).\n\n```\nmy @strings = <Here are some sample strings to be sorted>;\nput @strings.sort:{.chars, .lc};\nput sort -> $x { $x.chars, $x.lc }, @strings;\n\n```\n\nOutput:\n\n```\nbe to are Here some sample sorted strings\nbe to are Here some sample sorted strings\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSort an array of positive integers using the Bead Sort Algorithm.\n\nA   *bead sort*   is also known as a   *gravity sort*.\n\nAlgorithm has   O(S),   where   S   is the sum of the integers in the input set:   Each bead is moved individually.\n\nThis is the case when bead sort is implemented without a mechanism to assist in finding empty spaces below the beads, such as in software implementations."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016-05\n\n**Translation of**: Haskell\n\n```\n# routine cribbed from List::Utils;\nsub transpose(@list is copy) {\n    gather {\n        while @list {\n            my @heads;\n            if @list[0] !~~ Positional { @heads = @list.shift; }\n            else { @heads = @list.map({$_.shift unless $_ ~~ []}); }\n            @list = @list.map({$_ unless $_ ~~ []});\n            take [@heads];\n        }\n    }\n}\n\nsub beadsort(@l) {\n    (transpose(transpose(map {[1 xx $_]}, @l))).map(*.elems);\n}\n\nmy @list = 2,1,3,5;\nsay beadsort(@list).perl;\n\n```\n\nOutput:\n\n```\n(5, 3, 2, 1)\n```\n\nHere we simulate the dropping beads by using the push method.\n\n```\nsub beadsort(*@list) {\n    my @rods;\n    for words ^«@list -> $x { @rods[$x].push(1) }\n    gather for ^@rods[0] -> $y {\n        take [+] @rods.map: { .[$y] // last }\n    }\n}\n\nsay beadsort 2,1,3,5;\n\n```\n\nThe ^ is the \"upto\" operator that gives a range of 0 up to (but not including) its endpoint. We use it as a hyperoperator (^«) to generate all the ranges of rod numbers we should drop a bead on, with the result that $x tells us which rod to drop each bead on. Then we use ^ again on the first rod to see how deep the beads are stacked, since they are guaranteed to be the deepest there. The [+] adds up all the beads that are found at level $y. The last short circuits the map so we don't have to look for all the missing beads at a given level, since the missing beads are all guaranteed to come after the existing beads at that level (because we always dropped left to right starting at rod 0)."}]}
{"messages": [{"role": "user", "content": "Task\n\nBogosort a list of numbers.\n\nBogosort simply shuffles a collection randomly until it is sorted.\n\n\"Bogosort\" is a perversely inefficient algorithm only used as an in-joke.\n\nIts average run-time is   O(n!)   because the chance that any given shuffle of a set will end up in sorted order is about one in   *n*   factorial,   and the worst case is infinite since there's no guarantee that a random shuffling will ever produce a sorted sequence.\n\nIts best case is   O(n)   since a single pass through the elements may suffice to order them.\n\nPseudocode:\n\n```\nwhile not InOrder(list) do\n   Shuffle(list)\ndone\n\n```\n\nThe Knuth shuffle may be used to implement the shuffle part of this algorithm."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub bogosort (@list is copy) {\n    @list .= pick(*) until [<=] @list;\n    return @list;\n}\n\nmy @nums = (^5).map: { rand };\nsay @nums.sort.Str eq @nums.&bogosort.Str ?? 'ok' !! 'not ok';\n\n```"}]}
{"messages": [{"role": "user", "content": "A   **bubble**   sort is generally considered to be the simplest sorting algorithm.\n\nA   **bubble**   sort is also known as a   **sinking**   sort.\n\nBecause of its simplicity and ease of visualization, it is often taught in introductory computer science courses.\n\nBecause of its abysmal O(n2) performance, it is not used often for large (or even medium-sized) datasets.\n\nThe bubble sort works by passing sequentially over a list, comparing each value to the one immediately after it.   If the first value is greater than the second, their positions are switched.   Over a number of passes, at most equal to the number of elements in the list, all of the values drift into their correct positions (large values \"bubble\" rapidly toward the end, pushing others down around them).  \nBecause each pass finds the maximum item and puts it at the end, the portion of the list to be sorted can be reduced at each pass.  \nA boolean variable is used to track whether any changes have been made in the current pass; when a pass completes without changing anything, the algorithm exits.\n\nThis can be expressed in pseudo-code as follows (assuming 1-based indexing):\n\n```\nrepeat\n    if itemCount <= 1\n        return\n    hasChanged := false\n    decrement itemCount\n    repeat with index from 1 to itemCount\n        if (item at index) > (item at (index + 1))\n            swap (item at index) with (item at (index + 1))\n            hasChanged := true\nuntil hasChanged = false\n\n```\n\nTask\n\nSort an array of elements using the bubble sort algorithm.   The elements must have a total order and the index of the array can be of any discrete type.   For languages where this is not possible, sort an array of integers.\n\nReferences\n\n* The article on Wikipedia.\n* Dance interpretation."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #24 \"Seoul\"\n\n```\nsub bubble_sort (@a) {\n    for ^@a -> $i {\n        for $i ^..^ @a -> $j {\n            @a[$j] < @a[$i] and @a[$i, $j] = @a[$j, $i];\n        }\n    }\n}\n```"}]}
{"messages": [{"role": "user", "content": "Sort an array of integers (of any convenient size) into ascending order using Circlesort.\n\nIn short, compare the first element to the last element, then the second element to the second last element, etc.\n\nThen split the array in two and recurse until there is only one single element in the array, like this:\n\n```\nBefore:\n6 7 8 9 2 5 3 4 1\nAfter:\n1 4 3 5 2 9 8 7 6\n\n```\n\nRepeat this procedure until quiescence (i.e. until there are no swaps).\n\nShow both the initial, unsorted list and the final sorted list. (Intermediate steps during sorting are optional.)\n\nOptimizations (like doing *0.5 log2(n)* iterations and then continue with an Insertion sort) are optional.\n\nPseudo code:\n\n```\n function circlesort (index lo, index hi, swaps)\n {\n   if lo == hi return (swaps)\n   high := hi\n   low := lo\n   mid := int((hi-lo)/2)\n   while lo < hi {\n     if  (value at lo) > (value at hi) {\n        swap.values (lo,hi)\n        swaps++\n     }\n     lo++\n     hi--\n   }\n   if lo == hi\n     if (value at lo) > (value at hi+1) {\n         swap.values (lo,hi+1)\n         swaps++\n     }\n   swaps := circlesort(low,low+mid,swaps)\n   swaps := circlesort(low+mid+1,high,swaps)\n   return(swaps)\n }\n while circlesort (0, sizeof(array)-1, 0)\n\n```\n\nSee also\n\n* For more information on Circle sorting, see Sourceforge."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThe given algorithm can be simplified in several ways. There's no need to compute the midpoint, since the hi/lo will end up there. The extra swap conditional can be eliminated by incrementing hi at the correct moment inside the loop. There's no need to\npass accumulated swaps down the call stack.\n\nThis does generic comparisons, so it works on any ordered type, including numbers or strings.\n\n```\nsub circlesort (@x, $beg, $end) {\n    my $swaps = 0;\n    if $beg < $end {\n        my ($lo, $hi) = $beg, $end;\n        repeat {\n            if @x[$lo] after @x[$hi] {\n                @x[$lo,$hi] .= reverse;\n                ++$swaps;\n            }\n            ++$hi if --$hi == ++$lo\n        } while $lo < $hi;\n        $swaps += circlesort(@x, $beg, $hi);\n        $swaps += circlesort(@x, $lo, $end);\n    }\n    $swaps;\n}\n\nsay my @x = (-100..100).roll(20);\nsay @x while circlesort(@x, 0, @x.end);\n\nsay @x = <The quick brown fox jumps over the lazy dog.>;\nsay @x while circlesort(@x, 0, @x.end);\n\n```\n\nOutput:\n\n```\n16 35 -64 -29 46 36 -1 -99 20 100 59 26 76 -78 39 85 -7 -81 25 88\n-99 -78 16 20 36 -81 -29 46 25 59 -64 -7 39 26 88 -1 35 85 76 100\n-99 -78 -29 -81 16 -64 -7 20 -1 39 25 26 36 46 59 35 76 88 85 100\n-99 -81 -78 -64 -29 -7 -1 16 20 25 26 35 36 39 46 59 76 85 88 100\nThe quick brown fox jumps over the lazy dog.\nThe brown fox jumps lazy dog. quick over the\nThe brown dog. fox jumps lazy over quick the\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Cocktail sort. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThe cocktail shaker sort is an improvement on the Bubble Sort.\n\nThe improvement is basically that values \"bubble\" both directions through the array, because on each iteration the cocktail shaker sort bubble sorts once forwards and once backwards. Pseudocode for the algorithm (from wikipedia):\n\n```\nfunction cocktailSort( A : list of sortable items )\n do\n   swapped := false\n   for each i in 0 to length( A ) - 2 do\n     if A[ i ] > A[ i+1 ] then // test whether the two \n                               // elements are in the wrong \n                               // order\n       swap( A[ i ], A[ i+1 ] ) // let the two elements\n                                // change places\n       swapped := true;\n   if swapped = false then\n     // we can exit the outer loop here if no swaps occurred.\n     break do-while loop;\n   swapped := false\n   for each i in length( A ) - 2 down to 0 do\n     if A[ i ] > A[ i+1 ] then\n       swap( A[ i ], A[ i+1 ] )\n       swapped := true;\n while swapped; // if no elements have been swapped, \n                // then the list is sorted\n\n```\n\nRelated task\n:   * cocktail sort with shifting bounds"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub cocktail_sort ( @a ) {\n    my $range = 0 ..^ @a.end;\n    loop {\n        my $swapped_forward = 0;\n        for $range.list -> $i {\n            if @a[$i] > @a[$i+1] {\n                @a[ $i, $i+1 ] .= reverse;\n                $swapped_forward = 1;\n            } \n        }\n        last if not $swapped_forward;\n\n        my $swapped_backward = 0;\n        for $range.reverse -> $i {\n            if @a[$i] > @a[$i+1] {\n                @a[ $i, $i+1 ] .= reverse;\n                $swapped_backward = 1;\n            }\n        }\n        last if not $swapped_backward;\n    }\n    return @a;\n}\n\nmy @weights = (^50).map: { 100 + ( 1000.rand.Int / 10 ) };\nsay @weights.sort.Str eq @weights.&cocktail_sort.Str ?? 'ok' !! 'not ok';\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Cocktail sort. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nThe   cocktail sort   is an improvement on the   Bubble Sort.\n\nA cocktail sort is also known as:\n\n:   :   :   :   * cocktail shaker sort\n                * happy hour sort\n                * bidirectional bubble sort\n                * a bubble sort variation\n                * a selection sort variation\n                * ripple sort\n                * shuffle sort\n                * shuttle sort\n\nThe improvement is basically that values \"bubble\"   (migrate)   both directions through the\narray,   because on each iteration the cocktail sort   *bubble sorts*   once\nforwards and once backwards.\n\nAfter   *ii*   passes,   the first   *ii*   and the\nlast   *ii*   elements in the array are in their correct\npositions,   and don't have to be checked (again).\n\nBy shortening the part of the array that is sorted each time,   the number of\ncomparisons can be halved.\n\nPseudocode for the    2nd    algorithm   (from\nWikipedia)   with an added comment and changed indentations:\n\n```\nfunction A = cocktailShakerSort(A)\n% `beginIdx` and `endIdx` marks the first and last index to check.\nbeginIdx = 1;\nendIdx = length(A) - 1;\n\n    while beginIdx <= endIdx\n    newBeginIdx = endIdx;\n    newEndIdx = beginIdx;\n        for ii = beginIdx:endIdx\n            if A(ii) > A(ii + 1)\n                [A(ii+1), A(ii)] = deal(A(ii), A(ii+1));\n                newEndIdx = ii;\n            end\n        end\n\n    % decreases `endIdx` because the elements after `newEndIdx` are in correct order\n    endIdx = newEndIdx - 1;\n\n    % (FOR  (below)  decrements the  II  index by -1.\n\n        for ii = endIdx:-1:beginIdx\n            if A(ii) > A(ii + 1)\n                [A(ii+1), A(ii)] = deal(A(ii), A(ii+1));\n                newBeginIdx = ii;\n            end\n        end\n\n    % increases `beginIdx` because the elements before `newBeginIdx` are in correct order.\n    beginIdx = newBeginIdx + 1;\n    end\nend\n\n```\n\n**%**   indicates a comment,   and   **deal**   indicates a   *swap*.\n\nTask\n\nImplement a   *cocktail sort*   and optionally show the sorted output here on this page.\n\nSee the   *discussion*   page for some timing comparisons.\n\nRelated task\n:   * cocktail sort"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.05\n\n```\nsub cocktail_sort ( @a ) {\n    my ($min, $max) = 0, +@a - 2;\n    loop {\n        my $swapped_forward = 0;\n        for $min .. $max -> $i {\n            given @a[$i] cmp @a[$i+1] {\n                when More {\n                    @a[ $i, $i+1 ] .= reverse;\n                    $swapped_forward = 1\n                }\n                default {}\n            }\n        }\n        last if not $swapped_forward;\n        $max -= 1;\n\n        my $swapped_backward = 0;\n        for ($min .. $max).reverse -> $i {\n            given @a[$i] cmp @a[$i+1] {\n                when More {\n                    @a[ $i, $i+1 ] .= reverse;\n                    $swapped_backward = 1\n                }\n                default {}\n            }\n        }\n        last if not $swapped_backward;\n        $min += 1;\n    }\n    @a\n}\n\nmy @weights = (flat 0..9, 'A'..'F').roll(2 + ^4 .roll).join xx 100;\nsay @weights.sort.Str eq @weights.&cocktail_sort.Str ?? 'ok' !! 'not ok';\n\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nTask\n\nImplement a   *comb sort*.\n\nThe **Comb Sort** is a variant of the Bubble Sort.\n\nLike the Shell sort, the Comb Sort increases the gap used in comparisons and exchanges.\n\nDividing the gap by   \n\n(\n1\n−\n\ne\n\n−\nφ\n\n)\n\n−\n1\n≈\n1.247330950103979\n{\\displaystyle {\\displaystyle (1-e^{-\\varphi })^{-1}\\approx 1.247330950103979}}\n    works best, but    1.3   may be more practical.\n\nSome implementations use the insertion sort once the gap is less than a certain amount.\n\nAlso see\n\n* the Wikipedia article:   Comb sort.\n\nVariants:\n\n* Combsort11 makes sure the gap ends in (11, 8, 6, 4, 3, 2, 1), which is significantly faster than the other two possible endings.\n* Combsort with different endings changes to a more efficient sort when the data is almost sorted (when the gap is small).   Comb sort with a low gap isn't much better than the Bubble Sort.\n\nPseudocode:\n\n```\nfunction combsort(array input)\n    gap := input.size //initialize gap size\n    loop until gap = 1 and swaps = 0\n        //update the gap value for a next comb. Below is an example\n        gap := int(gap / 1.25)\n        if gap < 1\n          //minimum gap is 1\n          gap := 1\n        end if\n        i := 0\n        swaps := 0 //see Bubble Sort for an explanation\n        //a single \"comb\" over the input list\n        loop until i + gap >= input.size //see Shell sort for similar idea\n            if input[i] > input[i+gap]\n                swap(input[i], input[i+gap])\n                swaps := 1 // Flag a swap has occurred, so the\n                           // list is not guaranteed sorted\n            end if\n            i := i + 1\n        end loop\n    end loop\nend function\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nsub comb_sort ( @a is copy ) {\n    my $gap = +@a;\n    my $swaps = 1;\n    while $gap > 1 or $swaps {\n        $gap = ( ($gap * 4) div 5 ) || 1 if $gap > 1;\n\n        $swaps = 0;\n        for ^(+@a - $gap) -> $i {\n            my $j = $i + $gap;\n            if @a[$i] > @a[$j] {\n                @a[$i, $j] .= reverse;\n                $swaps = 1;\n            }\n        }\n    }\n    return @a;\n}\n\nmy @weights = (^50).map: { 100 + ( 1000.rand.Int / 10 ) };\nsay @weights.sort.Str eq @weights.&comb_sort.Str ?? 'ok' !! 'not ok';\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Counting sort. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nImplement the Counting sort.   This is a way of sorting integers when the minimum and maximum value are known.\n\nPseudocode\n\n```\nfunction countingSort(array, min, max):\n    count: array of (max - min + 1) elements\n    initialize count with 0\n    for each number in array do\n        count[number - min] := count[number - min] + 1\n    done\n    z := 0\n    for i from min to max do\n        while ( count[i - min] > 0 ) do\n            array[z] := i\n            z := z+1\n            count[i - min] := count[i - min] - 1\n        done\n    done\n\n```\n\nThe *min* and *max* can be computed apart, or be known *a priori*.\n\n**Note**:   we know that, given an array of integers,   its maximum and minimum values can be always found;   but if we imagine the worst case for an array that can hold up to 32 bit integers,   we see that in order to hold the counts,   an array of up to **232** elements may be needed.   I.E.:   we need to hold a count value up to **232-1**,   which is a little over 4.2 Gbytes.   So the counting sort is more practical when the range is (very) limited,   and minimum and maximum values are known   *a priori*.     (However, as a counterexample,   the use of   *sparse arrays*   minimizes the impact of the memory usage,   as well as removing the need of having to know the minimum and maximum values   *a priori*.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n```\nsub counting-sort (@ints) {\n    my $off = @ints.min;\n    (my @counts)[$_ - $off]++ for @ints;\n    flat @counts.kv.map: { ($^k + $off) xx ($^v // 0) }\n}\n\n# Testing:\nconstant @age-range = 2 .. 102;\nmy @ages = @age-range.roll(50);\nsay @ages.&counting-sort;\nsay @ages.sort;\n\nsay @ages.&counting-sort.join eq @ages.sort.join ?? 'ok' !! 'not ok';\n\n```\n\nOutput:\n\n```\n(5 5 5 7 9 17 19 19 20 21 25 27 28 30 32 34 38 40 41 45 48 49 50 51 53 54 55 56 59 62 65 66 67 69 70 73 74 81 83 85 87 91 91 93 94 96 99 99 100 101)\n(5 5 5 7 9 17 19 19 20 21 25 27 28 30 32 34 38 40 41 45 48 49 50 51 53 54 55 56 59 62 65 66 67 69 70 73 74 81 83 85 87 91 91 93 94 96 99 99 100 101)\nok\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Cycle\\_sort. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nFrom the the Wikipedia entry on cycle sorting:\n\n:   **Cycle sort** is an in-place, unstable sorting algorithm, a comparison sort that is theoretically optimal in terms of the total number of writes to the original array, unlike any other in-place sorting algorithm.\n:   It is based on the idea that the permutation to be sorted can be factored into cycles, which can individually be rotated to give a sorted result.\n\n:   Unlike nearly every other sort, items are never written elsewhere in the array simply to push them out of the way of the action.\n:   Each value is either written zero times, if it's already in its correct position, or written one time to its correct position.\n:   This matches the minimal number of overwrites required for a completed in-place sort.\n\n:   Minimizing the number of writes is useful when making writes to some huge data set is very expensive, such as with EEPROMs like Flash memory where each write reduces the lifespan of the memory.\n\nSee also\n\n* Youtube Visualization and audibilization of Cycle Sort algorithm."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub cycle_sort ( @nums ) {\n    my $writes = 0;\n\n    # Loop through the array to find cycles to rotate.\n    for @nums.kv -> $cycle_start, $item is copy {\n\n        # Find where to put the item.\n        my $pos = $cycle_start\n                + @nums[ $cycle_start ^.. * ].grep: * < $item;\n\n        # If the item is already there, this is not a cycle.\n        next if $pos == $cycle_start;\n\n        # Otherwise, put the item there or right after any duplicates.\n        $pos++ while $item == @nums[$pos];\n        ( @nums[$pos], $item ) .= reverse;\n        $writes++;\n\n        # Rotate the rest of the cycle.\n        while $pos != $cycle_start {\n\n            # Find where to put the item.\n            $pos = $cycle_start\n                 + @nums[ $cycle_start ^.. * ].grep: * < $item;\n\n            # Put the item there or right after any duplicates.\n            $pos++ while $item == @nums[$pos];\n            ( @nums[$pos], $item ) .= reverse;\n            $writes++;\n        }\n    }\n\n    return $writes;\n}\n\nmy @a = <0 1 2 2 2 2 1 9 3.5 5 8 4 7 0 6>;\n\nsay @a;\nsay 'writes ', cycle_sort(@a);\nsay @a;\n\n```\n\nOutput:\n\n```\n0 1 2 2 2 2 1 9 3.5 5 8 4 7 0 6\nwrites 10\n0 0 1 1 2 2 2 2 3.5 4 5 6 7 8 9\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Gnome sort. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nGnome sort is a sorting algorithm which is similar to Insertion sort, except that moving an element to its proper place is accomplished by a series of swaps, as in Bubble Sort.\n\nThe pseudocode for the algorithm is:\n\n```\nfunction gnomeSort(a[0..size-1])\n    i := 1\n    j := 2\n    while i < size do\n        if a[i-1] <= a[i] then\n            // for descending sort, use >= for comparison\n            i := j\n            j := j + 1 \n        else\n            swap a[i-1] and a[i]\n            i := i - 1\n            if i = 0 then\n                i := j\n                j := j + 1\n            endif\n        endif\n    done\n\n```\n\nTask\n\nImplement the Gnome sort in your language to sort an array (or list) of numbers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.03\n\n```\nsub gnome_sort (@a) {\n    my ($i, $j) = 1, 2;\n    while $i < @a {\n        if @a[$i - 1] <= @a[$i] {\n            ($i, $j) = $j, $j + 1;\n        }\n        else {\n            (@a[$i - 1], @a[$i]) = @a[$i], @a[$i - 1];\n            $i--;\n            ($i, $j) = $j, $j + 1 if $i == 0;\n        }\n    }\n}\n\nmy @n = (1..10).roll(20);\nsay @n.&gnome_sort ~~ @n.sort ?? 'ok' !! 'not ok';\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Heapsort. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nHeapsort is an in-place sorting algorithm with worst case and average complexity of   O(*n* log*n*).\n\nThe basic idea is to turn the array into a binary heap structure, which has the property that it allows efficient retrieval and removal of the maximal element.\n\nWe repeatedly \"remove\" the maximal element from the heap, thus building the sorted list from back to front.\n\nA heap sort requires random access, so can only be used on an array-like data structure.\n\nPseudocode:\n\n```\nfunction heapSort(a, count) is\n   input: an unordered array a of length count\n \n   (first place a in max-heap order)\n   heapify(a, count)\n \n   end := count - 1\n   while end > 0 do\n      (swap the root(maximum value) of the heap with the\n       last element of the heap)\n      swap(a[end], a[0])\n      (decrement the size of the heap so that the previous\n       max value will stay in its proper place)\n      end := end - 1\n      (put the heap back in max-heap order)\n      siftDown(a, 0, end)\n\n```\n\n```\nfunction heapify(a,count) is\n   (start is assigned the index in a of the last parent node)\n   start := (count - 2) / 2\n   \n   while start ≥ 0 do\n      (sift down the node at index start to the proper place\n       such that all nodes below the start index are in heap\n       order)\n      siftDown(a, start, count-1)\n      start := start - 1\n   (after sifting down the root all nodes/elements are in heap order)\n \nfunction siftDown(a, start, end) is\n   (end represents the limit of how far down the heap to sift)\n   root := start\n\n   while root * 2 + 1 ≤ end do       (While the root has at least one child)\n      child := root * 2 + 1           (root*2+1 points to the left child)\n      (If the child has a sibling and the child's value is less than its sibling's...)\n      if child + 1 ≤ end and a[child] < a[child + 1] then\n         child := child + 1           (... then point to the right child instead)\n      if a[root] < a[child] then     (out of max-heap order)\n         swap(a[root], a[child])\n         root := child                (repeat to continue sifting down the child now)\n      else\n         return\n\n```\n\nWrite a function to sort a collection of integers using heapsort."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub heap_sort ( @list ) {\n    for ( 0 ..^ +@list div 2 ).reverse -> $start {\n        _sift_down $start, @list.end, @list;\n    }\n\n    for ( 1 ..^ +@list ).reverse -> $end {\n        @list[ 0, $end ] .= reverse;\n        _sift_down 0, $end-1, @list;\n    }\n}\n\nsub _sift_down ( $start, $end, @list ) {\n    my $root = $start;\n    while ( my $child = $root * 2 + 1 ) <= $end {\n        $child++ if $child + 1 <= $end and [<] @list[ $child, $child+1 ];\n        return if @list[$root] >= @list[$child];\n        @list[ $root, $child ] .= reverse;\n        $root = $child;\n    }\n}\n\nmy @data = 6, 7, 2, 1, 8, 9, 5, 3, 4;\nsay 'Input  = ' ~ @data;\n@data.&heap_sort;\nsay 'Output = ' ~ @data;\n\n```\n\nOutput:\n\n```\nInput  = 6 7 2 1 8 9 5 3 4\nOutput = 1 2 3 4 5 6 7 8 9\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Insertion sort. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nAn O(*n*2) sorting algorithm which moves elements one at a time into the correct position.\nThe algorithm consists of inserting one element at a time into the previously sorted part of the array, moving higher ranked elements up as necessary.\nTo start off, the first (or smallest, or any arbitrary) element of the unsorted array is considered to be the sorted part.\n\nAlthough insertion sort is an O(*n*2) algorithm, its simplicity, low overhead, good locality of reference and efficiency make it a good choice in two cases:\n\n:   1. small   *n*,\n    2. as the final finishing-off algorithm for O(*n* log*n*) algorithms such as mergesort and quicksort.\n\nThe algorithm is as follows (from wikipedia):\n\n```\nfunction insertionSort(array A)\n    for i from 1 to length[A]-1 do\n        value := A[i] \n        j := i-1\n        while j >= 0 and A[j] > value do\n            A[j+1] := A[j]\n            j := j-1\n        done\n        A[j+1] = value\n    done\n\n```\n\nWriting the algorithm for integers will suffice."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub insertion_sort ( @a is copy ) {\n    for 1 .. @a.end -> $i {\n        my $value = @a[$i];\n        my $j;\n        loop ( $j = $i-1; $j >= 0 and @a[$j] > $value; $j-- ) {\n            @a[$j+1] = @a[$j];\n        }\n        @a[$j+1] = $value;\n    }\n    return @a;\n}\n\nmy @data = 22, 7, 2, -5, 8, 4;\nsay 'input  = ' ~ @data;\nsay 'output = ' ~ @data.&insertion_sort;\n```\n\nOutput:\n\n```\ninput  = 22 7 2 -5 8 4\noutput = -5 2 4 7 8 22\n\n```"}]}
{"messages": [{"role": "user", "content": "The   **merge sort**   is a recursive sort of order    n\\*log(n).\n\nIt is notable for having a worst case and average complexity of    *O(n\\*log(n))*,    and a best case complexity of    *O(n)*    (for pre-sorted input).\n\nThe basic idea is to split the collection into smaller groups by halving it until the groups only have one element or no elements   (which are both entirely sorted groups).\n\nThen merge the groups back together so that their elements are in order.\n\nThis is how the algorithm gets its   *divide and conquer*   description.\n\nTask\n\nWrite a function to sort a collection of integers using the merge sort.\n\nThe merge sort algorithm comes in two parts:\n\n```\n   a sort function     and \n   a merge function \n\n```\n\nThe functions in pseudocode look like this:\n\n```\nfunction mergesort(m)\n   var list left, right, result\n   if length(m) ≤ 1\n       return m\n   else\n       var middle = length(m) / 2\n       for each x in m up to middle - 1\n           add x to left\n       for each x in m at and after middle\n           add x to right\n       left = mergesort(left)\n       right = mergesort(right)\n       if last(left) ≤ first(right) \n          append right to left\n          return left\n       result = merge(left, right)\n       return result\n\nfunction merge(left,right)\n   var list result\n   while length(left) > 0 and length(right) > 0\n       if first(left) ≤ first(right)\n           append first(left) to result\n           left = rest(left)\n       else\n           append first(right) to result\n           right = rest(right)\n   if length(left) > 0 \n       append rest(left) to result\n   if length(right) > 0 \n       append rest(right) to result\n   return result\n\n```\n\nSee also\n\n* the Wikipedia entry:   merge sort\n\nNote:   better performance can be expected if, rather than recursing until    length(m) ≤ 1,    an insertion sort is used for    length(m)    smaller than some threshold larger than   **1**.   However, this complicates the example code, so it is not shown here."}, {"role": "assistant", "content": "```\n#| Recursive, single-thread, mergesort implementation\nsub mergesort ( @a ) {\n\treturn @a if @a <= 1;\n\n\t# recursion step\n\tmy $m = @a.elems div 2;\n\tmy @l = samewith @a[  0 ..^ $m ];\n\tmy @r = samewith @a[ $m ..^ @a ];\n\n\t# short cut - in case of no overlapping in left and right parts\n\treturn flat @l, @r if @l[*-1] !after @r[0];\n\treturn flat @r, @l if @r[*-1] !after @l[0];\n\n\t# merge step\n\treturn flat gather {\n\t\ttake @l[0] before @r[0]\n\t\t\t\t?? @l.shift\n\t\t\t\t!! @r.shift\n\t\t     while @l and @r;\n\n\t\ttake @l, @r;\n\t}\n}\n```\n\nSome intial testing\n\n```\nmy @data = 6, 7, 2, 1, 8, 9, 5, 3, 4;\nsay 'input  = ' ~ @data;\nsay 'output = ' ~ @data.&merge_sort;\n```\n\nOutput:\n\n```\ninput  = 6 7 2 1 8 9 5 3 4\noutput = 1 2 3 4 5 6 7 8 9\n```\n\n### concurrent implementation\n\nLet's implement it using parallel sorting.\n\n```\n#| Recursive, naive multi-thread, mergesort implementation\nsub mergesort-parallel-naive ( @a ) {\n\treturn @a if @a <= 1;\n\n\tmy $m = @a.elems div 2;\n\n\t# recursion step launching new thread\n    my @l = start { samewith @a[ 0  ..^ $m ] };\n\t\n    # meanwhile recursively sort right side\n    my @r =         samewith @a[ $m ..^ @a ]  ;\n\n\t# as we went parallel on left side, we need to await the result\n\tawait @l[0] andthen @l = @l[0].result;\n\n\t# short cut - in case of no overlapping left and right parts\n\treturn flat @l, @r if @l[*-1] !after @r[0];\n\treturn flat @r, @l if @r[*-1] !after @l[0];\n\n\t# merge step\n\treturn flat gather {\n\t\ttake @l[0] before @r[0]\n\t\t\t\t?? @l.shift\n\t\t\t\t!! @r.shift\n\t\t     while @l and @r;\n\n\t\ttake @l, @r;\n\t}\n}\n```\n\nand tune the batch size required to launch a new thread.\n\n```\n#| Recursive, batch tuned multi-thread, mergesort implementation\nsub mergesort-parallel ( @a, $batch = 2**9 ) {\n\treturn @a if @a <= 1;\n\n\tmy $m = @a.elems div 2;\n\n\t# recursion step\n\tmy @l = $m >= $batch\n\t\t\t  ?? start { samewith @a[ 0 ..^ $m ], $batch }\n\t\t\t  !!         samewith @a[ 0 ..^ $m ], $batch ;\n\n\t# meanwhile recursively sort right side\n\tmy @r = samewith @a[ $m ..^ @a ], $batch;\n\n\t# if we went parallel on left side, we need to await the result\n\tawait @l[0] andthen @l = @l[0].result if @l[0] ~~ Promise;\n\n\t# short cut - in case of no overlapping left and right parts\n\treturn flat @l, @r if @l[*-1] !after @r[0];\n\treturn flat @r, @l if @r[*-1] !after @l[0];\n\n\t# merge step\n\treturn flat gather {\n\t\ttake @l[0] before @r[0]\n\t\t\t\t?? @l.shift\n\t\t\t\t!! @r.shift\n\t\t     while @l and @r;\n\n\t\ttake @l, @r;\n\t}\n}\n```\n\n### testing\n\nLet's run some tests ...\n\n```\nsay \"x\" x 10 ~ \" Testing \" ~ \"x\" x 10;\nuse Test;\nmy @functions-under-test = &mergesort, &mergesort-parallel-naive, &mergesort-parallel;\nmy @testcases =\n\t\t() => (),\n\t\t<a>.List => <a>.List,\n\t\t<a a> => <a a>,\n\t\t(\"b\", \"a\", 3) => (3, \"a\", \"b\"),\n\t\t<h b a c d f e g> => <a b c d e f g h>,\n\t\t<a 🎮 3 z 4 🐧> => <a 🎮 3 z 4 🐧>.sort\n\t\t;\n\nplan @testcases.elems * @functions-under-test.elems;\nfor @functions-under-test -> &fun {\n\tsay &fun.name;\n\tis-deeply &fun(.key), .value, .key ~ \"  =>  \" ~ .value for @testcases;\n}\ndone-testing;\n```\n\nOutput:\n\n```\nxxxxxxxxxx Testing xxxxxxxxxx\n1..18\nmergesort\nok 1 -   =>\nok 2 - a  =>  a\nok 3 - a a  =>  a a\nok 4 - b a 3  =>  3 a b\nok 5 - h b a c d f e g  =>  a b c d e f g h\nok 6 - a 🎮 3 z 4 🐧  =>  3 4 a z 🎮 🐧\nmergesort-parallel-naive\nok 7 -   =>\nok 8 - a  =>  a\nok 9 - a a  =>  a a\nok 10 - b a 3  =>  3 a b\nok 11 - h b a c d f e g  =>  a b c d e f g h\nok 12 - a 🎮 3 z 4 🐧  =>  3 4 a z 🎮 🐧\nmergesort-parallel\nok 13 -   =>\nok 14 - a  =>  a\nok 15 - a a  =>  a a\nok 16 - b a 3  =>  3 a b\nok 17 - h b a c d f e g  =>  a b c d e f g h\nok 18 - a 🎮 3 z 4 🐧  =>  3 4 a z 🎮 🐧\n```\n\n### benchmarking\n\nand some Benchmarking.\n\n```\nuse Benchmark;\nmy $runs = 5;\nmy $elems = 10 * Kernel.cpu-cores * 2**10;\nmy @unsorted of Str = ('a'..'z').roll(8).join xx $elems;\nmy UInt $l-batch = 2**13;\nmy UInt $m-batch = 2**11;\nmy UInt $s-batch = 2**9;\nmy UInt $t-batch = 2**7;\n\nsay \"elements: $elems, runs: $runs, cpu-cores: {Kernel.cpu-cores}, large/medium/small/tiny-batch: $l-batch/$m-batch/$s-batch/$t-batch\";\n\nmy %results = timethese $runs, {\n\tsingle-thread         => { mergesort(@unsorted) },\n\tparallel-naive        => { mergesort-parallel-naive(@unsorted) },\n\tparallel-tiny-batch   => { mergesort-parallel(@unsorted, $t-batch) },\n\tparallel-small-batch  => { mergesort-parallel(@unsorted, $s-batch) },\n\tparallel-medium-batch => { mergesort-parallel(@unsorted, $m-batch) },\n\tparallel-large-batch  => { mergesort-parallel(@unsorted, $l-batch) },\n}, :statistics;\n\nmy @metrics = <mean median sd>;\nmy $msg-row = \"%.4f\\t\" x @metrics.elems ~ '%s';\n\nsay @metrics.join(\"\\t\");\nfor %results.kv -> $name, %m {\n\tsay sprintf($msg-row, %m{@metrics}, $name);\n}\n```\n\n```\nelements: 40960, runs: 5, cpu-cores: 4, large/medium/small/tiny-batch: 8192/2048/512/128\nmean\tmedian\tsd\n7.7683\t8.0265\t0.5724\tparallel-naive\n3.1354\t3.1272\t0.0602\tparallel-tiny-batch\n2.6932\t2.6599\t0.1831\tparallel-medium-batch\n2.8139\t2.7832\t0.0641\tparallel-large-batch\n3.0908\t3.0593\t0.0675\tparallel-small-batch\n5.9989\t5.9450\t0.1518\tsingle-thread\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSort an array of integers (of any convenient size) into ascending order using Pancake sorting.\n\nIn short, instead of individual elements being sorted, the only operation allowed is to \"flip\" one end of the list, like so:\n\n```\n          Before:   6 7 8 9 2 5 3 4 1\n          After:    9 8 7 6 2 5 3 4 1\n\n```\n\nOnly one end of the list can be flipped; this should be the low end, but the high end is okay if it's easier to code or works better, but it **must** be the same end for the entire solution. (The end flipped can't be arbitrarily changed.)\n\nShow both the initial, unsorted list and the final sorted list.\n\n(Intermediate steps during sorting are optional.)\n\nOptimizations are optional (but recommended).\n\nRelated tasks\n\n* Number reversal game\n* Topswops\n\nAlso see\n\n* Wikipedia article:   pancake sorting."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub pancake_sort(@a is copy) {\n    my $endpoint = @a.end;\n    while $endpoint > 0 and not [<] @a {\n        my $max_i = [0..$endpoint].max: { @a[$_] };\n        my $max   = @a[$max_i];\n        if @a[$endpoint] == $max {\n            $endpoint-- while $endpoint >= 0 and @a[$endpoint] == $max;\n            next;\n        }\n        # @a[$endpoint] is not $max, so it needs flipping;\n        # Flip twice if max is not already at the top.\n        @a[0..$max_i]    .= reverse if $max_i != 0;\n        @a[0..$endpoint] .= reverse;\n        $endpoint--;\n    }\n    return @a;\n}\n\nfor <6 7 2 1 8 9 5 3 4>,\n    <4 5 7 1 46 78 2 2 1 9 10>,\n    <0 -9 -8 2 -7 8 6 -2 -8 3> -> @data {\n   say 'input  = ' ~ @data;\n   say 'output = ' ~ @data.&pancake_sort\n}\n\n```\n\nOutput:\n\n```\ninput  = 6 7 2 1 8 9 5 3 4\noutput = 1 2 3 4 5 6 7 8 9\ninput  = 4 5 7 1 46 78 2 2 1 9 10\noutput = 1 1 2 2 4 5 7 9 10 46 78\ninput  = 0 -9 -8 2 -7 8 6 -2 -8 3\noutput = -9 -8 -8 -7 -2 0 2 3 6 8\n```\n\nThe following is an alternative adapted from the code by Andrew Shitov.\n\n```\n# 20240908 Updated Raku programming solution\n\nsub pancake-sort(@data is copy) { # imperative\n   for @data.elems - 1 ... 1 {\n      @data[0 .. @data[0..$_].maxpairs[*-1].key] .= reverse;\n      @data[0 .. $_] .= reverse;\n   }\n   return @data\n}\n\nsub pancake_sort(@data is copy) { # recursive\n   return @data if @data.elems <= 1;\n   @data[0 .. @data.maxpairs[*-1].key] .= reverse;\n   return pancake_sort(@data[1..*-1]).append: @data[0]\n}\n\nfor <6 7 2 1 8 9 5 3 4>,\n    <4 5 7 1 46 78 2 2 1 9 10>,\n    <0 -9 -8 2 -7 8 6 -2 -8 3> -> @data {\n   say 'input  = ' ~ @data;\n   say 'output = ' ~ pancake-sort(@data);\n   say 'output = ' ~ pancake_sort(@data) ~ \"\\n\"\n}\n\n```\n\nOutput:\n\n```\ninput  = 6 7 2 1 8 9 5 3 4\noutput = 1 2 3 4 5 6 7 8 9\noutput = 1 2 3 4 5 6 7 8 9\n\ninput  = 4 5 7 1 46 78 2 2 1 9 10\noutput = 1 1 2 2 4 5 7 9 10 46 78\noutput = 1 1 2 2 4 5 7 9 10 46 78\n\ninput  = 0 -9 -8 2 -7 8 6 -2 -8 3\noutput = -9 -8 -8 -7 -2 0 2 3 6 8\noutput = -9 -8 -8 -7 -2 0 2 3 6 8\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Sort an array of numbers (of any convenient size) into ascending order using   Patience sorting.\n\nRelated task\n:   * Longest increasing subsequence"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-10-22\n\n```\nmulti patience(*@deck) {\n    my @stacks;\n    for @deck -> $card {\n        with @stacks.first: $card before *[*-1] -> $stack {\n            $stack.push: $card;\n        }\n        else {\n            @stacks.push: [$card];\n        }\n    }\n    gather while @stacks {\n        take .pop given min :by(*[*-1]), @stacks;\n        @stacks .= grep: +*;\n    }\n}\n\nsay ~patience ^10 . pick(*);\n\n```\n\nOutput:\n\n```\n0 1 2 3 4 5 6 7 8 9\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a permutation sort, which proceeds by generating the possible permutations\nof the input array/list until discovering the sorted one.\n\nPseudocode:\n\n```\nwhile not InOrder(list) do\n    nextPermutation(list)\ndone\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# Lexicographic permuter from \"Permutations\" task.\nsub next_perm ( @a ) {\n    my $j = @a.end - 1;\n    $j-- while $j >= 1 and [>] @a[ $j, $j+1 ];\n\n    my $aj = @a[$j];\n    my $k  = @a.end;\n    $k-- while [>] $aj, @a[$k];\n\n    @a[ $j, $k ] .= reverse;\n\n    my Int $r = @a.end;\n    my Int $s = $j + 1;\n    while $r > $s {\n        @a[ $r, $s ] .= reverse;\n        $r--;\n        $s++;\n    }\n}\n\nsub permutation_sort ( @a ) {\n    my @n = @a.keys;\n    my $perm_count = [*] 1 .. +@n; # Factorial\n    for ^$perm_count {\n        my @permuted_a = @a[ @n ];\n        return @permuted_a if [le] @permuted_a;\n        next_perm(@n);\n    }\n}\n\nmy @data  = < c b e d a >; # Halfway between abcde and edcba\nsay 'Input  = ' ~ @data;\nsay 'Output = ' ~ @data.&permutation_sort;\n\n```\n\nOutput:\n\n```\nInput  = c b e d a\nOutput = a b c d e\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Quicksort. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nSort an array (or list) elements using the   quicksort   algorithm.\n\nThe elements must have a   strict weak order   and the index of the array can be of any discrete type.\n\nFor languages where this is not possible, sort an array of integers.\n\nQuicksort, also known as   *partition-exchange sort*,   uses these steps.\n\n:   :   1. Choose any element of the array to be the pivot.\n        2. Divide all other elements (except the pivot) into two partitions.\n           * All elements less than the pivot must be in the first partition.\n           * All elements greater than the pivot must be in the second partition.\n        3. Use recursion to sort both partitions.\n        4. Join the first sorted partition, the pivot, and the second sorted partition.\n\nThe best pivot creates partitions of equal length (or lengths differing by   **1**).\n\nThe worst pivot creates an empty partition (for example, if the pivot is the first or last element of a sorted array).\n\nThe run-time of Quicksort ranges from    *O(n* log *n)*    with the best pivots, to    *O(n2)*    with the worst pivots, where    *n*    is the number of elements in the array.\n\nThis is a simple quicksort algorithm, adapted from Wikipedia.\n\n```\nfunction quicksort(array)\n    less, equal, greater := three empty arrays\n    if length(array) > 1  \n        pivot := select any element of array\n        for each x in array\n            if x < pivot then add x to less\n            if x = pivot then add x to equal\n            if x > pivot then add x to greater\n        quicksort(less)\n        quicksort(greater)\n        array := concatenate(less, equal, greater)\n\n```\n\nA better quicksort algorithm works in place, by swapping elements within the array, to avoid the memory allocation of more arrays.\n\n```\nfunction quicksort(array)\n    if length(array) > 1\n        pivot := select any element of array\n        left := first index of array\n        right := last index of array\n        while left ≤ right\n            while array[left] < pivot\n                left := left + 1\n            while array[right] > pivot\n                right := right - 1\n            if left ≤ right\n                swap array[left] with array[right]\n                left := left + 1\n                right := right - 1\n        quicksort(array from first index to right)\n        quicksort(array from left to last index)\n\n```\n\nQuicksort has a reputation as the fastest sort. Optimized variants of quicksort are common features of many languages and libraries. One often contrasts quicksort with   merge sort,   because both sorts have an average time of    *O(n* log *n)*.\n\n:   *\"On average, mergesort does fewer comparisons than quicksort, so it may be better when complicated comparison routines are used. Mergesort also takes advantage of pre-existing order, so it would be favored for using sort() to merge several sorted arrays. On the other hand, quicksort is often faster for small arrays, and on arrays of a few distinct values, repeated many times.\"* — http://perldoc.perl.org/sort.html\n\nQuicksort is at one end of the spectrum of divide-and-conquer algorithms, with merge sort at the opposite end.\n\n* Quicksort is a conquer-then-divide algorithm, which does most of the work during the partitioning and the recursive calls. The subsequent reassembly of the sorted partitions involves trivial effort.\n* Merge sort is a divide-then-conquer algorithm. The partioning happens in a trivial way, by splitting the input array in half. Most of the work happens during the recursive calls and the merge phase.\n\nWith quicksort, every element in the first partition is less than or equal to every element in the second partition. Therefore, the merge phase of quicksort is so trivial that it needs no mention!\n\nThis task has not specified whether to allocate new arrays, or sort in place. This task also has not specified how to choose the pivot element. (Common ways to are to choose the first element, the middle element, or the median of three elements.) Thus there is a variety among the following implementations."}, {"role": "assistant", "content": "```\n#| Recursive, single-thread, random pivot, single-pass, quicksort implementation\nmulti quicksort(\\a where a.elems < 2) { a }\nmulti quicksort(\\a, \\pivot = a.pick) {\n\tmy %prt{Order} is default([]) = a.classify: * cmp pivot;\n\t|samewith(%prt{Less}), |%prt{Same}, |samewith(%prt{More})\n}\n```\n\n### concurrent implementation\n\nThe partitions can be sorted in parallel.\n\n```\n#| Recursive, parallel, random pivot, single-pass, quicksort implementation\nmulti quicksort-parallel-naive(\\a where a.elems < 2) { a }\nmulti quicksort-parallel-naive(\\a, \\pivot = a.pick) {\n\tmy %prt{Order} is default([]) = a.classify: * cmp pivot;\n\tmy Promise $less = start { samewith(%prt{Less}) }\n\tmy $more = samewith(%prt{More});\n\tawait $less andthen |$less.result, |%prt{Same}, |$more;\n}\n```\n\nLet's tune the parallel execution by applying a minimum batch size in order to spawn a new thread.\n\n```\n#| Recursive, parallel, batch tuned, single-pass, quicksort implementation\nsub quicksort-parallel(@a, $batch = 2**9) {\n\treturn @a if @a.elems < 2;\n\n\t# separate unsorted input into Order Less, Same and More compared to a random $pivot\n\tmy $pivot = @a.pick;\n\tmy %prt{Order} is default([]) = @a.classify( * cmp $pivot );\n\n\t# decide if we sort the Less partition on a new thread\n\tmy $less = %prt{Less}.elems >= $batch\n\t\t\t        ?? start { samewith(%prt{Less}, $batch) }\n\t\t\t        !!         samewith(%prt{Less}, $batch);\n\n\t# meanwhile use current thread for sorting the More partition\n\tmy $more = samewith(%prt{More}, $batch);\n\n\t# if we went parallel, we need to await the result\n\tawait $less andthen $less = $less.result if $less ~~ Promise;\n\n\t# concat all sorted partitions into a list and return\n\t|$less, |%prt{Same}, |$more;\n}\n```\n\n### testing\n\nLet's run some tests.\n\n```\nsay \"x\" x 10 ~ \" Testing \" ~ \"x\" x 10;\nuse Test;\nmy @functions-under-test = &quicksort, &quicksort-parallel-naive, &quicksort-parallel;\nmy @testcases =\n\t\t() => (),\n\t\t<a>.List => <a>.List,\n\t\t<a a> => <a a>,\n\t\t(\"b\", \"a\", 3) => (3, \"a\", \"b\"),\n\t\t<h b a c d f e g> => <a b c d e f g h>,\n\t\t<a 🎮 3 z 4 🐧> => <a 🎮 3 z 4 🐧>.sort\n\t\t;\n\nplan @testcases.elems * @functions-under-test.elems;\nfor @functions-under-test -> &fun {\n\tsay &fun.name;\n\tis-deeply &fun(.key), .value, .key ~ \"  =>  \" ~ .value for @testcases;\n}\ndone-testing;\n```\n\n```\nxxxxxxxxxx Testing xxxxxxxxxx\n1..18\nquicksort\nok 1 -   =>\nok 2 - a  =>  a\nok 3 - a a  =>  a a\nok 4 - b a 3  =>  3 a b\nok 5 - h b a c d f e g  =>  a b c d e f g h\nok 6 - a 🎮 3 z 4 🐧  =>  3 4 a z 🎮 🐧\nquicksort-parallel-naive\nok 7 -   =>\nok 8 - a  =>  a\nok 9 - a a  =>  a a\nok 10 - b a 3  =>  3 a b\nok 11 - h b a c d f e g  =>  a b c d e f g h\nok 12 - a 🎮 3 z 4 🐧  =>  3 4 a z 🎮 🐧\nquicksort-parallel\nok 13 -   =>\nok 14 - a  =>  a\nok 15 - a a  =>  a a\nok 16 - b a 3  =>  3 a b\nok 17 - h b a c d f e g  =>  a b c d e f g h\nok 18 - a 🎮 3 z 4 🐧  =>  3 4 a z 🎮 🐧\n```\n\n### benchmarking\n\nand some benchmarking\n\n```\nsay \"x\" x 11 ~ \" Benchmarking \" ~ \"x\" x 11;\nuse Benchmark;\nmy $runs = 5;\nmy $elems = 10 * Kernel.cpu-cores * 2**10;\nmy @unsorted of Str = ('a'..'z').roll(8).join xx $elems;\nmy UInt $l-batch = 2**13;\nmy UInt $m-batch = 2**11;\nmy UInt $s-batch = 2**9;\nmy UInt $t-batch = 2**7;\n\nsay \"elements: $elems, runs: $runs, cpu-cores: {Kernel.cpu-cores}, large/medium/small/tiny-batch: $l-batch/$m-batch/$s-batch/$t-batch\";\n\nmy %results = timethese $runs, {\n\tsingle-thread         => { quicksort(@unsorted) },\n\tparallel-naive        => { quicksort-parallel-naive(@unsorted) },\n\tparallel-tiny-batch   => { quicksort-parallel(@unsorted, $t-batch) },\n\tparallel-small-batch  => { quicksort-parallel(@unsorted, $s-batch) },\n\tparallel-medium-batch => { quicksort-parallel(@unsorted, $m-batch) },\n\tparallel-large-batch  => { quicksort-parallel(@unsorted, $l-batch) },\n}, :statistics;\n\nmy @metrics = <mean median sd>;\nmy $msg-row = \"%.4f\\t\" x @metrics.elems ~ '%s';\n\nsay @metrics.join(\"\\t\");\nfor %results.kv -> $name, %m {\n\tsay sprintf($msg-row, %m{@metrics}, $name);\n}\n```\n\n```\nxxxxxxxxxxx Benchmarking xxxxxxxxxxx\nelements: 40960, runs: 5, cpu-cores: 4, large/medium/small/tiny-batch: 8192/2048/512/128\nmean\tmedian\tsd\n2.9503\t2.8907\t0.2071\tparallel-small-batch\n3.2054\t3.1727\t0.2078\tparallel-tiny-batch\n5.6524\t5.0980\t1.2628\tparallel-naive\n3.4717\t3.3353\t0.3622\tparallel-medium-batch\n4.6275\t4.7793\t0.4930\tparallel-large-batch\n6.5401\t6.2832\t0.5585\tsingle-thread\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSort an integer array with the   radix sort algorithm.\n\nThe primary purpose is to complete the characterization of sort algorithms task."}, {"role": "assistant", "content": "(formerly Perl 6)\nA base-10 radix sort, done on the string representation of the integers. Signs are handled by in-place reversal of the '-' bucket on the last iteration. (The sort in there is not cheating; it only makes sure we process the buckets in the right order, since classify might return the buckets in random order. It might be more efficient to create our own ordered buckets, but this is succinct.)\n\n```\nsub radsort (@ints) {\n    my $maxlen = max @ints».chars;\n    my @list = @ints».fmt(\"\\%0{$maxlen}d\");\n\n    for reverse ^$maxlen -> $r {\n        my @buckets = @list.classify( *.substr($r,1) ).sort: *.key;\n        @buckets[0].value = @buckets[0].value.reverse.List\n            if !$r and @buckets[0].key eq '-';\n        @list = flat map *.value.values, @buckets;\n    }\n    @list».Int;\n}\n\n.say for radsort (-2_000 .. 2_000).roll(20);\n\n```\n\nOutput:\n\n```\n-1585\n-1427\n-1228\n-1067\n-945\n-657\n-643\n-232\n-179\n-28\n37\n411\n488\n509\n716\n724\n1504\n1801\n1864\n1939\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSort an array (or list) of elements using the Selection sort algorithm.\n\nIt works as follows:\n\nFirst find the smallest element in the array and exchange it with the element in the first position, then find the second smallest element and exchange it with the element in the second position, and continue in this way until the entire array is sorted.\n\nIts asymptotic complexity is    O(n2)    making it inefficient on large arrays.\n\nIts primary purpose is for when writing data is very expensive (slow) when compared to reading, eg. writing to flash memory or EEPROM.\n\nNo other sorting algorithm has less data movement.\n\nReferences\n\n* Rosetta Code:   O     (complexity).\n* Wikipedia:   Selection sort.\n* Wikipedia:   [Big O notation]."}, {"role": "assistant", "content": "(formerly Perl 6)\nSolution 1:\n\n```\nsub selection_sort ( @a is copy ) {\n    for 0 ..^ @a.end -> $i {\n        my $min = [ $i+1 .. @a.end ].min: { @a[$_] };\n        @a[$i, $min] = @a[$min, $i] if @a[$i] > @a[$min];\n    }\n    return @a;\n}\n\nmy @data = 22, 7, 2, -5, 8, 4;\nsay 'input  = ' ~ @data;\nsay 'output = ' ~ @data.&selection_sort;\n\n```\n\nOutput:\n\n```\ninput  = 22 7 2 -5 8 4\noutput = -5 2 4 7 8 22\n\n```\n\nSolution 2:\n\n```\nsub selectionSort(@tmp) {\n    for ^@tmp -> $i {\n        my $min = $i; @tmp[$i, $_] = @tmp[$_, $i] if @tmp[$min] > @tmp[$_] for $i^..^@tmp;\n    }\n    return @tmp;\n}\n\n```\n\nOutput:\n\n```\ninput  = 22 7 2 -5 8 4\noutput = -5 2 4 7 8 22\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSort an array of elements using the Shell sort algorithm, a diminishing increment sort.\n\nThe Shell sort   (also known as Shellsort or Shell's method)   is named after its inventor, Donald Shell, who published the algorithm in 1959.\n\nShell sort is a sequence of interleaved insertion sorts based on an increment sequence.\nThe increment size is reduced after each pass until the increment size is 1.\n\nWith an increment size of 1, the sort is a basic insertion sort, but by this time the data is guaranteed to be almost sorted, which is insertion sort's \"best case\".\n\nAny sequence will sort the data as long as it ends in 1, but some work better than others.\n\nEmpirical studies have shown a geometric increment sequence with a ratio of about 2.2 work well in practice.\n[1]\n\nOther good sequences are found at the On-Line Encyclopedia of Integer Sequences."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub shell_sort ( @a is copy ) {\n    loop ( my $gap = (@a/2).round; $gap > 0; $gap = ( $gap * 5 / 11 ).round ) {\n        for $gap .. @a.end -> $i {\n            my $temp = @a[$i];\n\n            my $j;\n            loop ( $j = $i; $j >= $gap; $j -= $gap ) {\n                my $v = @a[$j - $gap];\n                last if $v <= $temp;\n                @a[$j] = $v;\n            }\n\n            @a[$j] = $temp;\n        }\n    }\n    return @a;\n}\nmy @data = 22, 7, 2, -5, 8, 4;\nsay 'input  = ' ~ @data;\nsay 'output = ' ~ @data.&shell_sort;\n\n```\n\nOutput:\n\n```\ninput  = 22 7 2 -5 8 4\noutput = -5 2 4 7 8 22\n\n```"}]}
{"messages": [{"role": "user", "content": "In general, sleep sort works by starting a separate task for each item to be sorted, where each task sleeps for an interval corresponding to the item's sort key, then emits the item. Items are then collected sequentially in time.\n\nTask: Write a program that implements sleep sort. Have it accept non-negative integers on the command line and print the integers in sorted order. If this is not idomatic in your language or environment, input and output may be done differently. Enhancements for optimization, generalization, practicality, robustness, and so on are not required.\n\nSleep sort was presented anonymously on 4chan and has been discussed on Hacker News."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nawait map -> $delay { start { sleep $delay ; say $delay } },\n    <6 8 1 12 2 14 5 2 1 0>;\n\n```\n\nOutput:\n\n```\n0\n1\n1\n2\n2\n5\n6\n8\n12\n14\n```\n\nThis can also be written using reactive programming:\n\n```\n#!/usr/bin/env raku\nuse v6;\nreact whenever Supply.from-list(@*ARGS).start({ .&sleep // +$_ }).flat { .say }\n\n```\n\nOutput:\n\n```\n$ ./sleep-sort 1 3 5 6 2 4\n1\n2\n3\n4\n5\n6\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Stooge sort. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nShow the   Stooge Sort   for an array of integers.\n\nThe Stooge Sort algorithm is as follows:\n\n```\nalgorithm stoogesort(array L, i = 0, j = length(L)-1)\n     if L[j] < L[i] then\n         L[i] ↔ L[j]\n     if j - i > 1 then\n         t := (j - i + 1)/3\n         stoogesort(L, i  , j-t)\n         stoogesort(L, i+t, j  )\n         stoogesort(L, i  , j-t)\n     return L\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub stoogesort( @L, $i = 0, $j = @L.end ) {\n    @L[$j,$i] = @L[$i,$j] if @L[$i] > @L[$j];\n\n    my $interval = $j - $i;\n    \n    if $interval > 1 {\n         my $t = ( $interval + 1 ) div 3;\n         stoogesort( @L, $i   , $j-$t );\n         stoogesort( @L, $i+$t, $j    );\n         stoogesort( @L, $i   , $j-$t );\n    }\n    return @L;\n}\n\nmy @L = 1, 4, 5, 3, -6, 3, 7, 10, -2, -5;\n\nstoogesort(@L).Str.say;\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Strand sort. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTask\n\nImplement the Strand sort.\n\nThis is a way of sorting numbers by extracting shorter sequences of already sorted numbers from an unsorted list."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.04.01\n\n```\nsub infix:<M> (@x-in, @y-in) {\n    my @x = | @x-in;\n    my @y = | @y-in;\n    flat @x, @y,\n        reverse gather while @x and @y {\n            take do given @x[*-1] cmp @y[*-1] {\n                when More { pop @x }\n                when Less { pop @y }\n                when Same { pop(@x), pop(@y) }\n            }\n        }\n}\n\nsub strand (@x) {\n    my $i = 0;\n    my $prev = -Inf;\n    gather while $i < @x {\n        @x[$i] before $prev ?? $i++ !! take $prev = splice(@x, $i, 1)[0];\n    }\n}\n\nsub strand_sort (@x is copy) {\n    my @out;\n    @out M= strand(@x) while @x;\n    @out;\n}\n\nmy @a = (^100).roll(10);\nsay \"Before {@a}\";\n@a = strand_sort(@a);\nsay \"After  {@a}\";\n\n@a = <The quick brown fox jumps over the lazy dog>;\nsay \"Before {@a}\";\n@a = strand_sort(@a);\nsay \"After  {@a}\";\n\n```\n\nOutput:\n\n```\nBefore 1 20 64 72 48 75 96 55 42 74\nAfter  1 20 42 48 55 64 72 74 75 96\nBefore The quick brown fox jumps over the lazy dog\nAfter  The brown dog fox jumps lazy over quick the\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The current wikipedia article is at Tree\\_sort. The original RosettaCode article was extracted from the wikipedia article № 295989333 of 15:13, 12 June 2009 . The list of authors can be seen in the page history. As with Rosetta Code, the pre **5 June 2009** text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nA **tree sort** is a sort algorithm that builds a binary search tree from the keys to be sorted, and then traverses the tree (in-order) so that the keys come out in sorted order. Its typical use is when sorting the elements of a stream from a file. Several other sorts would have to load the elements to a temporary data structure, whereas in a tree sort the act of loading the input into a data structure is sorting it.\n\nThe tree sort is considered by some to be the faster method to sort a linked list, followed by Quicksort and Mergesort:\n\n* A Comparative Study of Linked List Sorting Algorithms by Ching-Kuang Shene\n\nSediment sort, bubble sort, selection sort perform very badly.\n\n* http://www.martinbroadhurst.com/sorting-a-linked-list-by-turning-it-into-a-binary-tree.html\n\n**Task:**  \nFirst, construct a doubly linked list (unsorted).  \nThen construct a tree in situ: use the prev and next of that list as left and right tree pointers.  \nThen traverse the tree, in order, and recreate a doubly linked list, again in situ, but of course now in sorted order."}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20231201 Raku programming solution\n\nclass BinaryTree { has ($.node, $.leftSubTree, $.rightSubTree) is rw;\n\n   method insert($item) {\n      if not $.node.defined {\n         $.node = $item;\n         ($.leftSubTree, $.rightSubTree)>>.&{ $_ = BinaryTree.new }\n      } elsif $item cmp $.node < 0 {\n         $.leftSubTree.insert($item);\n      } else {\n         $.rightSubTree.insert($item);\n      }\n   }\n\n   method inOrder(@ll) {\n      return unless $.node.defined;\n      $.leftSubTree.inOrder(@ll);\n      @ll.push($.node);\n      $.rightSubTree.inOrder(@ll);\n   }\n}\n\nsub treeSort(@ll) {\n   my $searchTree = BinaryTree.new;\n   for @ll -> $i { $searchTree.insert($i) }\n   $searchTree.inOrder(my @ll2);\n   return @ll2\n}\n\nsub printLinkedList(@ll, Str $fmt, Bool $sorted) {\n   for @ll -> $i { printf \"$fmt \", $i }\n   $sorted ?? say() !! print \"-> \"\n}\n\nmy @ll  = <5 3 7 9 1>;\n#my @ll = [37, 88, 13, 18, 72, 77, 29, 93, 21, 97, 37, 42, 67, 22, 29, 2];\nprintLinkedList(@ll, \"%d\", False);\nmy @lls = treeSort(@ll);\nprintLinkedList(@lls, \"%d\", True);\n\nmy @ll2 = <d c e b a>;\n#my @ll2 = <one two three four five six seven eight nine ten>;\nprintLinkedList(@ll2, \"%s\", False);\nmy @lls2 = treeSort(@ll2);\nprintLinkedList(@lls2, \"%s\", True);\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Soundex is an algorithm for creating indices for words based on their pronunciation.\n\nTask\n\nThe goal is for homophones to be encoded to the same representation so that they can be matched despite minor differences in spelling   (from the   soundex   Wikipedia article).\n\nCaution\n\nThere is a major issue in many of the implementations concerning the separation of two consonants that have the same soundex code! According to the official Rules [[1]]. So check for instance if **Ashcraft** is coded to **A-261**.\n\n* If a vowel (A, E, I, O, U) separates two consonants that have the same soundex code, the consonant to the right of the vowel is coded. Tymczak is coded as T-522 (T, 5 for the M, 2 for the C, Z ignored (see \"Side-by-Side\" rule above), 2 for the K). Since the vowel \"A\" separates the Z and K, the K is coded.\n* If \"H\" or \"W\" separate two consonants that have the same soundex code, the consonant to the right of the vowel is not coded. Example: Ashcraft is coded A-261 (A, 2 for the S, C ignored, 6 for the R, 1 for the F). It is not coded A-226."}, {"role": "assistant", "content": "(formerly Perl 6)\nUS census algorithm, so \"Ashcraft\" and \"Burroughs\" adjusted to match.\nWe fake up a first consonant in some cases to make up for the fact that we always trim the first numeric code (so that the 'l' of 'Lloyd' is properly deleted).\n\n```\nsub soundex ($name --> Str) {\n    my $first = substr($name,0,1).uc;\n    gather {\n        take $first;\n        my $fakefirst = '';\n        $fakefirst = \"de \" if $first ~~ /^ <[AEIOUWH]> /;\n        \"$fakefirst$name\".lc.trans('wh' => '') ~~ /\n            ^\n            [\n                [\n                | <[ bfpv     ]>+ { take 1 }\n                | <[ cgjkqsxz ]>+ { take 2 }\n                | <[ dt       ]>+ { take 3 }\n                | <[ l        ]>+ { take 4 }\n                | <[ mn       ]>+ { take 5 }\n                | <[ r        ]>+ { take 6 }\n                ]\n            || .\n            ]+\n            $ { take 0,0,0 }\n        /;\n    }.flat.[0,2,3,4].join;\n}\n\nfor < Soundex     S532\n      Example     E251\n      Sownteks    S532\n      Ekzampul    E251\n      Euler       E460\n      Gauss       G200\n      Hilbert     H416\n      Knuth       K530\n      Lloyd       L300\n      Lukasiewicz L222\n      Ellery      E460\n      Ghosh       G200\n      Heilbronn   H416\n      Kant        K530\n      Ladd        L300\n      Lissajous   L222\n      Wheaton     W350\n      Ashcraft    A261\n      Burroughs   B620\n      Burrows     B620\n      O'Hara      O600 >\n-> $n, $s {\n    my $s2 = soundex($n);\n    say $n.fmt(\"%16s \"), $s, $s eq $s2 ?? \" OK\" !! \" NOT OK $s2\";\n}\n\n```\n\nOutput:\n\n```\n         Soundex S532 OK\n         Example E251 OK\n        Sownteks S532 OK\n        Ekzampul E251 OK\n           Euler E460 OK\n           Gauss G200 OK\n         Hilbert H416 OK\n           Knuth K530 OK\n           Lloyd L300 OK\n     Lukasiewicz L222 OK\n          Ellery E460 OK\n           Ghosh G200 OK\n       Heilbronn H416 OK\n            Kant K530 OK\n            Ladd L300 OK\n       Lissajous L222 OK\n         Wheaton W350 OK\n        Ashcraft A261 OK\n       Burroughs B620 OK\n         Burrows B620 OK\n          O'Hara O600 OK\n```"}]}
{"messages": [{"role": "user", "content": "A sparkline is a graph of successive values laid out horizontally\nwhere the height of the line is proportional to the values in succession.\n\nTask\n\nUse the following series of Unicode characters to create a program\nthat takes a series of numbers separated by one or more whitespace or comma characters\nand generates a sparkline-type bar graph of the values on a single line of output.\n\nThe eight characters: `'▁▂▃▄▅▆▇█'`  \n(Unicode values U+2581 through U+2588).\n\nUse your program to show sparklines for the following input,\nhere on this page:\n\n1. 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1\n2. 1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5\n\n:   (note the mix of separators in this second case)!\n\nNotes\n\n* A space is not part of the generated sparkline.\n* The sparkline may be accompanied by simple statistics of the data such as its range.\n* A suggestion emerging in later discussion (see Discussion page) is that the bounds between bins should ideally be set to yield the following results for two particular edge cases:\n\n:   :   `\"0, 1, 19, 20\" -> ▁▁██`\n    :   (Aiming to use just two spark levels)\n\n:   :   `\"0, 999, 4000, 4999, 7000, 7999\" -> ▁▁▅▅██`\n    :   (Aiming to use just three spark levels)\n\n:   :   It may be helpful to include these cases in output tests.\n\n* You may find that the unicode sparklines on this page are rendered less noisily by Google Chrome than by Firefox or Safari."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nconstant @bars = '▁' ... '█';\nwhile prompt 'Numbers separated by anything: ' -> $_ {\n    my @numbers = map +*, .comb(/ '-'? [[\\d+ ['.' \\d*]?] | ['.' \\d+]] /);\n    my ($mn,$mx) = @numbers.minmax.bounds;\n    say \"min: $mn.fmt('%5f'); max: $mx.fmt('%5f')\";\n    say @bars[ @numbers.map: { @bars * ($_ - $mn) / ($mx - $mn) min @bars - 1 } ].join;\n}\n\n```\n\nOutput:\n\n```\nNumbers separated by anything: 9 18 27 36 45 54 63 72 63 54 45 36 27 18 9\n9 18 27 36 45 54 63 72 63 54 45 36 27 18 9\nmin: 9.000000; max: 72.000000\n▁▂▃▄▅▆▇█▇▆▅▄▃▂▁\nNumbers separated by anything: 1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5\n1.5 0.5 3.5 2.5 5.5 4.5 7.5 6.5\nmin: 0.500000; max: 7.500000\n▂▁▄▃▆▅█▇\nNumbers separated by anything: 3 2 1 0 -1 -2 -3 -4 -3 -2 -1 0 1 2 3  \nmin: -4.000000; max: 3.000000\n█▇▆▅▄▃▂▁▂▃▄▅▆▇█\nNumbers separated by anything: ^D\n```"}]}
{"messages": [{"role": "user", "content": "Special characters are symbols (single characters or sequences of characters) that have a \"special\" built-in meaning in the language and typically cannot be used in identifiers.\n\nEscape sequences are methods that the language uses to remove the special meaning from the symbol, enabling it to be used as a normal character, or sequence of characters when this can be done.\n\nTask\n\nList the special characters and show escape sequences in the language.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nTechnically speaking, all characters are special in Raku, since\nthey're all just the result of particular mixes of parse rules.\nNevertheless, some characters may appear to be more special than\nothers. (However, we will not document any operators here, which\ncontain plenty of odd characters in Raku.)\n\nSigils:\n\n```\n    $   Item\n    @\tPositional\n    %\tAssociative\n    &\tCallable\n```\n\nTwigils may occur only after a sigil, and indicate special scoping:\n\n```\n    *\tDynamically scoped\n    ?\tCompile-time constant\n    ^\tPositional placeholder\n    :\tNamed placeholder\n    !\tPrivate attribute\n    .\tPublic attribute/accessor\n    ~\tSlang\n    =\tPod data\n    <\tNamed match from $/\n```\n\nQuote characters:\n\n```\n    ''\tSingle quotes\n    \"\"\tDouble quotes\n    //\tRegex\n    ｢｣\tQuotes that allow no interpolation at all\n    <>\tQuote words\n    «»\tShell-style words\n```\n\nEscapes within single quotes:\n\n```\n    \\\\\tBackslash\n    \\'\tQuote char\n```\n\nEscapes within double quotes:\n\n```\n    {}\tInterpolate results of block\n    $\tInterpolate item\n    @\tInterpolate list (requires postcircumfix)\n    %\tInterpolate hash (requires postcircumfix)\n    &\tInterpolate call (requires postcircumfix)\n    \\\\\tBackslash\n    \\\"\tQuote char\n    \\a\tAlarm\n    \\b\tBackspace\n    \\c\tDecimal, control, or named char\n    \\e\tEscape\n    \\f\tFormfeed\n    \\n\tNewline\n    \\o\tOctal char\n    \\r\tReturn\n    \\t\tTab\n    \\x\tHex char\n    \\0\tNull\n```\n\nEscapes within character classes and translations include most of the double-quote backslashes, plus:\n\n```\n    ..\trange\n```\n\nEscapes within regexes include most of the double-quote escapes, plus:\n\n```\n    :\tSome kind of declaration\n    <>\tSome kind of assertion\n    []\tSimple grouping\n    ()\tCapture grouping\n    {}\tSide effect block\n    .\tAny character\n    \\d\tDigit\n    \\w\tAlphanumeric\n    \\s\tWhitespace\n    \\h\tHorizontal whitespace\n    \\v\tVertical whitespace\n    ''\tSingle quoted string\n    \"\"\tDouble quoted string\n    «\tWord initial boundary\n    »\tWord final boundary\n    ^\tString start\n    ^^\tLine start\n    $\tString end\n    $$\tLine end\n```\n\nNote that all non-alphanumeric characters are reserved for escapes and operators in Raku regexes.\n\nAny lowercase backslash escape in a regex may be uppercased to negate it, hence \\N matches anything that is not a newline."}]}
{"messages": [{"role": "user", "content": "Task\n\nNumbers   **n**   such that   reverse(**d**)   divides   reverse(**n**)   for all divisors   **d**   of   **n**,   where   **n  <  200**"}, {"role": "assistant", "content": "```\nuse Prime::Factor:ver<0.3.0+>;\n\nsay \"{+$_} matching numbers:\\n{.batch(10)».fmt('%3d').join: \"\\n\"}\"\n    given (1..^200).grep: { all .flip «%%« .&divisors».flip };\n\n```\n\nOutput:\n\n```\n72 matching numbers:\n  1   2   3   4   5   6   7   8   9  11\n 13  17  19  22  23  26  27  29  31  33\n 37  39  41  43  44  46  47  53  55  59\n 61  62  66  67  69  71  73  77  79  82\n 83  86  88  89  93  97  99 101 103 107\n109 113 121 127 131 137 139 143 149 151\n157 163 167 169 173 179 181 187 191 193\n197 199\n```"}]}
{"messages": [{"role": "user", "content": "This task is an aggregation of lesser-known factorials that nevertheless have some mathematical use.\n\nSpecial factorials\n\n| Name | Formula | Example calculation | Links |\n| --- | --- | --- | --- |\n| Superfactorial | n  sf(n) = ∏ k!                k=1 | sf(4) = 1! × 2! × 3! × 4! = 288 | * Wikipedia * OEIS:A000178 |\n| Hyperfactorial | n  *H*(n) = ∏ kk                k=1 | *H*(4) = 11 × 22 × 33 × 44 = 27,648 | * Wikipedia * OEIS:A002109 |\n| Alternating factorial | n  af(n) = ∑ (-1)n-ii!                i=1 | af(3) = -12×1! + -11×2! + -10×3! = 5 | * Wikipedia * OEIS:A005165 |\n| Exponential factorial | *n*$ = n(n-1)(n-2)... | 4$ = 4321 = 262,144 | * Wikipedia * OEIS:A049384 |\n\nTask\n\n* Write a function/procedure/routine for each of the factorials in the table above.\n* Show   sf(*n*),   *H*(*n*),   and   af(*n*)   where   0 ≤ *n* ≤ 9.   Only show as many numbers as the data types in your language can handle. Bignums are welcome, but not required.\n* Show   0$,   1$,   2$,   3$,   and   4$.\n* Show the number of digits in   5$.   (Optional)\n* Write a function/procedure/routine to find the inverse factorial (sometimes called reverse factorial). That is, if   5! = 120,   then   rf(120) = 5.   This function is simply undefined for most inputs.\n* Use the inverse factorial function to show the inverse factorials of 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, and 3628800.\n* Show   rf(119).   The result should be undefined.\n\nNotes\n:   Since the factorial inverse of   **1**   is both   0   and   1,   your function should return   **0**   in this case since it is normal to use the first match found in a series.\n\nSee also\n\n* Factorial\n* Factorions\n* Left factorials\n* Multifactorial\n* Primorial numbers\n* Stirling numbers of the first kind"}, {"role": "assistant", "content": "```\nsub postfix:<!> ($n) {   [*] 1 .. $n }\nsub postfix:<$> ($n) { [R**] 1 .. $n }\n\nsub sf ($n) { [*] map {                      $_! }, 1 .. $n }\nsub H  ($n) { [*] map {                $_ ** $_  }, 1 .. $n }\nsub af ($n) { [+] map { (-1) ** ($n - $_) *  $_! }, 1 .. $n }\nsub rf ($n) {\n    state @f = 1, |[\\*] 1..*;\n    $n == .value ?? .key !! Nil given @f.first: :p, * >= $n;\n}\n\nsay 'sf : ', map &sf , 0..9;\nsay 'H  : ', map &H  , 0..9;\nsay 'af : ', map &af , 0..9;\nsay '$  : ', map *$  , 1..4;\n\nsay '5$ has ', 5$.chars, ' digits';\n\nsay 'rf : ', map &rf, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800;\nsay 'rf(119) = ', rf(119).raku;\n\n```\n\nOutput:\n\n```\nsf : (1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000)\nH  : (1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000)\naf : (0 1 1 5 19 101 619 4421 35899 326981)\n$  : (1 2 9 262144)\n5$ has 183231 digits\nrf : (0 2 3 4 5 6 7 8 9 10)\nrf(119) = Nil\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nLet   (**p1**,  **p2**)   are neighbor primes.\n\nFind and show here in base ten if   **p1+ p2 -1**   is prime,   where   **p1,   p2  <  100**."}, {"role": "assistant", "content": "```\n# 20210809 Raku programming solution \n\nfor (grep {.is-prime}, 3..*).rotor(2 => -1) -> (\\P1,\\P2) {\n   last if P2 ≥ Ⅽ;\n   ($_ = P1+P2-1).is-prime and printf \"%2d, %2d => %3d\\n\", P1, P2, $_\n}\n\n```\n\nOutput:\n\n```\n 3,  5 =>   7\n 5,  7 =>  11\n 7, 11 =>  17\n11, 13 =>  23\n13, 17 =>  29\n19, 23 =>  41\n29, 31 =>  59\n31, 37 =>  67\n41, 43 =>  83\n43, 47 =>  89\n61, 67 => 127\n67, 71 => 137\n73, 79 => 151\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind the Pythagorean triplet for which a + b + c = 1000 and print the product of a, b, and c. The problem was taken from Project Euler problem 9\n\nRelated task\n\n* Pythagorean triples"}, {"role": "assistant", "content": "```\nhyper for 1..998 -> $a {\n    my $a2 = $a²;\n    for $a + 1 .. 999 -> $b {\n        my $c = 1000 - $a - $b;\n        last if $c < $b;\n        say \"$a² + $b² = $c²\\n$a  + $b  + $c = {$a+$b+$c}\\n$a  × $b  × $c = {$a×$b×$c}\"\n            and exit if $a2 + $b² == $c²\n    }\n}\n\n```\n\nOutput:\n\n```\n200² + 375² = 425²\n200  + 375  + 425 = 1000\n200  × 375  × 425 = 31875000\n```"}]}
{"messages": [{"role": "user", "content": "Special variables have a predefined meaning within a computer programming language.\n\nTask\n\nList the special variables used within the language."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nIt is probably useful to briefly explain normal variables in Raku before tackling special variables.\n\nVariables in Raku have a prefix sigil to distinguish them from named subroutines, functions, classes, and so on. There is a system of sigils to mark the fundamental structural type of the variable:\n\n```\n $foo   scalar (object)\n @foo   ordered array\n %foo   unordered hash (associative array)\n &foo   code/rule/token/regex\n ::foo  package/module/class/role/subset/enum/type/grammar\n\n```\n\nSigils indicate overall interface, not the exact type of the bound object. Different sigils imply different minimal abilities. Ordinary sigils indicate normally scoped variables, either lexical or package scoped. Oddly scoped variables include a secondary sigil (a twigil) that indicates what kind of strange scoping the variable is subject to:\n\n```\n $foo                # ordinary scoping\n $.foo               # object attribute public accessor\n $^foo               # self-declared formal positional parameter\n $:foo               # self-declared formal named parameter\n $*foo               # dynamically overridable global variable\n $?foo               # compiler hint variable\n $=foo               # POD variable\n $<foo>              # match variable, short for $/{'foo'}\n $!foo               # object attribute private storage\n $~foo               # the foo sublanguage seen by the parser at this lexical spot\n\n```\n\nA selection (not comprehensive) of Raku's automatically set and/or pre-defined compile-time and run-time variables.\n\n```\n# Lexical variables\n\n $_                  # implicit variable lexically scoped to the current block\n $!                  # current Exception object\n $/                  # last match\n $0, $1, $2...       # captured values from match: $/[0], $/[1], $/[2] ...\n\n# Compile-time variables\n\n$?PACKAGE            # current package\n$?CLASS              # current class\n$?MODULE             # current module\n$?ROLE               # current role\n$?DISTRIBUTION       # which OS distribution am I compiling under\n$?FILE               # current filename of source file\n$?LINE               # current line number in source file\n&?ROUTINE            # current sub or method (itself)\n&?BLOCK              # current block (itself)\n\n# Dynamic variables\n\n$*USAGE              # value of the auto-generated USAGE message\n$*PROGRAM-NAME       # path to the current executable\n$*PROGRAM            # location (in the form of an IO::Path object) of the Raku program being executed\n@*ARGS               # command-line arguments\n$*ARGFILES           # the magic command-line input handle\n$*CWD                # current working directory\n$*DISTRO             # which OS distribution am I running under\n%*ENV                # system environment variables\n$*ERR                # standard error handle\n$*EXECUTABLE-NAME    # name of the Raku executable that is currently running\n$*EXECUTABLE         # IO::Path absolute path of the Raku executable that is currently running\n$*IN                 # standard input handle; is an IO object\n$*KERNEL             # operating system running under\n$*OUT                # standard output handle\n$*RAKU               # Raku version running under\n$*PID                # system process id\n$*TZ                 # local time zone\n$*USER               # system user id\n\n# Run-time variables\n\n$*COLLATION          # object that can be used to configure Unicode collation levels\n$*TOLERANCE          # used by the =~= operator to decide if two values are approximately equal\n$*DEFAULT-READ-ELEMS # affects the number of bytes read by default by IO::Handle.read\n\n```\n\nAlso, not really a variable but...\n\n```\n *  # A standalone term that has no fixed value, instead it captures the notion of \"Whatever\",\n    # the meaning of which is decided lazily by whatever it is an argument to.\n    # See the docs on Whatever: https://docs.raku.org/type/Whatever\n\n```"}]}
{"messages": [{"role": "user", "content": "Render the text       **This is an example of speech synthesis**      as speech.\n\nRelated task\n:   * using a speech engine to highlight words"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nrun 'espeak', 'This is an example of speech synthesis.';\n\n```"}]}
{"messages": [{"role": "user", "content": "**Ordinal numbers**   (as used in this Rosetta Code task),   are numbers that describe the   *position*   of something in a list.\n\nIt is this context that ordinal numbers will be used, using an English-spelled name of an ordinal number.\n\nThe ordinal numbers are   (at least, one form of them):\n\n```\n  1st  2nd  3rd  4th  5th  6th  7th  ···  99th  100th  ···  1000000000th  ···  etc\n\n```\n\nsometimes expressed as:\n\n```\n  1st  2nd  3rd  4th  5th  6th  7th  ···  99th  100th  ···  1000000000th  ···\n\n```\n\nFor this task, the following (English-spelled form) will be used:\n\n```\n  first second third fourth fifth sixth seventh ninety-nineth one hundredth one billionth\n\n```\n\nFurthermore, the short scale numbering system (i.e. 2,000,000,000 is two billion) will be used here. wp:Long and short scales\n\n**2,000,000,000**   is two billion,   *not*   two milliard.\n\nTask\n\nWrite a driver and a function (subroutine/routine ···) that returns the English-spelled ordinal version of a specified number   (a positive integer).\n\nOptionally, try to support as many forms of an integer that can be expressed:   **123**   **00123.0**   **1.23e2**   all are forms of the same integer.\n\nShow all output here.\n\nTest cases\n\nUse (at least) the test cases of:\n\n```\n  1  2  3  4  5  11  65  100  101  272  23456  8007006005004003\n\n```\n\nRelated tasks\n\n* Number names\n* N'th"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nRakudo version 2019.07.1 is updated to Unicode version 12.1. Unicode version 12.0 introduced some new numeric digits, which changed the output here a bit. This will *work* with earlier versions of Rakudo, but will yield slightly different results.\n\nThis would be pretty simple to implement from scratch; it would be straightforward to do a minor modification of the Number names task code. Much simpler to just use the Lingua::EN::Numbers module from the Raku ecosystem though. It will easily handles ordinal number conversions.\n\nWe need to be slightly careful of terminology. In Raku, 123, 00123.0, & 1.23e2 are not all integers. They are respectively an Int (integer), a Rat (rational number) and a Num (floating point number). (The fourth numeric is a Complex) For this task it doesn't much matter as the ordinal routine coerces its argument to an Int, but to Raku they are different things. We can further abuse allomorphic and String types and role mixins for some somewhat non-intuitive results as well.\n\nNote that the different allomorphic integer forms of 123 are evaluated on *use*, not on *assignment*. They can be passed around in parameters, but until they are used numerically, they retain their stringy characteristics and are distinctive, determinable through introspection. The numerics are evaluated on assignment, hence the stringified output not exactly matching the input format. The mixin role returns different things depending on what context you evaluate it under. When evaluated as a string it is 17, numerically, it is 123.\n\nRaku uses Unicode natively. If a glyph has a Unicode 'Numeric Digit' (<:Nd>) property, it is treated as a numeric digit, and may be used as one.\n\nIt is not really clear what is meant by \"Write a driver and a function...\". Well, the function part is clear enough; driver not so much. Perhaps this will suffice.\n\n```\nuse Lingua::EN::Numbers;\n\n# The task\n+$_ ?? printf( \"Type: \\%-14s %16s : %s\\n\", .^name, $_, .&ordinal ) !! say \"\\n$_:\" for\n\n# Testing\n'Required tests',\n1, 2, 3, 4, 5, 11, 65, 100, 101, 272, 23456, 8007006005004003,\n\n'Optional tests - different forms of 123',\n'Numerics',\n123, 00123.0, 1.23e2, 123+0i,\n\n'Allomorphs',\n|<123 1_2_3 00123.0 1.23e2 123+0i 0b1111011 0o173 0x7B 861/7>,\n\n'Numeric Strings',\n|'1_2_3 00123.0 1.23e2 123+0i 0b1111011 0o173 0x7B 861/7'.words,\n\n'Unicode Numeric Strings',\n# (Only using groups of digits from the same Unicode block. Technically,\n# digits from any block could be combined with digits from any other block.)\n|(^0x1FFFF).grep( { .chr ~~ /<:Nd>/ and .unival == 1|2|3 }).rotor(3)».chr».join,\n\n'Role Mixin',\n'17' but 123;\n\n```\n\nOutput:\n\n```\nRequired tests:\nType: Int                           1 : first\nType: Int                           2 : second\nType: Int                           3 : third\nType: Int                           4 : fourth\nType: Int                           5 : fifth\nType: Int                          11 : eleventh\nType: Int                          65 : sixty-fifth\nType: Int                         100 : one hundredth\nType: Int                         101 : one hundred first\nType: Int                         272 : two hundred seventy-second\nType: Int                       23456 : twenty-three thousand, four hundred fifty-sixth\nType: Int            8007006005004003 : eight quadrillion, seven trillion, six billion, five million, four thousand third\n\nOptional tests - different forms of 123:\n\nNumerics:\nType: Int                         123 : one hundred twenty-third\nType: Rat                         123 : one hundred twenty-third\nType: Num                         123 : one hundred twenty-third\nType: Complex                  123+0i : one hundred twenty-third\n\nAllomorphs:\nType: IntStr                      123 : one hundred twenty-third\nType: IntStr                    1_2_3 : one hundred twenty-third\nType: RatStr                  00123.0 : one hundred twenty-third\nType: NumStr                   1.23e2 : one hundred twenty-third\nType: ComplexStr               123+0i : one hundred twenty-third\nType: IntStr                0b1111011 : one hundred twenty-third\nType: IntStr                    0o173 : one hundred twenty-third\nType: IntStr                     0x7B : one hundred twenty-third\nType: RatStr                    861/7 : one hundred twenty-third\n\nNumeric Strings:\nType: Str                       1_2_3 : one hundred twenty-third\nType: Str                     00123.0 : one hundred twenty-third\nType: Str                      1.23e2 : one hundred twenty-third\nType: Str                      123+0i : one hundred twenty-third\nType: Str                   0b1111011 : one hundred twenty-third\nType: Str                       0o173 : one hundred twenty-third\nType: Str                        0x7B : one hundred twenty-third\nType: Str                       861/7 : one hundred twenty-third\n\nUnicode Numeric Strings:\nType: Str                         123 : one hundred twenty-third\nType: Str                         ١٢٣ : one hundred twenty-third\nType: Str                         ۱۲۳ : one hundred twenty-third\nType: Str                         ߁߂߃ : one hundred twenty-third\nType: Str                         १२३ : one hundred twenty-third\nType: Str                         ১২৩ : one hundred twenty-third\nType: Str                         ੧੨੩ : one hundred twenty-third\nType: Str                         ૧૨૩ : one hundred twenty-third\nType: Str                         ୧୨୩ : one hundred twenty-third\nType: Str                         ௧௨௩ : one hundred twenty-third\nType: Str                         ౧౨౩ : one hundred twenty-third\nType: Str                         ೧೨೩ : one hundred twenty-third\nType: Str                         ൧൨൩ : one hundred twenty-third\nType: Str                         ෧෨෩ : one hundred twenty-third\nType: Str                         ๑๒๓ : one hundred twenty-third\nType: Str                         ໑໒໓ : one hundred twenty-third\nType: Str                         ༡༢༣ : one hundred twenty-third\nType: Str                         ၁၂၃ : one hundred twenty-third\nType: Str                         ႑႒႓ : one hundred twenty-third\nType: Str                         ១២៣ : one hundred twenty-third\nType: Str                         ᠑᠒᠓ : one hundred twenty-third\nType: Str                         ᥇᥈᥉ : one hundred twenty-third\nType: Str                         ᧑᧒᧓ : one hundred twenty-third\nType: Str                         ᪁᪂᪃ : one hundred twenty-third\nType: Str                         ᪑᪒᪓ : one hundred twenty-third\nType: Str                         ᭑᭒᭓ : one hundred twenty-third\nType: Str                         ᮱᮲᮳ : one hundred twenty-third\nType: Str                         ᱁᱂᱃ : one hundred twenty-third\nType: Str                         ᱑᱒᱓ : one hundred twenty-third\nType: Str                         ꘡꘢꘣ : one hundred twenty-third\nType: Str                         ꣑꣒꣓ : one hundred twenty-third\nType: Str                         ꤁꤂꤃ : one hundred twenty-third\nType: Str                         ꧑꧒꧓ : one hundred twenty-third\nType: Str                         ꧱꧲꧳ : one hundred twenty-third\nType: Str                         ꩑꩒꩓ : one hundred twenty-third\nType: Str                         ꯱꯲꯳ : one hundred twenty-third\nType: Str                         １２３ : one hundred twenty-third\nType: Str                         𐒡𐒢𐒣 : one hundred twenty-third\nType: Str                         𐴱𐴲𐴳 : one hundred twenty-third\nType: Str                         𑁧𑁨𑁩 : one hundred twenty-third\nType: Str                         𑃱𑃲𑃳 : one hundred twenty-third\nType: Str                         𑄷𑄸𑄹 : one hundred twenty-third\nType: Str                         𑇑𑇒𑇓 : one hundred twenty-third\nType: Str                         𑋱𑋲𑋳 : one hundred twenty-third\nType: Str                         𑑑𑑒𑑓 : one hundred twenty-third\nType: Str                         𑓑𑓒𑓓 : one hundred twenty-third\nType: Str                         𑙑𑙒𑙓 : one hundred twenty-third\nType: Str                         𑛁𑛂𑛃 : one hundred twenty-third\nType: Str                         𑜱𑜲𑜳 : one hundred twenty-third\nType: Str                         𑣡𑣢𑣣 : one hundred twenty-third\nType: Str                         𑱑𑱒𑱓 : one hundred twenty-third\nType: Str                         𑵑𑵒𑵓 : one hundred twenty-third\nType: Str                         𑶡𑶢𑶣 : one hundred twenty-third\nType: Str                         𖩡𖩢𖩣 : one hundred twenty-third\nType: Str                         𖭑𖭒𖭓 : one hundred twenty-third\nType: Str                         𝟏𝟐𝟑 : one hundred twenty-third\nType: Str                         𝟙𝟚𝟛 : one hundred twenty-third\nType: Str                         𝟣𝟤𝟥 : one hundred twenty-third\nType: Str                         𝟭𝟮𝟯 : one hundred twenty-third\nType: Str                         𝟷𝟸𝟹 : one hundred twenty-third\nType: Str                         𞥑𞥒𞥓 : one hundred twenty-third\n\nRole Mixin:\nType: Str+{<anon|1>}               17 : one hundred twenty-third\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nA **sphenic number** is a positive integer that is the product of three distinct prime numbers. More technically it's a square-free 3-almost prime (see Related tasks below).\n\nFor the purposes of this task, a **sphenic triplet** is a group of three sphenic numbers which are consecutive.\n\nNote that sphenic quadruplets are not possible because every fourth consecutive positive integer is divisible by 4 (= 2 x 2) and its prime factors would not therefore be distinct.\n\nExamples\n\n30 (= 2 x 3 x 5) is a sphenic number and is also clearly the first one.\n\n[1309, 1310, 1311] is a sphenic triplet because 1309 (= 7 x 11 x 17), 1310 (= 2 x 5 x 31) and 1311 (= 3 x 19 x 23) are 3 consecutive sphenic numbers.\n\nTask\n\nCalculate and show here:\n\n1. All sphenic numbers less than 1,000.\n\n2. All sphenic triplets less than 10,000.\n\nStretch\n\n3. How many sphenic numbers are there less than 1 million?\n\n4. How many sphenic triplets are there less than 1 million?\n\n5. What is the 200,000th sphenic number and its 3 prime factors?\n\n6. What is the 5,000th sphenic triplet?\n\nHint: you only need to consider sphenic numbers less than 1 million to answer 5. and 6.\n\nReferences\n\n* Wikipedia: Sphenic number\n* OEIS:A007304 - Sphenic numbers\n* OEIS:A165936 - Sphenic triplets (in effect)\n\nRelated tasks\n\n* Almost prime\n* Square-free integers"}, {"role": "assistant", "content": "Not the most efficient algorithm, but **massively** parallelizable, so finishes pretty quickly.\n\n```\nuse Prime::Factor;\nuse List::Divvy;\nuse Lingua::EN::Numbers;\n\nmy @sphenic = lazy (^Inf).hyper(:200batch).grep: { my @pf = .&prime-factors; +@pf == 3 and +@pf.unique == 3 };\nmy @triplets = lazy (^Inf).grep( { @sphenic[$_]+2 == @sphenic[$_+2] } ).map: {(@sphenic[$_,$_+1,$_+2])}\n\nsay \"Sphenic numbers less than 1,000:\\n\" ~\n    @sphenic.&upto(1e3).batch(15)».fmt(\"%3d\").join: \"\\n\";\n\nsay \"\\nSphenic triplets less than 10,000:\";\n.say for @triplets.&before(*.[2] > 1e4);\n\nsay \"\\nThere are {(+@sphenic.&upto(1e6)).&comma} sphenic numbers less than {1e6.Int.&comma}\";\nsay \"There are {(+@triplets.&before(*.[2] > 1e6)).&comma} sphenic triplets less than {1e6.Int.&comma}\";\nsay \"The 200,000th sphenic number is {@sphenic[2e5-1].&comma} ({@sphenic[2e5-1].&prime-factors.join(' × ')}).\";\nsay \"The 5,000th sphenic triplet is ({@triplets[5e3-1].join(', ')}).\"\n\n```\n\nOutput:\n\n```\nSphenic numbers less than 1,000:\n 30  42  66  70  78 102 105 110 114 130 138 154 165 170 174\n182 186 190 195 222 230 231 238 246 255 258 266 273 282 285\n286 290 310 318 322 345 354 357 366 370 374 385 399 402 406\n410 418 426 429 430 434 435 438 442 455 465 470 474 483 494\n498 506 518 530 534 555 561 574 582 590 595 598 602 606 609\n610 615 618 627 638 642 645 646 651 654 658 663 665 670 678\n682 705 710 715 730 741 742 754 759 762 777 782 786 790 795\n805 806 814 822 826 830 834 854 861 874 885 890 894 897 902\n903 906 915 935 938 942 946 957 962 969 970 978 986 987 994\n\nSphenic triplets less than 10,000:\n(1309 1310 1311)\n(1885 1886 1887)\n(2013 2014 2015)\n(2665 2666 2667)\n(3729 3730 3731)\n(5133 5134 5135)\n(6061 6062 6063)\n(6213 6214 6215)\n(6305 6306 6307)\n(6477 6478 6479)\n(6853 6854 6855)\n(6985 6986 6987)\n(7257 7258 7259)\n(7953 7954 7955)\n(8393 8394 8395)\n(8533 8534 8535)\n(8785 8786 8787)\n(9213 9214 9215)\n(9453 9454 9455)\n(9821 9822 9823)\n(9877 9878 9879)\n\nThere are 206,964 sphenic numbers less than 1,000,000\nThere are 5,457 sphenic triplets less than 1,000,000\nThe 200,000th sphenic number is 966,467 (17 × 139 × 409).\nThe 5,000th sphenic triplet is (918005, 918006, 918007).\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nAn animation with the following frames in the following order (if certain characters aren't available or can't be used correctly in the programming language, alternate characters can replace any of these frames) must animate with a delay of 0.25 seconds between each frame, with the previous frame being cleared before the next frame appears:\n\n:   * |\n    * /\n    * - or ─\n    * \\\n\nA stand-alone version that loops and/or a version that doesn't loop can be made. These examples can also be converted into a system used in game development which is called on a HUD or GUI element requiring it to be called each frame to output the text, and advance the frame when the frame delay has passed. You can also use alternate text such as the . animation ( . | .. | ... | .. | repeat from . ) or the logic can be updated to include a ping/pong style where the frames advance forward, reach the end and then play backwards and when they reach the beginning they start over ( technically, you'd stop one frame prior to prevent the first frame playing twice, or write it another way ).  \n  \nThere are many different ways you can incorporate text animations. Here are a few text ideas - each frame is in quotes. If you can think of any, add them to this page! There are 2 examples for several of these; the first is the base animation with only unique sets of characters. The second consists of the primary set from a - n and doubled, minus the first and last element ie: We only want the center. This way an animation can play forwards, and then in reverse ( ping ponging ) without having to code that feature. For the animations with 3 elements, we only add 1, the center. with 4, it becomes 6. with 10, it becomes 18.  \n  \nWe don't need the second option for some of the animations if they connect smoothly, when animated, back to the first element. ... doesn't connect with . cleanly - there is a large leap. The rotating pipe meets the first perfectly so it isn't necessary, etc..\n\n:   * Dots - Option A requires ping / pong enabled script. Option B just adds the elements in the center.\n      + '.', '..', '...'\n      + '.', '..', '...', '..'\n    * Pipe - This has the uniform sideways pipe instead of a hyphen to prevent non-uniform sizing.\n      + '|', '/', '─', '\\'\n    * Stars - Option A requires ping / pong enabled script. Option B just adds the elements from the center.\n      + '⁎', '⁑', '⁂'\n      + '⁎', '⁑', '⁂', '⁑'\n    * Clock - These need to be ordered. I haven't done this yet as the application I was testing the system in doesn't support these wingdings / icons. But this would look quite nice and you could set it up to go forward, or backward during an undo process, etc..\n      + '🕛', '🕧', '🕐', '🕜', '🕑', '🕝', '🕒', '🕞', '🕓', '🕟', '🕔', '🕠', '🕕', '🕖', '🕗', '🕘', '🕙', '🕚', '🕡', '🕢', '🕣', '🕤', '🕥', '🕦'\n    * Arrows:\n      + '⬍', '⬈', '➞', '⬊', '⬍', '⬋', '⬅', '⬉'\n    * Bird - This looks decent but may be missing something.\n      + '︷', '︵', '︹', '︺', '︶', '︸'\n      + '︷', '︵', '︹', '︺', '︶', '︸', '︶', '︺', '︹', '︵'\n    * Plants - This isn't quite complete\n      + '☘', '❀', '❁'\n      + '☘', '❀', '❁', '❀'\n    * Eclipse - From Raku Throbber post author\n      + '🌑', '🌒', '🌓', '🌔', '🌕', '🌖', '🌗', '🌘'"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.05\n\nTraditionally these are know as throbbers or progress indicators.\n\nThis implementation will accept an array of elements to use as its throbber frames, or as a scrolling marquee and optionally a delay before it returns the next element.\n\n```\nclass throbber {\n    has @.frames;\n    has $.delay is rw = 0;\n    has $!index = 0;\n    has Bool $.marquee = False;\n    method next {\n        $!index = ($!index + 1) % +@.frames;\n        sleep $.delay if $.delay;\n        if $!marquee {\n            (\"\\b\" x @.frames) ~ @.frames.rotate($!index).join;\n        }\n        else {\n            \"\\b\" ~ @.frames[$!index];\n        }\n    }\n}\n\nmy $rod = throbber.new( :frames(< | / - \\ >), :delay(.25) );\nprint \"\\e[?25lLong running process...  \";\nprint $rod.next for ^20;\n\nmy $clock = throbber.new( :frames(\"🕐\" .. \"🕛\") );\nprint \"\\r\\nSomething else with a delay...   \";\nuntil my $done {\n    # do something in a loop;\n    sleep 1/12;\n    print \"\\b\", $clock.next;\n    $done = True if $++ >= 60;\n}\n\nmy $moon = throbber.new( :frames('🌑🌒🌓🌔🌕🌖🌗🌘'.comb) );\nprint \"\\r\\nGonna be a long night...   \";\nuntil my $end {\n    # do something in a loop;\n    sleep 1/8;\n    print \"\\b\", $moon.next;\n    $end = True if $++ >= 60;\n}\n\nmy $scroll = throbber.new( :frames('PLEASE STAND BY...      '.comb), :delay(.1), :marquee );\nprint \"\\r\\nEXPERIENCING TECHNICAL DIFFICULTIES: { $scroll.frames.join }\";\nprint $scroll.next for ^95;\n\nEND { print \"\\e[?25h\\n\" } # clean up on exit\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nProduce a spiral array.\n\nA   *spiral array*   is a square arrangement of the first    N2   natural numbers,   where the\n  \nnumbers increase sequentially as you go around the edges of the array spiraling inwards.\n\nFor example, given   **5**,   produce this array:\n\n```\n 0  1  2  3  4\n15 16 17 18  5\n14 23 24 19  6\n13 22 21 20  7\n12 11 10  9  8\n\n```\n\nRelated tasks\n\n* Zig-zag matrix\n* Identity\\_matrix\n* Ulam\\_spiral\\_(for\\_primes)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Object-oriented Solution\n\nSuppose we set up a Turtle class like this:\n\n```\nclass Turtle {\n    my @dv =  [0,-1], [1,-1], [1,0], [1,1], [0,1], [-1,1], [-1,0], [-1,-1];\n    my $points = 8; # 'compass' points of neighbors on grid: north=0, northeast=1, east=2, etc.\n\n    has @.loc = 0,0;\n    has $.dir = 0;\n    has %.world;\n    has $.maxegg;\n    has $.range-x;\n    has $.range-y;\n\n    method turn-left ($angle = 90) { $!dir -= $angle / 45; $!dir %= $points; }\n    method turn-right($angle = 90) { $!dir += $angle / 45; $!dir %= $points; }\n\n    method lay-egg($egg) {\n    %!world{~@!loc} = $egg;\n    $!maxegg max= $egg;\n    $!range-x minmax= @!loc[0];\n    $!range-y minmax= @!loc[1];\n    }\n\n    method look($ahead = 1) {\n    my $there = @!loc »+« @dv[$!dir] »*» $ahead;\n    %!world{~$there};\n    }\n\n    method forward($ahead = 1) {\n    my $there = @!loc »+« @dv[$!dir] »*» $ahead;\n    @!loc = @($there);\n    }\n\n    method showmap() {\n    my $form = \"%{$!maxegg.chars}s\";\n    my $endx = $!range-x.max;\n        for $!range-y.list X $!range-x.list -> ($y, $x) {\n        print (%!world{\"$x $y\"} // '').fmt($form);\n        print $x == $endx ?? \"\\n\" !! ' ';\n    }\n    }\n}\n\n# Now we can build the spiral in the normal way from outside-in like this:\n\nsub MAIN(Int $size = 5) {\nmy $t = Turtle.new(dir => 2);\nmy $counter = 0;\n$t.forward(-1);\nfor 0..^ $size -> $ {\n    $t.forward;\n    $t.lay-egg($counter++);\n}\nfor $size-1 ... 1 -> $run {\n    $t.turn-right;\n    $t.forward, $t.lay-egg($counter++) for 0..^$run;\n    $t.turn-right;\n    $t.forward, $t.lay-egg($counter++) for 0..^$run;\n}\n$t.showmap;\n}\n\n```\n\nOr we can build the spiral from inside-out like this:\n\n```\nsub MAIN(Int $size = 5) {\nmy $t = Turtle.new(dir => ($size %% 2 ?? 4 !! 0));\nmy $counter = $size * $size;\nwhile $counter {\n    $t.lay-egg(--$counter);\n    $t.turn-left;\n    $t.turn-right if $t.look;\n    $t.forward;\n}\n$t.showmap;\n}\n\n```\n\nNote that with these \"turtle graphics\" we don't actually have to care about the coordinate system, since the `showmap` method can show whatever rectangle was modified by the turtle. So unlike the standard inside-out algorithm, we don't have to find the center of the matrix first.\n\n### Procedural Solution\n\n```\nsub spiral_matrix ( $n ) {\n    my @sm;\n    my $len = $n;\n    my $pos = 0;\n\n    for ^($n/2).ceiling -> $i {\n        my $j = $i +  1;\n        my $e = $n - $j;\n\n        @sm[$i     ][$i + $_] = $pos++ for         ^(  $len); # Top\n        @sm[$j + $_][$e     ] = $pos++ for         ^(--$len); # Right\n        @sm[$e     ][$i + $_] = $pos++ for reverse ^(  $len); # Bottom\n        @sm[$j + $_][$i     ] = $pos++ for reverse ^(--$len); # Left\n    }\n\n    return @sm;\n}\n\nsay .fmt('%3d') for spiral_matrix(5);\n\n```\n\nOutput:\n\n```\n 0   1   2   3   4\n15  16  17  18   5\n14  23  24  19   6\n13  22  21  20   7\n12  11  10   9   8\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSplit a (character) string into comma (plus a blank) delimited\nstrings based on a change of character   (left to right).\n\nShow the output here   (use the 1st example below).\n\nBlanks should be treated as any other character   (except\nthey are problematic to display clearly).   The same applies\nto commas.\n\nFor instance, the string:\n\n```\n gHHH5YY++///\\ \n\n```\n\nshould be split and show:\n\n```\n g, HHH, 5, YY, ++, ///, \\ \n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.05\n\n```\nsub group-chars ($str) { $str.comb: / (.) $0* / }\n\n# Testing:\n\nfor Q[gHHH5YY++///\\], Q[fffn⃗n⃗n⃗»»»  ℵℵ☄☄☃☃̂☃🤔🇺🇸🤦‍♂️👨‍👩‍👧‍👦] -> $string {\n    put 'Original: ', $string;\n    put '   Split: ', group-chars($string).join(', ');\n}\n\n```\n\nOutput:\n\n```\nOriginal: gHHH5YY++///\\\n   Split: g, HHH, 5, YY, ++, ///, \\\nOriginal: fffn⃗n⃗n⃗»»»  ℵℵ☄☄☃☃̂☃🤔🇺🇸🤦‍♂️👨‍👩‍👧‍👦\n   Split: fff, , n⃗n⃗n⃗, »»»,   , ℵℵ, ☄☄, ☃, ☃̂, ☃, 🤔, 🇺🇸, 🤦‍♂️, 👨‍👩‍👧‍👦\n\n```\n\nThe second test-case is to show that Raku works with strings on the Unicode grapheme level, handles whitespace, combiners, and zero width characters up to Unicode Version 13.0 correctly. (Raku generally tracks updates to the Unicode spec and typically lags no more than a month behind.) For those of you with browsers unable to display the second string, it consists of:\n\n* {LATIN SMALL LETTER F} x 3\n* {ZERO WIDTH NO-BREAK SPACE} x 3\n* {LATIN SMALL LETTER N, COMBINING RIGHT ARROW ABOVE} x 3\n* {RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK} x 3\n* {SPACE} x 2,\n* {ALEF SYMBOL} x 2,\n* {COMET} x 2,\n* {SNOWMAN} x 1,\n* {SNOWMAN, COMBINING CIRCUMFLEX ACCENT} x 1\n* {SNOWMAN} x 1,\n* {THINKING FACE} x 1\n* {REGIONAL INDICATOR SYMBOL LETTER U, REGIONAL INDICATOR SYMBOL LETTER S} x 1\n* {FACE PALM, ZERO WIDTH JOINER, MALE SIGN, VARIATION SELECTOR-16} x 1\n* {MAN, ZERO WIDTH JOINER, WOMAN, ZERO WIDTH JOINER, GIRL, ZERO WIDTH JOINER, BOY} x 1"}]}
{"messages": [{"role": "user", "content": "Create Spoof game. See details: Spoof game"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nsub query_for_integer ($prompt) { loop { ($_ = prompt \"$prompt \") ~~ /^ \\d+ $/ ?? return $_ !! say '(need an integer)'; } }\n\nsub spoof_for_2 {\n    my ($mypot, $myguess, $yourpot, $yourguess) = 0, 0, 0, 0;\n    my $ngames = query_for_integer('How many games do you want?');\n\n    for 1 .. $ngames {\n\n        repeat {\n            $mypot   = 1 + 3.rand.Int;\n            $myguess = 1 + 6.rand.Int;\n        } until $mypot+3 < $myguess;\n        say 'I have set my pot and guess.';\n\n        repeat {\n            $yourpot   = query_for_integer('Your pot?'  );\n            $yourguess = query_for_integer('Your guess?');\n        } until 0 <= $yourpot & $yourguess <= 6 and $yourpot+4 > $yourguess;\n\n        say \"My pot is: $mypot\\nMy guess is: $myguess\";\n\n        given $mypot + $yourpot {\n            when $myguess & $yourguess { say 'Draw!'      }\n            when $myguess              { say 'I won!'     }\n            when            $yourguess { say 'You won!'   }\n            default                    { say 'No winner!' }\n        }\n    }\n}\n\nspoof_for_2();\n\n```\n\nOutput:\n\n```\nHow many games do you want? 1\nYour pot? 2\nYour guess? 3\nI have set my pot and guess.\nMy pot is: 1\nMy guess is: 5\nYou won!\n```"}]}
{"messages": [{"role": "user", "content": "This task has three parts:\n\n* Connect to a MySQL database (connect\\_db)\n* Create user/password records in the following table (create\\_user)\n* Authenticate login requests against the table (authenticate\\_user)\n\nThis is the table definition:\n\n```\ncreate table users (\n    userid int primary key auto_increment,\n    username varchar(32) unique key not null,\n    pass_salt tinyblob not null,\n            -- a string of 16 random bytes\n    pass_md5 tinyblob not null\n            -- binary MD5 hash of pass_salt concatenated with the password\n);\n\n```\n\n(pass\\_salt and pass\\_md5 would be binary(16) values, but MySQL versions before 5.0.15 strip trailing spaces when selecting them.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nuse v6;\nuse DBIish;\n\nmulti connect_db(:$dbname, :$host, :$user, :$pass) {\n   my $db = DBIish.connect(\"mysql\",host => $host, database =>$dbname, user =>$user, password =>$pass, :RaiseError) \n      or die \"ERROR: {DBIish.errstr}.\";\n   $db;\n}\n\nmulti create_user(:$db, :$user, :$pass) {\n   #https://stackoverflow.com/questions/53365101/converting-pack-to-perl6\n   my $salt = Buf.new((^256).roll(16));\n   my $sth = $db.prepare(q:to/STATEMENT/);\n      INSERT IGNORE INTO users (username, pass_salt, pass_md5)\n      VALUES (?, ?, unhex(md5(concat(pass_salt, ?))))\n   STATEMENT\n   $sth.execute($user,$salt,$pass);\n   $sth.insert-id or Any;\n}\n\nmulti authenticate_user (:$db, :$user, :$pass) {\n   my $sth = $db.prepare(q:to/STATEMENT/);\n       SELECT userid FROM users WHERE\n       username=? AND pass_md5=unhex(md5(concat(pass_salt, ?)))\n   STATEMENT\n   $sth.execute($user,$pass);\n   my $userid =  $sth.fetch;\n   $userid[0] or Any;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow the first   **30**   positive integers which are squares but not cubes of such integers.\n\nOptionally, show also the first   **3**   positive integers which are both squares and cubes,   and mark them as such."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @square-and-cube = map { .⁶ }, 1..Inf;\n\nmy @square-but-not-cube = (1..Inf).map({ .² }).grep({ $_ ∉ @square-and-cube[^@square-and-cube.first: * > $_, :k]});\n\nput \"First 30 positive integers that are a square but not a cube: \\n\",  @square-but-not-cube[^30];\n\nput \"\\nFirst 15 positive integers that are both a square and a cube: \\n\", @square-and-cube[^15];\n\n```\n\nOutput:\n\n```\nFirst 30 positive integers that are a square but not a cube: \n4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089\n\nFirst 15 positive integers that are both a square and a cube: \n1 64 729 4096 15625 46656 117649 262144 531441 1000000 1771561 2985984 4826809 7529536 11390625\n```"}]}
{"messages": [{"role": "user", "content": "Task.\n\nDaniel Shanks's Square Form Factorization (SquFoF).\n\nInvented around 1975, *‘On a 32-bit computer, SquFoF is the clear champion factoring algorithm*\n*for numbers between 1010 and 1018, and will likely remain so.’*\n\nAn integral binary quadratic form is a polynomial\n*f*(*x,y*) = *ax2* + *bxy* + *cy2*\nwith integer coefficients and discriminant *D* = *b2* – *4ac*.\nFor each positive discriminant there are multiple forms (*a, b, c*).\n\nThe next form in a periodic sequence (cycle) of adjacent forms is found by applying a reduction operator\n*rho*, essentially a variant of Euclid's algorithm for finding the continued fraction of a square root.\nUsing floor(*√N*), rho constructs a *principal form*\n(*1, b, c*) with *D* = *4N*.\n\nSquFoF is based on the existence of cycles containing *ambiguous forms*, with the property that *a* divides *b*.\nThey come in pairs of associated forms (*a, b, c*) and (*c, b, a*) called symmetry points.\nIf an ambiguous form is found (there is one for each divisor of D), write the discriminant as\n(*ak*)*2* – *4ac* = *a*(*a·k2* – *4c*) = *4N*\nand (if a is not equal to 1 or 2) N is split.\n\nShanks used *square forms* to jump to a random ambiguous cycle. Fact: if any form in an ambiguous cycle\nis squared, that square form will always land in the principal cycle. Conversely, the square root of any\nform in the principal cycle lies in an ambiguous cycle. (Possibly the principal cycle itself).\n\nA square form is easy to find: the last coefficient *c* is a perfect square. This happens about once\nevery ∜N-th cycle step and for even indices only. Let rho compute the inverse square root form and track\nthe ambiguous cycle backward until the symmetry point is reached. (Taking the inverse reverses the cycle).\nThen *a* or *a/2* divides D and therefore N.\n\nTo avoid trivial factorizations, Shanks created a list (queue) to hold small coefficients appearing\nearly in the principal cycle, that may be roots of square forms found later on. If these forms are skipped,\nno roots land in the principal cycle itself and cases a = 1 or a = 2 do not happen.\n\nSometimes the cycle length is too short to find a proper square form. This is fixed by running five instances\nof SquFoF in parallel, with input N and 3, 5, 7, 11 times N; the discriminants then will have different periods.\nIf N is prime or the cube of a prime, there are improper squares only and the program will duly report failure.\n\nReference.\n\n[1] A detailed analysis of SquFoF (2007)"}, {"role": "assistant", "content": "### A just for fun snail ..\n\nReferences: Algorithm, C program example from the WP page and also the pseudocode from here.\n\n```\n# 20210325 Raku programming solution\n\nmy @multiplier = ( 1, 3, 5, 7, 11, 3*5, 3*7, 3*11, 5*7, 5*11, 7*11, 3*5*7, 3*5*11, 3*7*11, 5*7*11, 3*5*7*11 );\n\nsub circumfix:<⌊ ⌋>{ $^n.floor }; sub prefix:<√>{ $^n.sqrt }; # just for fun\n\nsub SQUFOF ( \\𝑁 ) {  \n\n   return  1 if 𝑁.is-prime;     # if n is prime             return  1\n   return √𝑁 if √𝑁 == Int(√𝑁);  # if n is a perfect square  return √𝑁\n\n   for @multiplier -> \\𝑘 { \n      my \\Pₒ = $ = ⌊ √(𝑘*𝑁) ⌋;          # P[0]=floor(√N)\n      my \\Qₒ = $ = 1 ;                  # Q[0]=1\n      my \\Q = $ =  𝑘*𝑁 - Pₒ²;           # Q[1]=N-P[0]^2 & Q[i]\n      my \\Pₚᵣₑᵥ = $ = Pₒ;               # P[i-1] = P[0]\n      my \\Qₚᵣₑᵥ = $ = Qₒ;               # Q[i-1] = Q[0] \n      my \\P = $ = 0;                    # P[i]\n      my \\Qₙₑₓₜ = $ = 0;                # P[i+1]\n      my \\b = $ = 0;                    # b[i]\n                                        # i = 1\n      repeat until √Q == Int(√Q) {      # until Q[i] is a perfect square\n         b = ⌊⌊ √(𝑘*𝑁) + Pₚᵣₑᵥ ⌋ / Q ⌋;    # floor(floor(√N+P[i-1])/Q[i])\n         P = b*Q - Pₚᵣₑᵥ;                  # P[i]=b*Q[i]-P[i-1] \n         Qₙₑₓₜ = Qₚᵣₑᵥ + b*(Pₚᵣₑᵥ - P);    # Q[i+1]=Q[i-1]+b(P[i-1]-P[i]) \n         ( Qₚᵣₑᵥ,  Q, Pₚᵣₑᵥ ) = Q, Qₙₑₓₜ, P;  # i++\n      } \n\n      b     = ⌊ ⌊ √(𝑘*𝑁)+P ⌋ / Q ⌋;     # b=floor((floor(√N)+P[i])/Q[0])\n      Pₚᵣₑᵥ = b*Qₒ - P;                 # P[i-1]=b*Q[0]-P[i]\n      Q     = ( 𝑘*𝑁 - Pₚᵣₑᵥ² )/Qₒ;      # Q[1]=(N-P[0]^2)/Q[0] & Q[i]\n      Qₚᵣₑᵥ = Qₒ;                       # Q[i-1] = Q[0]\n                                        # i = 1\n      loop {                            # repeat\n         b  = ⌊ ⌊ √(𝑘*𝑁)+Pₚᵣₑᵥ ⌋ / Q ⌋;    # b=floor(floor(√N)+P[i-1])/Q[i])\n         P  = b*Q - Pₚᵣₑᵥ;                 # P[i]=b*Q[i]-P[i-1]\n         Qₙₑₓₜ = Qₚᵣₑᵥ + b*(Pₚᵣₑᵥ - P);    # Q[i+1]=Q[i-1]+b(P[i-1]-P[i])\n         last if (P == Pₚᵣₑᵥ);          # until P[i+1]=P[i]\n         ( Qₚᵣₑᵥ,  Q, Pₚᵣₑᵥ ) = Q, Qₙₑₓₜ, P; # i++ \n      }  \n      given 𝑁 gcd P { return $_ if $_ != 1|𝑁 }    \n   }  # gcd(N,P[i]) (if != 1 or N) is a factor of N, otherwise try next k\n   return 0 # give up\n}\n\nrace for ( \n   11111, # wikipedia.org/wiki/Shanks%27s_square_forms_factorization#Example\n   4558849, # example from talk page\n   # all of the rest are taken from the FreeBASIC entry\n   2501,12851,13289,75301,120787,967009,997417,7091569,13290059,\n   42854447,223553581,2027651281,11111111111,100895598169,1002742628021,\n   # time hoarders \n   60012462237239, # = 6862753 * 8744663                     15s \n   287129523414791, # = 6059887 * 47381993                   80s\n   11111111111111111, # = 2071723 * 5363222357                2m\n   384307168202281507, # = 415718707 * 924440401              5m\n   1000000000000000127, # = 111756107 * 8948056861           12m\n   9007199254740931, # = 10624181 * 847801751                17m\n   922337203685477563, # = 110075821 * 8379108103            41m\n   314159265358979323, # = 317213509 * 990371647             61m\n   1152921505680588799, # = 139001459 * 8294312261           93m\n   658812288346769681, # = 62222119 * 10588072199           112m\n   419244183493398773, # = 48009977 * 8732438749            135m\n   1537228672809128917, # = 26675843 * 57626245319          254m\n   # don't know how to handle this one\n   # for 1e-323, 1e-324 { my $*TOLERANCE = $_ ; \n   #     say 4611686018427387877.sqrt ≅ 4611686018427387877.sqrt.Int }\n   # skip the perfect square check and start k with 3 to get the following \n   # 4611686018427387877, # = 343242169 * 13435662733       217m\n) -> \\data {\n   given data.&SQUFOF {\n      when 0  { say \"The number \", data, \" is not factored.\" }\n      when 1  { say \"The number \", data, \" is a prime.\" }\n      default { say data, \" = \", $_, \" * \", data div $_.Int }\n   }\n}\n\n```\n\nOutput:\n\n```\n11111 = 41 * 271 \n4558849 = 383 * 11903 \n2501 = 61 * 41 \n12851 = 71 * 181 \n13289 = 97 * 137 \n75301 = 293 * 257 \n120787 = 43 * 2809 \n967009 = 601 * 1609 \n997417 = 257 * 3881 \n7091569 = 2663 * 2663  \n13290059 = 3119 * 4261 \n42854447 = 4423 * 9689 \n223553581 = 11213 * 19937 \n2027651281 = 44021 * 46061 \n11111111111 = 21649 * 513239\n100895598169 = 112303 * 898423 \nThe number 1002742628021 is a prime.\n60012462237239 = 6862753 * 8744663 \n287129523414791 = 6059887 * 47381993 \n11111111111111111 = 2071723 * 5363222357\n384307168202281507 = 415718707 * 924440401 \n1000000000000000127 = 111756107 * 8948056861 \n9007199254740931 = 10624181 * 847801751 \n922337203685477563 = 110075821 * 8379108103 \n314159265358979323 = 317213509 * 990371647\n1152921505680588799 = 139001459 * 8294312261 \n658812288346769681 = 62222119 * 10588072199 \n419244183493398773 = 48009977 * 8732438749 \n1537228672809128917 = 26675843 * 57626245319 \n\n```\n\n### Use NativeCall\n\nUse idea similar to the second approach from here, by compiling the C (Classical heuristic) entry to a shared library and then make use of the squfof routine.\n\nsqufof.raku\n\n```\n# 20210326 Raku programming solution\n\nuse NativeCall;\n\nconstant LIBSQUFOF = '/home/user/LibSQUFOF.so';\n\nsub squfof(uint64 $n) returns uint64 is native(LIBSQUFOF) { * };\n\nrace for (\n   11111, # wikipedia.org/wiki/Shanks%27s_square_forms_factorization#Example\n   4558849, # example from talk page\n   # all of the rest are taken from the FreeBASIC entry\n   2501,12851,13289,75301,120787,967009,997417,7091569,13290059,\n   42854447,223553581,2027651281,11111111111,100895598169,1002742628021,\n   60012462237239, # = 6862753 * 8744663\n   287129523414791, # = 6059887 * 47381993\n   11111111111111111, # = 2071723 * 5363222357\n   384307168202281507, # = 415718707 * 924440401\n   1000000000000000127, # = 111756107 * 8948056861\n   9007199254740931, # = 10624181 * 847801751\n   922337203685477563, # = 110075821 * 8379108103\n   314159265358979323, # = 317213509 * 990371647\n   1152921505680588799, # = 139001459 * 8294312261\n   658812288346769681, # = 62222119 * 10588072199\n   419244183493398773, # = 48009977 * 8732438749\n   1537228672809128917, # = 26675843 * 57626245319\n   4611686018427387877, # = 343242169 * 13435662733\n) -> \\data {\n   given squfof(data) { say data, \" = \", $_, \" * \", data div $_ }\n}\n\n```\n\nOutput:\n\n```\ngcc -Wall -fPIC -shared -o LibSQUFOF.so squfof.c\n\nfile LibSQUFOF.so\nLibSQUFOF.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=f7f9864e5508ba1de80cbc6e2f4d789f4ec448e9, not stripped\nraku -c squfof.raku && time ./squfof.raku\nSyntax OK\n11111 = 41 * 271\n4558849 = 383 * 11903\n2501 = 61 * 41\n12851 = 71 * 181\n13289 = 97 * 137\n75301 = 293 * 257\n120787 = 43 * 2809\n967009 = 1609 * 601\n997417 = 257 * 3881\n7091569 = 2663 * 2663\n13290059 = 3119 * 4261\n42854447 = 4423 * 9689\n223553581 = 11213 * 19937\n2027651281 = 44021 * 46061\n11111111111 = 21649 * 513239\n100895598169 = 112303 * 898423\n1002742628021 = 1 * 1002742628021\n60012462237239 = 6862753 * 8744663\n287129523414791 = 6059887 * 47381993\n11111111111111111 = 2071723 * 5363222357\n384307168202281507 = 415718707 * 924440401\n1000000000000000127 = 111756107 * 8948056861\n9007199254740931 = 10624181 * 847801751\n922337203685477563 = 110075821 * 8379108103\n314159265358979323 = 317213509 * 990371647\n1152921505680588799 = 139001459 * 8294312261\n658812288346769681 = 62222119 * 10588072199\n419244183493398773 = 48009977 * 8732438749\n1537228672809128917 = 26675843 * 57626245319\n4611686018427387877 = 343242169 * 13435662733\n\nreal    0m0.784s\nuser    0m0.716s\nsys     0m0.056s\n\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a program that will calculate   **n**   decimal digits of the square root of a non─negative number.\n\nThe program should continue forever (or until the number of digits is specified) calculating and outputting each decimal digit in succession.\n\nThe program should be a \"spigot algorithm\" generating the digits of the number sequentially from left to right providing increasing precision as the algorithm proceeds."}, {"role": "assistant", "content": "Implemented a long division algorithm..\n\n```\n# 20201023 Raku programming solution\n\nsub integral   (Str $in) { # prepend '0' if length is odd\n   given $in { .chars mod 2 ?? ('0'~$_).comb(2) !! .comb(2) }\n}\n\nsub fractional (Str $in) { # append  '0' if length is odd\n   given $in { .chars mod 2 ?? ($_~'0').comb(2) !! .comb(2) }\n}\n\nsub SpigotSqrt ($in) {\n\n   my @dividends, my @fractional; # holds digital duos\n   my $d = 9;    # unit  digit part of divisors & running answer\n   my $D = '';   # tens+ digit part of divisors\n   my $dot_printed  = False;\n   my $dividend; my $quotient = ''; my $remainder;\n\n   return \"Sorry, minimum charge is $0⁺\" if $in ≤ 0;\n\n   if $in.narrow ~~ Int {                 # integer\n      @dividends = integral($in.Str)\n   } else {\n      given split(/\\./, $in.Str) {        # floating point\n         @dividends  =   integral(@_[0]);\n         @fractional = fractional(@_[1]);\n      }\n   }\n\n   $dividend = shift @dividends;\n\n   loop {\n      until ( $remainder = $dividend - ($D~$d) * $d ) ≥ 0 {\n         $d-- # keep trying till the max divisor is found\n      }\n      print $d; # running answer\n      $quotient ~= $d;\n      unless @dividends.Bool {\n         last if ( $remainder == 0 and $quotient != 0 and !@fractional.Bool );\n         unless $dot_printed { print '.' and $dot_printed = True }\n         if @fractional.Bool {      # happen only once\n            @dividends.append: @fractional;\n            @fractional = (); # retired\n         } else {\n            @dividends.append: '00';\n         }\n      }\n      $dividend = $remainder.Str ~ shift @dividends;\n      $D = 2*$quotient;\n      $d = 9\n   }\n}\n\n#`[ matches result from https://stackoverflow.com/a/28152047/3386748\nfor <99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999982920000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000726067> { # ]\nfor < 25 0.0625 152.2756 13579.02468 > {\n   say \"The square root of $_ is\";\n   SpigotSqrt $_ ; print \"\\n\";\n}\n\n```\n\nOutput:\n\n```\nThe square root of 25 is\n5\nThe square root of 0.0625 is\n0.25\nThe square root of 152.2756 is\n12.34\nThe square root of 13579.02468 is\n116.5290722523782903561833846788464631805119729204989141878325473726703822155976113726101636833624692173783050112427274490403132495026916228339453686341013613481116569793281525666303293666139135373395664751766204609166006753350008676787108560810713189340122619853015331030735400702976991920098868235804433621649473896395145322270105611438518020713137788187701241059921153133101219142225340975562189465283743880315403123043908068827985609461380033349440281928044661628680849458194668644072518779930532625670101046028192429778354952392572052578927533919600336446165970115867463651405291843435779882540897283554569528134419570259054368204716277521872340583781499813500950876849873104131526244245476070417915^C\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function to test if a number is   *square-free*.\n\nA   *square-free*   is an integer which is divisible by no perfect square other\nthan   **1**   (unity).\n\nFor this task, only positive square-free numbers will be used.\n\nShow here (on this page) all square-free integers (in a horizontal format) that are between:\n\n:   :   * **1**   ───►   **145**     (inclusive)\n        * **1** trillion   ───►   **1** trillion + **145**     (inclusive)\n\n(One trillion = 1,000,000,000,000)\n\nShow here (on this page) the count of square-free integers from:\n\n:   :   * **1**   ───►   one hundred     (inclusive)\n        * **1**   ───►   one thousand     (inclusive)\n        * **1**   ───►   ten thousand     (inclusive)\n        * **1**   ───►   one hundred thousand     (inclusive)\n        * **1**   ───►   one million     (inclusive)\n\nSee also\n:   * the Wikipedia entry:   square-free integer"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.06\n\nThe prime factoring algorithm is not really the best option for finding long runs of sequential square-free numbers. It works, but is probably better suited for testing arbitrary numbers rather than testing every sequential number from 1 to some limit. If you know that that is going to be your use case, there are faster algorithms.\n\n```\n# Prime factorization routines\nsub prime-factors ( Int $n where * > 0 ) {\n    return $n if $n.is-prime;\n    return [] if $n == 1;\n    my $factor = find-factor( $n );\n    flat prime-factors( $factor ), prime-factors( $n div $factor );\n}\n\nsub find-factor ( Int $n, $constant = 1 ) {\n    return 2 unless $n +& 1;\n    if (my $gcd = $n gcd 6541380665835015) > 1 {\n        return $gcd if $gcd != $n\n    }\n    my $x      = 2;\n    my $rho    = 1;\n    my $factor = 1;\n    while $factor == 1 {\n        $rho *= 2;\n        my $fixed = $x;\n        for ^$rho {\n            $x = ( $x * $x + $constant ) % $n;\n            $factor = ( $x - $fixed ) gcd $n;\n            last if 1 < $factor;\n        }\n    }\n    $factor = find-factor( $n, $constant + 1 ) if $n == $factor;\n    $factor;\n}\n\n# Task routine\nsub is-square-free (Int $n) { my @v = $n.&prime-factors.Bag.values; @v.sum/@v <= 1 }\n\n# The Task\n# Parts 1 & 2\nfor 1, 145, 1e12.Int, 145+1e12.Int -> $start, $end {\n    say \"\\nSquare─free numbers between $start and $end:\\n\",\n    ($start .. $end).hyper(:4batch).grep( &is-square-free ).list.fmt(\"%3d\").comb(84).join(\"\\n\");\n}\n\n# Part 3\nfor 1e2, 1e3, 1e4, 1e5, 1e6 {\n    say \"\\nThe number of square─free numbers between 1 and {$_} (inclusive) is: \",\n    +(1 .. .Int).race.grep: &is-square-free;\n}\n\n```\n\nOutput:\n\n```\nSquare─free numbers between 1 and 145:\n  1   2   3   5   6   7  10  11  13  14  15  17  19  21  22  23  26  29  30  31  33 \n 34  35  37  38  39  41  42  43  46  47  51  53  55  57  58  59  61  62  65  66  67 \n 69  70  71  73  74  77  78  79  82  83  85  86  87  89  91  93  94  95  97 101 102 \n103 105 106 107 109 110 111 113 114 115 118 119 122 123 127 129 130 131 133 134 137 \n138 139 141 142 143 145\n\nSquare─free numbers between 1000000000000 and 1000000000145:\n1000000000001 1000000000002 1000000000003 1000000000005 1000000000006 1000000000007 \n1000000000009 1000000000011 1000000000013 1000000000014 1000000000015 1000000000018 \n1000000000019 1000000000021 1000000000022 1000000000023 1000000000027 1000000000029 \n1000000000030 1000000000031 1000000000033 1000000000037 1000000000038 1000000000039 \n1000000000041 1000000000042 1000000000043 1000000000045 1000000000046 1000000000047 \n1000000000049 1000000000051 1000000000054 1000000000055 1000000000057 1000000000058 \n1000000000059 1000000000061 1000000000063 1000000000065 1000000000066 1000000000067 \n1000000000069 1000000000070 1000000000073 1000000000074 1000000000077 1000000000078 \n1000000000079 1000000000081 1000000000082 1000000000085 1000000000086 1000000000087 \n1000000000090 1000000000091 1000000000093 1000000000094 1000000000095 1000000000097 \n1000000000099 1000000000101 1000000000102 1000000000103 1000000000105 1000000000106 \n1000000000109 1000000000111 1000000000113 1000000000114 1000000000115 1000000000117 \n1000000000118 1000000000119 1000000000121 1000000000122 1000000000123 1000000000126 \n1000000000127 1000000000129 1000000000130 1000000000133 1000000000135 1000000000137 \n1000000000138 1000000000139 1000000000141 1000000000142 1000000000145\n\nThe number of square─free numbers between 1 and 100 (inclusive) is: 61\n\nThe number of square─free numbers between 1 and 1000 (inclusive) is: 608\n\nThe number of square─free numbers between 1 and 10000 (inclusive) is: 6083\n\nThe number of square─free numbers between 1 and 100000 (inclusive) is: 60794\n\nThe number of square─free numbers between 1 and 1000000 (inclusive) is: 607926\n```"}]}
{"messages": [{"role": "user", "content": "Solve the Stable marriage problem using the Gale/Shapley algorithm.\n\n**Problem description**  \nGiven an equal number of men and women to be paired for marriage, each man ranks all the women in order of his preference and each woman ranks all the men in order of her preference.\n\nA stable set of engagements for marriage is one where no man prefers a woman over the one he is engaged to, where that other woman *also* prefers that man over the one she is engaged to. I.e. with consulting marriages, there would be no reason for the engagements between the people to change.\n\nGale and Shapley proved that there is a stable set of engagements for any set of preferences and the first link above gives their algorithm for finding a set of stable engagements.\n\n**Task Specifics**  \nGiven ten males:\n\n```\n   abe, bob, col, dan, ed, fred, gav, hal, ian, jon\n\n```\n\nAnd ten females:\n\n```\n   abi, bea, cath, dee, eve, fay, gay, hope, ivy, jan\n\n```\n\nAnd a complete list of ranked preferences, where the most liked is to the left:\n\n```\n  abe: abi, eve, cath, ivy, jan, dee, fay, bea, hope, gay\n  bob: cath, hope, abi, dee, eve, fay, bea, jan, ivy, gay\n  col: hope, eve, abi, dee, bea, fay, ivy, gay, cath, jan\n  dan: ivy, fay, dee, gay, hope, eve, jan, bea, cath, abi\n   ed: jan, dee, bea, cath, fay, eve, abi, ivy, hope, gay\n fred: bea, abi, dee, gay, eve, ivy, cath, jan, hope, fay\n  gav: gay, eve, ivy, bea, cath, abi, dee, hope, jan, fay\n  hal: abi, eve, hope, fay, ivy, cath, jan, bea, gay, dee\n  ian: hope, cath, dee, gay, bea, abi, fay, ivy, jan, eve\n  jon: abi, fay, jan, gay, eve, bea, dee, cath, ivy, hope\n   \n  abi: bob, fred, jon, gav, ian, abe, dan, ed, col, hal\n  bea: bob, abe, col, fred, gav, dan, ian, ed, jon, hal\n cath: fred, bob, ed, gav, hal, col, ian, abe, dan, jon\n  dee: fred, jon, col, abe, ian, hal, gav, dan, bob, ed\n  eve: jon, hal, fred, dan, abe, gav, col, ed, ian, bob\n  fay: bob, abe, ed, ian, jon, dan, fred, gav, col, hal\n  gay: jon, gav, hal, fred, bob, abe, col, ed, dan, ian\n hope: gav, jon, bob, abe, ian, dan, hal, ed, col, fred\n  ivy: ian, col, hal, gav, fred, bob, abe, ed, jon, dan\n  jan: ed, hal, gav, abe, bob, jon, col, ian, fred, dan\n\n```\n\n1. Use the Gale Shapley algorithm to find a stable set of engagements\n2. Perturb this set of engagements to form an unstable set of engagements then check this new set for stability.\n\n**References**\n\n1. The Stable Marriage Problem. (Eloquent description and background information).\n2. Gale-Shapley Algorithm Demonstration.\n3. Another Gale-Shapley Algorithm Demonstration.\n4. Stable Marriage Problem - Numberphile (Video).\n5. Stable Marriage Problem (the math bit) (Video).\n6. The Stable Marriage Problem and School Choice. (Excellent exposition)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.10\n\n**Translation of**: Perl\n\n```\nmy %he-likes =\n    abe  => < abi eve cath ivy jan dee fay bea hope gay >,\n    bob  => < cath hope abi dee eve fay bea jan ivy gay >,\n    col  => < hope eve abi dee bea fay ivy gay cath jan >,\n    dan  => < ivy fay dee gay hope eve jan bea cath abi >,\n    ed   => < jan dee bea cath fay eve abi ivy hope gay >,\n    fred => < bea abi dee gay eve ivy cath jan hope fay >,\n    gav  => < gay eve ivy bea cath abi dee hope jan fay >,\n    hal  => < abi eve hope fay ivy cath jan bea gay dee >,\n    ian  => < hope cath dee gay bea abi fay ivy jan eve >,\n    jon  => < abi fay jan gay eve bea dee cath ivy hope >,\n;\n \nmy %she-likes =\n    abi  => < bob fred jon gav ian abe dan ed col hal >,\n    bea  => < bob abe col fred gav dan ian ed jon hal >,\n    cath => < fred bob ed gav hal col ian abe dan jon >,\n    dee  => < fred jon col abe ian hal gav dan bob ed >,\n    eve  => < jon hal fred dan abe gav col ed ian bob >,\n    fay  => < bob abe ed ian jon dan fred gav col hal >,\n    gay  => < jon gav hal fred bob abe col ed dan ian >,\n    hope => < gav jon bob abe ian dan hal ed col fred >,\n    ivy  => < ian col hal gav fred bob abe ed jon dan >,\n    jan  => < ed hal gav abe bob jon col ian fred dan >,\n;\n\nmy %fiancé;\nmy %fiancée;\nmy %proposed;\n \nsub she-prefers ($her, $hottie) { .index($hottie) < .index(%fiancé{$her}) given ~%she-likes{$her} }\nsub he-prefers  ($him, $hottie) { .index($hottie) < .index(%fiancée{$him}) given ~%he-likes{$him} }\n \nmatch'em;\ncheck-stability;\n\nperturb'em;\ncheck-stability;\n \nsub match'em {                                          #'\n    say 'Matchmaking:';\n    while unmatched-guy() -> $guy {\n        my $gal = preferred-choice($guy);\n        %proposed{\"$guy $gal\"} = '❤';\n        if not %fiancé{$gal} {\n            engage($guy, $gal);\n            say \"\\t$gal and $guy\";\n        }\n        elsif she-prefers($gal, $guy) {\n\t    my $engaged-guy = %fiancé{$gal};\n\t    engage($guy, $gal);\n\t    %fiancée{$engaged-guy} = '';\n\t    say \"\\t$gal dumped $engaged-guy for $guy\";\n\t}\n    }\n}\n \nsub check-stability {\n    my @instabilities = gather for flat %he-likes.keys X %she-likes.keys -> $m, $w {\n\tif he-prefers($m, $w) and she-prefers($w, $m) {\n\t    take \"\\t$w prefers $m to %fiancé{$w} and $m prefers $w to %fiancée{$m}\";\n\t}\n    }\n\n    say 'Stablility:';\n    if @instabilities {\n\t.say for @instabilities;\n    }\n    else {\n        say \"\\t(all marriages stable)\";\n    }\n}\n \nsub unmatched-guy { %he-likes.keys.first: { not %fiancée{$_} } }\n \nsub preferred-choice($guy) { %he-likes{$guy}.first: { not %proposed{\"$guy $_\" } } }\n \nsub engage($guy, $gal) {\n    %fiancé{$gal} = $guy;\n    %fiancée{$guy} = $gal;\n}\n \nsub perturb'em {                                            #'\n    say 'Perturb:';\n    say \"\\tengage abi with fred and bea with jon\";\n    engage('fred', 'abi');\n    engage('jon', 'bea');\n}\n\n```\n\nOutput:\n\n```\nMatchmaking:\n        cath and bob\n        ivy and dan\n        abi and jon\n        hope and ian\n        jan and ed\n        eve and abe\n        eve dumped abe for hal\n        ivy dumped dan for abe\n        fay and dan\n        gay and gav\n        bea and fred\n        dee and col\nStablility:\n        (all marriages stable)\nPerturb:\n        engage abi with fred and bea with jon\nStablility:\n        fay prefers jon to dan and jon prefers fay to bea\n        eve prefers jon to hal and jon prefers eve to bea\n        gay prefers jon to gav and jon prefers gay to bea\n        bea prefers fred to jon and fred prefers bea to abi\n```"}]}
{"messages": [{"role": "user", "content": "A **stack** is a container of elements with   last in, first out   access policy.   Sometimes it also called **LIFO**.\n\nThe stack is accessed through its **top**.\n\nThe basic stack operations are:\n\n* *push*   stores a new element onto the stack top;\n* *pop*   returns the last pushed stack element, while removing it from the stack;\n* *empty*   tests if the stack contains no elements.\n\nSometimes the last pushed stack element is made accessible for immutable access (for read) or mutable access (for write):\n\n* *top*   (sometimes called *peek* to keep with the *p* theme) returns the topmost element without modifying the stack.\n\nStacks allow a very simple hardware implementation.\n\nThey are common in almost all processors.\n\nIn programming, stacks are also very popular for their way (**LIFO**) of resource management, usually memory.\n\nNested scopes of language objects are naturally implemented by a stack (sometimes by multiple stacks).\n\nThis is a classical way to implement local variables of a re-entrant or recursive subprogram. Stacks are also used to describe a formal computational framework.\n\nSee stack machine.\n\nMany algorithms in pattern matching, compiler construction (e.g. recursive descent parsers), and machine learning (e.g. based on tree traversal) have a natural representation in terms of stacks.\n\nTask\n\nCreate a stack supporting the basic operations: push, pop, empty.\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku still has the stack functions from Perl 5, but now they also can be accessed by object notation:\n\n```\nmy @stack;          # just a array\n@stack.push($elem); # add $elem to the end of @stack\n$elem = @stack.pop; # get the last element back\n@stack.elems == 0   # true, because the stack is empty\nnot @stack          # also true because @stack is false\n```"}]}
{"messages": [{"role": "user", "content": "Many programming languages allow for introspection of the current call stack environment. This can be for a variety of purposes such as enforcing security checks, debugging, or for getting access to the stack frame of callers.\n\nTask\n\nPrint out (in a manner considered suitable for the platform) the current call stack.\n\nThe amount of information printed for each frame on the call stack is not constrained, but should include at least the name of the function or method at that level of the stack frame.\n\nYou may explicitly add a call to produce the stack trace to the (example) code being instrumented for examination.\n\nThe task should allow the program to continue after generating the stack trace.\n\nThe task report here must include the trace from a sample program."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2013-03-03\n\n```\nsub g { say Backtrace.new.concise }\nsub f { g }\nsub MAIN { f }\n\n```\n\nOutput:\n\n```\n  in sub g at bt:1\n  in sub f at bt:2\n  in sub MAIN at bt:3\n```"}]}
{"messages": [{"role": "user", "content": "From Chung-Chieh Shan (LtU):\n\nYour stair-climbing robot has a very simple low-level API: the \"step\" function takes no argument and attempts to climb one step as a side effect. Unfortunately, sometimes the attempt fails and the robot clumsily falls one step instead. The \"step\" function detects what happens and returns a boolean flag: true on success, false on failure.\n\nWrite a function \"step\\_up\" that climbs one step up [from the initial position] (by repeating \"step\" attempts if necessary). Assume that the robot is not already at the top of the stairs, and neither does it ever reach the bottom of the stairs. How small can you make \"step\\_up\"? Can you avoid using variables (even immutable ones) and numbers?\n\nHere's a pseudo-code of a simple recursive solution without using variables:\n\n```\nfunc step_up()\n{\n    if not step() {\n        step_up();\n        step_up();\n    }\n}\n\n```\n\nInductive proof that step\\_up() steps up one step, if it terminates:\n\n* Base case (if the step() call returns true): it stepped up one step. QED\n* Inductive case (if the step() call returns false): Assume that recursive calls to step\\_up() step up one step. It stepped down one step (because step() returned false), but now we step up two steps using two step\\_up() calls. QED\n\nThe second (tail) recursion above can be turned into an iteration, as follows:\n\n```\nfunc step_up()\n{\n    while not step() {\n        step_up();\n    }\n}\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub step_up { step_up until step; }\n\n```"}]}
{"messages": [{"role": "user", "content": "Some languages (like Gambas and Visual Basic) support two startup modes.   Applications written in these languages start with an open window that waits for events, and it is necessary to do some trickery to cause a main procedure to run instead.   Data driven or event driven languages may also require similar trickery to force a startup procedure to run.\n\nTask\n\nDemonstrate the steps involved in causing the application to run a main procedure, rather than an event driven window at startup.\n\nLanguages that always run from main() can be omitted from this task."}, {"role": "assistant", "content": "(formerly Perl 6)\nWhen executed with the standard setting, Raku code always runs the mainline code automatically, followed by the MAIN function if you have one. However, it's possible to start up with an alternate setting that might want to create its own event loop or MAIN. In such cases you can\nalways capture control at various phases with blocks that we call \"phasers\":\n\n```\nBEGIN {...} # as soon as parsed\nCHECK {...} # end of compile time\nINIT {...}  # beginning of run time\nEND {...}   # end of run time\n\n```"}]}
{"messages": [{"role": "user", "content": "Build and show a web page displaying the data from the task separate the house number from the street name in a formatted and colored table.\n\nTask\n\nWrite the code which automatically opens a web page in a browser showing the addresses.\n*No static data must be shown, only processed data.*"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nUses the code from the Separate the house number from the street name task almost verbatim. Included here to make a complete, runnable example.\n\n```\nuse File::Temp;\n\nmy $addresses = qq :to /END/;\n    Plataanstraat 5\n    Straat 12\n    Straat 12 II\n    Dr. J. Straat   12\n    Dr. J. Straat 12 a\n    Dr. J. Straat 12-14\n    Laan 1940 – 1945 37\n    Plein 1940 2\n    1213-laan 11\n    16 april 1944 Pad 1\n    1e Kruisweg 36\n    Laan 1940-’45 66\n    Laan ’40-’45\n    Langeloërduinen 3 46\n    Marienwaerdt 2e Dreef 2\n    Provincialeweg N205 1\n    Rivium 2e Straat 59.\n    Nieuwe gracht 20rd\n    Nieuwe gracht 20rd 2\n    Nieuwe gracht 20zw /2\n    Nieuwe gracht 20zw/3\n    Nieuwe gracht 20 zw/4\n    Bahnhofstr. 4\n    Wertstr. 10\n    Lindenhof 1\n    Nordesch 20\n    Weilstr. 6\n    Harthauer Weg 2\n    Mainaustr. 49\n    August-Horch-Str. 3\n    Marktplatz 31\n    Schmidener Weg 3\n    Karl-Weysser-Str. 6\n    END\n\nmy @row-color = '#d7fffe', '#9dbcd4';\n\n# build the table\nsub genTable () {\n    my $table = '<table border=\"2\"> <tr bgcolor=\"#02ccfe\">' ~\n    qq|<th>Address</th><th>Street</th><th>House Number</th>\\n|;\n    my $i = 0;\n    for $addresses.lines -> $addr {\n        $table ~= qq|<tr bgcolor=\"{@row-color[$i++ % 2]}\"><td>{$addr}</td>|;\n        $addr ~~ m[\n            ( .*? )\n            [\n                \\s+\n                (\n                | \\d+ [ \\- | \\/ ] \\d+\n                | <!before 1940 | 1945> \\d+ <[ a..z I . / \\x20 ]>* \\d*\n                )\n            ]?\n            $\n        ];\n        quietly $table ~= qq|<td>{$0.Str}</td><td>{$1.Str||''}</td></tr>\\n|;\n    }\n    $table ~ '</table>';\n}\n\n# generate the page content\nsub content {\n    qq :to /END/;\n    <html>\n    <head>\n    <title>Rosetta Code - Start a Web Browser</title>\n    <meta charset=\"UTF-8\">\n    </head>\n    <body bgcolor=\"#d8dcd6\">\n    <p align=\"center\">\n    <font face=\"Arial, sans-serif\" size=\"5\">Split the house number from the street name</font>\n    </p>\n    <p align=\"center\">\n    { genTable }\n    </p>\n    </body>\n    </html>\n    END\n}\n\n# Use a temporary file name and file handle\nmy ($fn, $fh) = tempfile :suffix('.html');\n\n# dump the content to the file\n$fh.spurt: content;\n\n# use appropriate command for Windows or X11\n# other OSs/WMs may need different invocation\nmy $command = $*DISTRO.is-win ?? \"start $fn\" !! \"xdg-open $fn\";\n\n# start the browser\nshell $command;\n\n# wait for a bit to give browser time to load before destroying temp file\nsleep 5;\n\n```\n\nOutput:\n\nWill start the default browser (or open a new tab/window in a running one) and display this table.\n\n| Address | Street | House Number |\n| --- | --- | --- |\n| Plataanstraat 5 | Plataanstraat | 5 |\n| Straat 12 | Straat | 12 |\n| Straat 12 II | Straat | 12 II |\n| Dr. J. Straat 12 | Dr. J. Straat | 12 |\n| Dr. J. Straat 12 a | Dr. J. Straat | 12 a |\n| Dr. J. Straat 12-14 | Dr. J. Straat | 12-14 |\n| Laan 1940 – 1945 37 | Laan 1940 – 1945 | 37 |\n| Plein 1940 2 | Plein 1940 | 2 |\n| 1213-laan 11 | 1213-laan | 11 |\n| 16 april 1944 Pad 1 | 16 april 1944 Pad | 1 |\n| 1e Kruisweg 36 | 1e Kruisweg | 36 |\n| Laan 1940-’45 66 | Laan 1940-’45 | 66 |\n| Laan ’40-’45 | Laan ’40-’45 |  |\n| Langeloërduinen 3 46 | Langeloërduinen | 3 46 |\n| Marienwaerdt 2e Dreef 2 | Marienwaerdt 2e Dreef | 2 |\n| Provincialeweg N205 1 | Provincialeweg N205 | 1 |\n| Rivium 2e Straat 59. | Rivium 2e Straat | 59. |\n| Nieuwe gracht 20rd | Nieuwe gracht | 20rd |\n| Nieuwe gracht 20rd 2 | Nieuwe gracht | 20rd 2 |\n| Nieuwe gracht 20zw /2 | Nieuwe gracht | 20zw /2 |\n| Nieuwe gracht 20zw/3 | Nieuwe gracht | 20zw/3 |\n| Nieuwe gracht 20 zw/4 | Nieuwe gracht | 20 zw/4 |\n| Bahnhofstr. 4 | Bahnhofstr. | 4 |\n| Wertstr. 10 | Wertstr. | 10 |\n| Lindenhof 1 | Lindenhof | 1 |\n| Nordesch 20 | Nordesch | 20 |\n| Weilstr. 6 | Weilstr. | 6 |\n| Harthauer Weg 2 | Harthauer Weg | 2 |\n| Mainaustr. 49 | Mainaustr. | 49 |\n| August-Horch-Str. 3 | August-Horch-Str. | 3 |\n| Marktplatz 31 | Marktplatz | 31 |\n| Schmidener Weg 3 | Schmidener Weg | 3 |\n| Karl-Weysser-Str. 6 | Karl-Weysser-Str. | 6 |"}]}
{"messages": [{"role": "user", "content": "**Background**\n\nThis task is inspired by Mark Nelson's DDJ Column \"Wordplay\" and one of the weekly puzzle challenges from Will Shortz on NPR Weekend Edition [1] and originally attributed to David Edelheit.\n\nThe challenge was to take the names of two U.S. States, mix them all together, then rearrange the letters to form the names of two *different* U.S. States (so that all four state names differ from one another).\n\nWhat states are these?\n\nThe problem was reissued on the Unicon Discussion Web which includes several solutions with analysis. Several techniques may be helpful and you may wish to refer to Gödel numbering, equivalence relations, and equivalence classes. The basic merits of these were discussed in the Unicon Discussion Web.\n\nA second challenge in the form of a set of fictitious new states was also presented.\n\nTask\n\nWrite a program to solve the challenge using both the original list of states and the fictitious list.\n\nCaveats\n\n* case and spacing aren't significant - just letters (harmonize case)\n* don't expect the names to be in any order - such as being sorted\n* don't rely on names to be unique (eliminate duplicates - meaning if Iowa appears twice you can only use it once)\n\nComma separated list of state names used in the original puzzle:\n\n```\n    \"Alabama\",  \"Alaska\",  \"Arizona\",  \"Arkansas\",\n    \"California\",  \"Colorado\",  \"Connecticut\",  \"Delaware\",  \n    \"Florida\",  \"Georgia\",  \"Hawaii\",  \"Idaho\",  \"Illinois\",  \n    \"Indiana\",  \"Iowa\",  \"Kansas\",  \"Kentucky\",  \"Louisiana\",\n    \"Maine\",  \"Maryland\",  \"Massachusetts\",  \"Michigan\",\n    \"Minnesota\",  \"Mississippi\",  \"Missouri\",  \"Montana\",\n    \"Nebraska\",  \"Nevada\",  \"New Hampshire\",  \"New Jersey\",\n    \"New Mexico\",  \"New York\",  \"North Carolina\",  \"North Dakota\",\n    \"Ohio\",  \"Oklahoma\",  \"Oregon\",  \"Pennsylvania\",  \"Rhode Island\",\n    \"South Carolina\",  \"South Dakota\",  \"Tennessee\",  \"Texas\",\n    \"Utah\",  \"Vermont\",  \"Virginia\",\n    \"Washington\",  \"West Virginia\",  \"Wisconsin\",  \"Wyoming\"\n\n```\n\nComma separated list of additional fictitious state names to be added to the original (Includes a duplicate):\n\n```\n\"New Kory\",  \"Wen Kory\",  \"York New\",  \"Kory New\",  \"New Kory\"\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n```\nmy @states = <\n    Alabama Alaska Arizona Arkansas California Colorado Connecticut Delaware\n    Florida Georgia Hawaii Idaho Illinois Indiana Iowa Kansas Kentucky\n    Louisiana Maine Maryland Massachusetts Michigan Minnesota Mississippi\n    Missouri Montana Nebraska Nevada New_Hampshire New_Jersey New_Mexico\n    New_York North_Carolina North_Dakota Ohio Oklahoma Oregon Pennsylvania\n    Rhode_Island South_Carolina South_Dakota Tennessee Texas Utah Vermont\n    Virginia Washington West_Virginia Wisconsin Wyoming\n>;\n\nsay \"50 states:\";\n.say for anastates @states;\n \nsay \"\\n54 states:\";\n.say for sort anastates @states, < New_Kory Wen_Kory York_New Kory_New New_Kory >;\n\nsub anastates (*@states) {\n    my @s = @states.unique».subst('_', ' ');\n     \n    my @pairs = gather for ^@s -> $i {\n\tfor $i ^..^ @s -> $j {\n\t    take [ @s[$i], @s[$j] ];\n\t}\n    }\n     \n    my $equivs = hash @pairs.classify: *.lc.comb.sort.join;\n\n    gather for $equivs.values -> @c {\n\tfor ^@c -> $i {\n\t    for $i ^..^ @c -> $j {\n\t\tmy $set = set @c[$i].list, @c[$j].list;\n\t\ttake @c[$i].list.join(', ') ~ ' = ' ~ @c[$j].list.join(', ') if $set == 4;\n\t    }\n\t}\n    }\n}\n\n```\n\nOutput:\n\n```\n50 states:\nNorth Carolina, South Dakota = North Dakota, South Carolina\n\n54 states:\nNew Kory, Kory New = Wen Kory, York New\nNew Kory, Wen Kory = York New, Kory New\nNew Kory, York New = Wen Kory, Kory New\nNew York, Kory New = New Kory, Wen Kory\nNew York, Kory New = New Kory, York New\nNew York, Kory New = Wen Kory, York New\nNew York, New Kory = Wen Kory, Kory New\nNew York, New Kory = Wen Kory, York New\nNew York, New Kory = York New, Kory New\nNew York, Wen Kory = New Kory, Kory New\nNew York, Wen Kory = New Kory, York New\nNew York, Wen Kory = York New, Kory New\nNew York, York New = New Kory, Kory New\nNew York, York New = New Kory, Wen Kory\nNew York, York New = Wen Kory, Kory New\nNorth Carolina, South Dakota = North Dakota, South Carolina\n```"}]}
{"messages": [{"role": "user", "content": "Statistics is all about large groups of numbers.\nWhen talking about a set of sampled data, most frequently used is their mean value and standard deviation (stddev).\nIf you have set of data \n\nx\n\ni\n{\\displaystyle {\\displaystyle x\\_{i}}}\n where \n\ni\n=\n1\n,\n2\n,\n…\n,\nn\n\n{\\displaystyle {\\displaystyle i=1,2,\\ldots ,n\\,\\!}}\n, the mean is \n\nx\n¯\n≡\n\n\n1\nn\n\n∑\n\ni\n\nx\n\ni\n{\\displaystyle {\\displaystyle {\\bar {x}}\\equiv {1 \\over n}\\sum \\_{i}x\\_{i}}}\n, while the stddev is \n\nσ\n≡\n\n1\nn\n\n∑\n\ni\n\n\n(\n\n\nx\n\ni\n−\n\nx\n¯\n)\n\n2\n{\\displaystyle {\\displaystyle \\sigma \\equiv {\\sqrt {{1 \\over n}\\sum \\_{i}\\left(x\\_{i}-{\\bar {x}}\\right)^{2}}}}}\n.\n\nWhen examining a large quantity of data, one often uses a histogram, which shows the counts of data samples falling into a prechosen set of intervals (or bins).\nWhen plotted, often as bar graphs, it visually indicates how often each data value occurs.\n\n**Task** Using your language's random number routine, generate real numbers in the range of [0, 1]. It doesn't matter if you chose to use open or closed range.\nCreate 100 of such numbers (i.e. sample size 100) and calculate their mean and stddev.\nDo so for sample size of 1,000 and 10,000, maybe even higher if you feel like.\nShow a histogram of any of these sets.\nDo you notice some patterns about the standard deviation?\n\n**Extra** Sometimes so much data need to be processed that it's impossible to keep all of them at once. Can you calculate the mean, stddev and histogram of a trillion numbers? (You don't really need to do a trillion numbers, just show how it can be done.)\n\nHint\n\nFor a finite population with equal probabilities at all points, one can derive:\n\n:   (\n    x\n    −\n\n\n    x\n    ¯\n\n    )\n\n    2\n    ¯\n    =\n\n    x\n\n    2\n    ¯\n    −\n\n    x\n    ¯\n\n    2\n    {\\displaystyle {\\displaystyle {\\overline {(x-{\\overline {x}})^{2}}}={\\overline {x^{2}}}-{\\overline {x}}^{2}}}\n\nOr, more verbosely:\n\n:   1\n    N\n\n    ∑\n\n    i\n    =\n    1\n\n    N\n    (\n\n    x\n\n    i\n    −\n\n\n    x\n    ¯\n\n    )\n\n    2\n    =\n\n\n    1\n    N\n\n    (\n\n\n    ∑\n\n    i\n    =\n    1\n\n    N\n\n    x\n\n    i\n\n    2\n    )\n    −\n\n    x\n    ¯\n\n    2\n    .\n    {\\displaystyle {\\displaystyle {\\frac {1}{N}}\\sum \\_{i=1}^{N}(x\\_{i}-{\\overline {x}})^{2}={\\frac {1}{N}}\\left(\\sum \\_{i=1}^{N}x\\_{i}^{2}\\right)-{\\overline {x}}^{2}.}}\n\nSee also\n\n* Statistics/Normal distribution\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| | Tasks for calculating statistical measures | | | --- | --- | |  | | |  |  |  |  |  | | --- | --- | --- | --- | --- | |  | | in one go | moving *(sliding window)* | moving *(cumulative)* | | Mean | Arithmetic | Statistics/Basic  Averages/Arithmetic mean  Averages/Pythagorean means | Averages/Simple moving average |  | | Geometric | Averages/Pythagorean means |  |  | | Harmonic | Averages/Pythagorean means |  |  | | Quadratic | Averages/Root mean square |  |  | | Circular | Averages/Mean angle  Averages/Mean time of day |  |  | | Median | | Averages/Median |  |  | | Mode | | Averages/Mode |  |  | | Standard deviation | | Statistics/Basic |  | Cumulative standard deviation | | | |\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n```\nfor 100, 1_000, 10_000 -> $N {\n    say \"size: $N\";\n    my @data = rand xx $N;\n    printf \"mean: %f\\n\", my $mean = $N R/ [+] @data;\n    printf \"stddev: %f\\n\", sqrt\n    $mean**2 R- $N R/ [+] @data »**» 2;\n    printf \"%.1f %s\\n\", .key, '=' x (500 * .value.elems / $N)\n        for sort @data.classify: (10 * *).Int / 10;\n    say '';\n}\n\n```\n\nOutput:\n\n```\nsize: 100\nmean: 0.52518699464629726\nstddev: 0.28484207464779548\n0.0\t==============================\n0.1\t======================================================================\n0.2\t===================================\n0.3\t==================================================\n0.4\t============================================================\n0.5\t=============================================\n0.6\t====================\n0.7\t===========================================================================\n0.8\t======================================================================\n0.9\t=============================================\n\nsize: 1000\nmean: 0.51043974182914975\nstddev: 0.29146336553431618\n0.0\t==============================================\n0.1\t==================================================\n0.2\t===========================================\n0.3\t========================================================\n0.4\t===================================================\n0.5\t=======================================\n0.6\t===========================================================\n0.7\t====================================================\n0.8\t==============================================\n0.9\t========================================================\n\nsize: 10000\nmean: 0.50371817503544458\nstddev: 0.2900716333092252\n0.0\t===================================================\n0.1\t=================================================\n0.2\t=============================================\n0.3\t====================================================\n0.4\t==============================================\n0.5\t====================================================\n0.6\t================================================\n0.7\t===================================================\n0.8\t====================================================\n0.9\t==================================================\n```"}]}
{"messages": [{"role": "user", "content": "The probability density function (pdf) of the chi-squared (or χ2) distribution as used in statistics is\n\n:   f\n    (\n    x\n    ;\n\n    k\n    )\n    =\n\n    x\n\n    k\n    2\n    −\n    1\n\n    e\n\n    −\n\n\n    x\n    2\n\n\n    2\n\n\n    k\n    2\n    Γ\n\n    (\n\n\n    k\n    2\n    )\n    {\\displaystyle {\\displaystyle f(x;\\,k)={\\dfrac {x^{{\\frac {k}{2}}-1}e^{-{\\frac {x}{2}}}}{2^{\\frac {k}{2}}\\Gamma \\left({\\frac {k}{2}}\\right)}}}}\n    , where \n\n    x\n    >\n    0\n    {\\textstyle x>0}\n\nHere, \n\nΓ\n(\nk\n\n/\n2\n)\n{\\textstyle \\Gamma (k/2)}\n denotes the Gamma\\_function.\n\nThe use of the gamma function in the equation below reflects the chi-squared distribution's origin as a special case of the gamma\ndistribution.\n\nIn probability theory and statistics, the gamma distribution is a two-parameter family of continuous probability distributions.\nThe exponential distribution, Erlang distribution, and chi-square distribution are special cases of the gamma distribution.\n\nThe probability density function (pdf) of the gamma distribution is given by the formula\n\n:   f\n    (\n    x\n    ;\n    k\n    ,\n    θ\n    )\n    =\n\n    x\n\n    k\n    −\n    1\n\n    e\n\n    −\n    x\n\n    /\n    θ\n\n\n    θ\n\n    k\n    Γ\n    (\n    k\n    )\n\n\n     for \n    x\n    >\n    0\n\n     and \n    k\n    ,\n    θ\n    >\n    0.\n    {\\displaystyle {\\displaystyle f(x;k,\\theta )={\\frac {x^{k-1}e^{-x/\\theta }}{\\theta ^{k}\\Gamma (k)}}\\quad {\\text{ for }}x>0{\\text{ and }}k,\\theta >0.}}\n\nwhere Γ(*k*) is the Gamma\\_function, with shape parameter k and a scale parameter θ.\n\nThe cumulative probability distribution of the gamma distribution is the area under the curve of the distribution, which indicates\nthe increasing probability of the x value of a single random point within the gamma distribution being less than or equal to the x value\nof the cumulative probability distribution. The gamma cumulative probability distribution function can be calculated as\n\n:   F\n    (\n    x\n    ;\n    k\n    ,\n    θ\n    )\n    =\n\n    ∫\n\n    0\n\n    x\n    f\n    (\n    u\n    ;\n    k\n    ,\n    θ\n    )\n\n    d\n    u\n    =\n\n    γ\n\n    (\n\n    k\n    ,\n\n\n    x\n    θ\n    )\n\n    Γ\n    (\n    k\n    )\n    ,\n    {\\displaystyle {\\displaystyle F(x;k,\\theta )=\\int \\_{0}^{x}f(u;k,\\theta )\\,du={\\frac {\\gamma \\left(k,{\\frac {x}{\\theta }}\\right)}{\\Gamma (k)}},}}\n\nwhere \n\nγ\n\n(\n\nk\n,\n\n\nx\nθ\n)\n{\\displaystyle {\\displaystyle \\gamma \\left(k,{\\frac {x}{\\theta }}\\right)}}\n is the lower incomplete gamma function.\n\nThe lower incomplete gamma function can be calculated as\n\nx\n\ns\n\n\ne\n\n−\nx\n\n∑\n\nm\n=\n0\n\n∞\n\nx\n\nm\n\nΓ\n(\ns\n+\nm\n+\n1\n)\n{\\displaystyle x^{s}\\,e^{-x}\\sum \\_{m=0}^{\\infty }{\\frac {x^{m}}{\\Gamma (s+m+1)}}}\n\nand so, for the chi-squared cumulative probability distribution and substituting chi-square k into s as k/2 and chi-squared x into x as x / 2,\n\n:   F\n    (\n    x\n    ;\n\n    k\n    )\n    =\n    (\n    x\n\n    /\n    2\n\n    )\n\n    (\n    k\n\n    /\n    2\n    )\n\n\n    e\n\n    −\n    x\n\n    /\n    2\n\n    ∑\n\n    m\n    =\n    0\n\n    ∞\n\n    (\n    x\n\n    /\n    2\n\n    )\n\n    m\n\n    Γ\n    (\n\n\n    k\n    2\n    +\n    m\n    +\n    1\n    )\n    .\n    {\\displaystyle F(x;\\,k)=(x/2)^{(k/2)}\\,e^{-x/2}\\sum \\_{m=0}^{\\infty }{\\frac {(x/2)^{m}}{\\Gamma ({\\frac {k}{2}}+m+1)}}.}\n\nBecause series formulas may be subject to accumulated errors from rounding in the frequently used region where x and k are under 10 and near one another, you may instead use a mathematics function library, if available for your programming task, to calculate gamma and incomplete gamma.\n\nTask\n\n* Calculate and show the values of the χ2(x; k) for k = 1 through 5 inclusive and x integer from 0 and through 10 inclusive.\n\n* Create a function to calculate the cumulative probability function for the χ2 distribution. This will need to be reasonably accurate (at least 6 digit accuracy) for k = 3.\n\n* Calculate and show the p values of statistical samples which result in a χ2(k = 3) value of 1, 2, 4, 8, 16, and 32. (Statistical *p values* can be calculated for the purpose of this task as approximately 1 - P(x), with P(x) the cumulative probability function at x for χ2.)\n\n:   :   The following is a chart for 4 airports:\n\nFlight Delays\n\n| Airport | On Time | Delayed | Totals |\n| --- | --- | --- | --- |\n| Dallas/Fort Worth | 77 | 23 | 100 |\n| Honolulu | 88 | 12 | 100 |\n| LaGuardia | 79 | 21 | 100 |\n| Orlando | 81 | 19 | 100 |\n| All Totals | 325 | 75 | 400 |\n| Expected per 100 | 81.25 | 18.75 | 100 |\n\n:   :   χ2 on a 2D table is calculated as the sum of the squares of the differences from expected divided by the expected numbers for each entry on the table. The k for the chi-squared distribution is to be calculated as df, the degrees of freedom for the table, which is a 2D parameter, (count of airports - 1) \\* (count of measures per airport - 1), which here is (4 - 1 )(2 - 1) = 3.\n\n* Calculate the Chi-squared statistic for the above table and find its p value using your function for the cumulative probability for χ2 with k = 3 from the previous task.\n\nStretch task\n\n* Show how you could make a plot of the curves for the probability distribution function χ2(x; k) for k = 0, 1, 2, and 3.\n\nRelated Tasks\n\n* Statistics/Basic\n* Statistics/Normal\\_distribution\n\nSee also\n\n[Chi Squared Test]\n[NIST page on the Chi-Square Distribution]"}, {"role": "assistant", "content": "**Translation of**: Julia\n\n```\n# 20221101 Raku programming solution\n\nuse Graphics::PLplot;\n\nsub Γ(\\z) { # https://rosettacode.org/wiki/Gamma_function#Raku\n    constant g = 9;\n    z < .5 ?? π/ sin(π * z) / Γ(1 - z) \n           !! sqrt(2*π) * (z + g - 1/2)**(z - 1/2) * exp(-(z + g - 1/2)) *\n              [+] < 1.000000000000000174663        5716.400188274341379136\n                    -14815.30426768413909044       14291.49277657478554025\n                    -6348.160217641458813289       1301.608286058321874105\n                    -108.1767053514369634679       2.605696505611755827729\n                    -0.7423452510201416151527e-2   0.5384136432509564062961e-7\n                    -0.4023533141268236372067e-8 > Z* 1, |map 1/(z + *), 0..*\n}\n\nsub χ2(\\x,\\k) {x>0 && k>0 ?? (x**(k/2 - 1)*exp(-x/2)/(2**(k/2)*Γ(k / 2))) !! 0}\n \nsub Γ_cdf(\\k,\\x) { x**k * exp(-x) * sum( ^101 .map: { x** $_ / Γ(k+$_+1) } ) }\n\nsub cdf_χ2(\\x,\\k) { (x <= 0 or k <= 0) ?? 0.0 !!  Γ_cdf(k / 2, x / 2) }\n\nsay ' 𝒙          χ² ', [~] (1..5)».&{ \"𝒌 = $_\" ~ ' ' x 13 };\nsay '-' x my \\width = 93;\nfor 0..10 -> \\x {\n   say x.fmt('%2d'), [~] (1…5)».&{χ2(x, $_).fmt: \"  %-.{((width-2) div 5)-4}f\"}\n}\n\nsay \"\\nχ² 𝒙     cdf for χ²   P value (df=3)\\n\", '-' x 36;\nfor 2 «**« ^6 -> \\p {\n   my $cdf = cdf_χ2(p, 3).fmt: '%-.10f';\n   say p.fmt('%2d'), \"     $cdf   \", (1-$cdf).fmt: '%-.10f'\n}\n\nmy \\airport   = [ <77 23>, <88 12>, <79 21>, <81 19> ];\nmy \\expected  = [ <81.25 18.75> xx 4 ];\nmy \\dtotal    = ( (airport »-« expected)»² »/» expected )».List.flat.sum;\n\nsay \"\\nFor the airport data, diff total is \",dtotal,\", χ² is \", χ2(dtotal, 3), \", p value \", cdf_χ2(dtotal, 3);\n\ngiven Graphics::PLplot.new( device => 'png', file-name => 'output.png' ) {\n   .begin;\n   .pen-width: 3 ;\n   .environment: x-range => [-1.0, 10.0], y-range => [-0.1, 0.5], just => 0 ;\n   .label: x-axis => '', y-axis => '', title => 'Chi-squared distribution' ;\n   for 0..3 -> \\𝒌 {  \n      .color-index0: 1+2*𝒌;\n      .line: (0, .1 … 10).map: -> \\𝒙 { ( 𝒙, χ2( 𝒙, 𝒌 ) )».Num };\n      .text-viewport: side=>'t', disp=>-𝒌-2, pos=>.5, just=>.5, text=>'k = '~𝒌 \n   } # plplot.sourceforge.net/docbook-manual/plplot-html-5.15.0/plmtex.html\n   .end \n}\n\n```\n\nOutput:\n\n```\n 𝒙          χ² 𝒌 = 1             𝒌 = 2             𝒌 = 3             𝒌 = 4             𝒌 = 5             \n---------------------------------------------------------------------------------------------\n 0  0.00000000000000  0.00000000000000  0.00000000000000  0.00000000000000  0.00000000000000\n 1  0.24197072451914  0.30326532985632  0.24197072451914  0.15163266492816  0.08065690817305\n 2  0.10377687435515  0.18393972058572  0.20755374871030  0.18393972058572  0.13836916580686\n 3  0.05139344326792  0.11156508007421  0.15418032980377  0.16734762011132  0.15418032980377\n 4  0.02699548325659  0.06766764161831  0.10798193302638  0.13533528323661  0.14397591070183\n 5  0.01464498256193  0.04104249931195  0.07322491280963  0.10260624827987  0.12204152134939\n 6  0.00810869555494  0.02489353418393  0.04865217332964  0.07468060255180  0.09730434665928\n 7  0.00455334292164  0.01509869171116  0.03187340045148  0.05284542098906  0.07437126772012\n 8  0.00258337316926  0.00915781944437  0.02066698535409  0.03663127777747  0.05511196094425\n 9  0.00147728280398  0.00555449826912  0.01329554523581  0.02499524221105  0.03988663570744\n10  0.00085003666025  0.00336897349954  0.00850036660252  0.01684486749771  0.02833455534173\n\nχ² 𝒙     cdf for χ²   P value (df=3)\n------------------------------------\n 1     0.1987480431   0.8012519569\n 2     0.4275932955   0.5724067045\n 4     0.7385358701   0.2614641299\n 8     0.9539882943   0.0460117057\n16     0.9988660157   0.0011339843\n32     0.9999994767   0.0000005233\n\nFor the airport data, diff total is 4.512821, χ² is 0.08875392598443506, p value 0.7888504263193072\n```"}]}
{"messages": [{"role": "user", "content": "The Normal (or Gaussian) distribution is a frequently used distribution in statistics. While most programming languages provide a uniformly distributed random number generator, one can derive normally distributed random numbers from a uniform generator.\n\nThe task\n\n1. Take a uniform random number generator and create a large (you decide how large) set of numbers that follow a normal (Gaussian) distribution. Calculate the dataset's mean and standard deviation, and show a histogram of the data.\n2. Mention any native language support for the generation of normally distributed random numbers.\n\nReference\n\n* You may refer to code in Statistics/Basic if available."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nsub normdist ($m, $σ) {\n    my $r = sqrt -2 * log rand;\n    my $Θ = τ * rand;\n    $r * cos($Θ) * $σ + $m;\n}\n\nsub MAIN ($size = 100000, $mean = 50, $stddev = 4) {\n    my @dataset = normdist($mean,$stddev) xx $size;\n\n    my $m = [+](@dataset) / $size;\n    say (:$m);\n\n    my $σ = sqrt [+](@dataset X** 2) / $size - $m**2;\n    say (:$σ);\n\n    (my %hash){.round}++ for @dataset;\n    my $scale = 180 * $stddev / $size;\n    constant @subbar = < ⎸ ▏ ▎ ▍ ▌ ▋ ▊ ▉ █ >;\n    for %hash.keys».Int.minmax(+*) -> $i {\n        my $x = (%hash{$i} // 0) * $scale;\n        my $full = floor $x;\n        my $part = 8 * ($x - $full);\n        say $i, \"\\t\", '█' x $full, @subbar[$part];\n    }\n}\n\n```\n\nOutput:\n\n```\n\"m\" => 50.006107405837142e0\n\"σ\" => 4.0814435639885254e0\n33\t⎸\n34\t⎸\n35\t⎸\n36\t▏\n37\t▎\n38\t▊\n39\t█▋\n40\t███⎸\n41\t█████▊\n42\t██████████⎸\n43\t███████████████▋\n44\t███████████████████████▏\n45\t████████████████████████████████▌\n46\t███████████████████████████████████████████▍\n47\t██████████████████████████████████████████████████████▏\n48\t███████████████████████████████████████████████████████████████▏\n49\t█████████████████████████████████████████████████████████████████████▋\n50\t███████████████████████████████████████████████████████████████████████▊\n51\t█████████████████████████████████████████████████████████████████████▌\n52\t███████████████████████████████████████████████████████████████⎸\n53\t██████████████████████████████████████████████████████▎\n54\t███████████████████████████████████████████⎸\n55\t████████████████████████████████▌\n56\t███████████████████████▍\n57\t███████████████▉\n58\t█████████▉\n59\t█████▍\n60\t███▍\n61\t█▋\n62\t▊\n63\t▍\n64\t▏\n65\t⎸\n66\t⎸\n67\t⎸\n```"}]}
{"messages": [{"role": "user", "content": "Euler Project #284\n\n\nTask\n\nThe 3-digit number 376 in the decimal numbering system is an example of numbers with the special property that its square ends with the same digits: **376\\*376 = 141376**. Let's call a number with this property a steady square. Find steady squares under **10.000**"}, {"role": "assistant", "content": "```\n.say for ({$++²}…*).kv.grep( {$^v.ends-with: $^k} )[1..10]\n\n```\n\nOutput:\n\n```\n(1 1)\n(5 25)\n(6 36)\n(25 625)\n(76 5776)\n(376 141376)\n(625 390625)\n(9376 87909376)\n(90625 8212890625)\n(109376 11963109376)\n```"}]}
{"messages": [{"role": "user", "content": "Steffensen's method is a numerical method to find the roots of functions. It is similar to Newton's method, but, unlike Newton's, does not require derivatives. Like Newton's, however, it is prone towards not finding a solution at all.\n\nIn this task we will do a root-finding problem that illustrates both the advantage—that no derivatives are required—and the disadvantage—that the method often gives no answer. We will try to find intersection points of two Bézier curves.\n\n### Steffensen's method\n\nWe will be using the variant of Steffensen's method that employs Aitken's extrapolation. Aitken's extrapolation is illustrated by the following ATS function:\n\n```\nfun aitken\n     (f  : double -> double,   (* function double to double *)\n      p0 : double)             (* initial fixed point estimate *)\n   : double =\n let\n   val p1 = f(p0)\n   val p2 = f(p1)\n   val p1m0 = p1 - p0\n in\n   p0 - (p1m0 * p1m0) / (p2 - (2.0 * p1) + p0)\n end\n\n```\n\nThe return value is a function of \n\np\n0\n{\\displaystyle {\\displaystyle p0}}\n, \n\np\n1\n=\nf\n(\np\n0\n)\n{\\displaystyle {\\displaystyle p1=f(p0)}}\n, and \n\np\n2\n=\nf\n(\nf\n(\np\n0\n)\n)\n{\\displaystyle {\\displaystyle p2=f(f(p0))}}\n. What one is trying to find is a so-called fixed point of \n\nf\n{\\displaystyle {\\displaystyle f}}\n: a value of \n\np\n{\\displaystyle {\\displaystyle p}}\n such that \n\nf\n(\np\n)\n=\np\n{\\displaystyle {\\displaystyle f(p)=p}}\n. Our implementation of Steffensen's method will be to repeat Aitken's extrapolation until either a tolerance is satisfied or too many iterations have been executed:\n\n```\nfun steffensen_aitken     (* finds fixed point p such that f(p) = p *)\n     (f       : double -> double, (* function double to double *)\n      pinit   : double,           (* initial estimate *)\n      tol     : double,           (* tolerance *)\n      maxiter : int)              (* maximum number of iterations *)\n   : Option (double) =     (* return a double, IF tolerance is met *)\n let\n   var p0   : double = pinit\n   var p    : double = aitken (f, p0)\n   var iter : int = 1          (* iteration counter *)\n in\n   while (abs (p - p0) > tol andalso iter < maxiter)\n     begin\n       p0 := p;\n       p := aitken (f, p0);\n       iter := iter + 1\n     end;\n   if abs (p - p0) > tol then None () else Some (p)\n end\n\n```\n\nThe function `steffensen_aitken` will find a fixed point for us, but how can we use that to find a root? In particular, suppose one wants to find \n\nt\n{\\displaystyle {\\displaystyle t}}\n such that \n\ng\n(\nt\n)\n=\n0\n{\\displaystyle {\\displaystyle g(t)=0}}\n. Then what one can do (and what we will try to do) is find a fixed point \n\np\n{\\displaystyle {\\displaystyle p}}\n of \n\nf\n(\nt\n)\n=\ng\n(\nt\n)\n+\nt\n{\\displaystyle {\\displaystyle f(t)=g(t)+t}}\n. In that case, \n\np\n=\nf\n(\np\n)\n=\ng\n(\np\n)\n+\np\n{\\displaystyle {\\displaystyle p=f(p)=g(p)+p}}\n, and therefore \n\ng\n(\np\n)\n=\n0\n{\\displaystyle {\\displaystyle g(p)=0}}\n.\n\n### The problem we wish to solve\n\nSuppose we have two quadratic planar Bézier curves, with control points \n\n(\n−\n1\n,\n0\n)\n,\n(\n0\n,\n10\n)\n,\n(\n1\n,\n0\n)\n{\\displaystyle {\\displaystyle (-1,0),(0,10),(1,0)}}\n and \n\n(\n2\n,\n1\n)\n,\n(\n−\n8\n,\n2\n)\n,\n(\n2\n,\n3\n)\n{\\displaystyle {\\displaystyle (2,1),(-8,2),(2,3)}}\n, respectively. These two parabolas are shown in the following figure. As you can see, they intersect at four points.\n\nWe want to try to find the points of intersection.\n\nThe method we will use is *implicitization*. In this method, one first rewrites one of the curves as an implicit equation in \n\nx\n{\\displaystyle {\\displaystyle x}}\n and \n\ny\n{\\displaystyle {\\displaystyle y}}\n. For this we will use the parabola that is convex upwards: it has implicit equation \n\n5\n\nx\n\n2\n+\ny\n−\n5\n=\n0\n{\\displaystyle {\\displaystyle 5x^{2}+y-5=0}}\n. Then what one does is plug the parametric equations of the *other* curve into the implicit equation. The resulting equation is \n\n5\n(\nx\n(\nt\n)\n\n)\n\n2\n+\ny\n(\nt\n)\n−\n5\n=\n0\n{\\displaystyle {\\displaystyle 5(x(t))^{2}+y(t)-5=0}}\n, where \n\nt\n{\\displaystyle {\\displaystyle t}}\n is the independent parameter for the curve that is convex *leftwards*. After expansion, this will be a degree-4 equation in \n\nt\n{\\displaystyle {\\displaystyle t}}\n. Find its four roots and you have found the points of intersection of the two curves.\n\nThat is easier said than done.\n\nThere are excellent ways to solve this problem, but we will not be using those. Our purpose, after all, is to illustrate Steffensen's method: both its advantages and its drawbacks. Let us look at an advantage: to use Steffensen's method (which requires only function values, not derivatives), we do not actually have to expand that polynomial in \n\nt\n{\\displaystyle {\\displaystyle t}}\n. Instead, we can evaluate \n\nx\n(\nt\n)\n{\\displaystyle {\\displaystyle x(t)}}\n and \n\ny\n(\nt\n)\n{\\displaystyle {\\displaystyle y(t)}}\n and plug the resulting numbers into the implicit equation. What is more, we do not even need to write \n\nx\n(\nt\n)\n{\\displaystyle {\\displaystyle x(t)}}\n and \n\ny\n(\nt\n)\n{\\displaystyle {\\displaystyle y(t)}}\n as polynomials, but instead can evaluate them directly from their control points, using de Casteljau's algorithm:\n\n```\nfun de_casteljau\n     (c0 : double,         (* control point coordinates (one axis) *)\n      c1 : double,\n      c2 : double,\n      t  : double)             (* the independent parameter *)\n   : double =                  (* value of x(t) or y(t) *)\n let\n   val s = 1.0 - t\n   val c01 = (s * c0) + (t * c1)\n   val c12 = (s * c1) + (t * c2)\n   val c012 = (s * c01) + (t * c12)\n in\n   c012\n end\n\nfun x_convex_left_parabola (t : double) : double =\n de_casteljau (2.0, ~8.0, 2.0, t)\n\nfun y_convex_left_parabola (t : double) : double =\n de_casteljau (1.0, 2.0, 3.0, t)\n\n```\n\nPlugging \n\nx\n(\nt\n)\n{\\displaystyle {\\displaystyle x(t)}}\n and \n\ny\n(\nt\n)\n{\\displaystyle {\\displaystyle y(t)}}\n into the implicit equation, and writing \n\nf\n(\nt\n)\n{\\displaystyle {\\displaystyle f(t)}}\n as the function whose fixed points are to be found:\n\n```\nfun implicit_equation (x : double, y : double) : double =\n (5.0 * x * x) + y - 5.0\n\nfun f (t : double) : double = (* find fixed points of this function *)\n let\n   val x = x_convex_left_parabola (t)\n   val y = y_convex_left_parabola (t)\n in\n   implicit_equation (x, y) + t\n end\n\n```\n\nWhat is left to be done is simple, but tricky: use the `steffensen_aitken` function to find those fixed points. This is where a huge disadvantage of Steffensen's method (shared with Newton's method) will be illustrated. What is likely to happen is that only some of the intersection points will be found. Furthermore, for most of our initial estimates, Steffensen's method will not give us an answer at all.\n\n### The task\n\nUse the methods described above to try to find intersection points of the two parabolas. For initial estimates, use \n\np\ni\nn\ni\nt\n=\n\nt\n\n0\n=\n0.0\n,\n0.1\n,\n0.2\n,\n⋯\n,\n0.9\n,\n1.0\n{\\displaystyle {\\displaystyle {\\it {pinit}}=t\\_{0}=0.0,0.1,0.2,\\cdots ,0.9,1.0}}\n. Choose reasonable settings for tolerance and maximum iterations. (The ATS example has 0.00000001 and 1000, respectively.) For each initial estimate, if tolerance was not met before maximum iterations was reached, print that there was no answer. On the other hand, if there was an answer, plug the resulting value of \n\nt\n{\\displaystyle {\\displaystyle t}}\n into \n\nx\n(\nt\n)\n{\\displaystyle {\\displaystyle x(t)}}\n and \n\ny\n(\nt\n)\n{\\displaystyle {\\displaystyle y(t)}}\n to find the intersection point \n\n(\nx\n,\ny\n)\n{\\displaystyle {\\displaystyle (x,y)}}\n. Check that that this answer is correct, by plugging \n\n(\nx\n,\ny\n)\n{\\displaystyle {\\displaystyle (x,y)}}\n into the implicit equation. If it is not correct, print that Steffensen's method gave a spurious answer. Otherwise print the value of \n\n(\nx\n,\ny\n)\n{\\displaystyle {\\displaystyle (x,y)}}\n.\n\n(*The ATS example has purposely been written in a fashion to be readable as if it were pseudocode. You may use it as a reference implementation.*)\n\n### See also\n\n* Bézier curves/Intersections"}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20230928 Raku programming solution\n\nsub aitken($f, $p0) {\n   my $p2   = $f( my $p1 = $f($p0) ); \n   my $p1m0 = $p1 - $p0;\n   return $p0 - $p1m0*$p1m0/($p2-2.0*$p1+$p0);\n}\n\nsub steffensenAitken($f, $pinit, $tol, $maxiter) {\n   my ($iter, $p) = 1, aitken($f, my $p0 = $pinit);\n   while abs($p-$p0) > $tol and $iter < $maxiter {\n      $p = aitken($f, $p0 = $p);\n      $iter++\n   }\n   return abs($p-$p0) > $tol ?? NaN !! $p\n}\n\nsub deCasteljau($c0, $c1, $c2, $t) {\n   my $s = 1.0 - $t;\n   return $s*($s*$c0 + $t*$c1) + $t*($s*$c1 + $t*$c2)\n}\n\nsub xConvexLeftParabola($t) { return deCasteljau(2.0, -8.0, 2.0, $t) }\n\nsub yConvexRightParabola($t) { return deCasteljau(1.0, 2.0, 3.0, $t) }\n\nsub implicitEquation($x, $y) { return 5.0*$x*$x + $y - 5.0 }\n\nsub f($t) {\n   implicitEquation(xConvexLeftParabola($t), yConvexRightParabola($t)) + $t\n}\n\nmy $t0 = 0.0;\nfor ^11 {\n   print \"t0 = {$t0.fmt: '%0.1f'} : \";\n   my $t = steffensenAitken(&f, $t0, 0.00000001, 1000);\n   if $t.isNaN {\n      say \"no answer\";\n   } else {\n      my ($x, $y) = xConvexLeftParabola($t), yConvexRightParabola($t);\n      if abs(implicitEquation($x, $y)) <= 0.000001 {\n         printf \"intersection at (%f, %f)\\n\", $x, $y;\n      } else {\n         say \"spurious solution\";\n      }\n   }\n   $t0 += 0.1;\n}\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Create a well-formatted stem-and-leaf plot from the following data set, where the leaves are the last digits:\n\n> 12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146\n\nThe primary intent of this task is the presentation of information. It is acceptable to hardcode the data set or characteristics of it (such as what the stems are) in the example, insofar as it is impractical to make the example generic to any data set. For example, in a computation-less language like HTML the data set may be entirely prearranged within the example; the interesting characteristics are how the proper visual formatting is arranged.\n\nIf possible, the output should not be a bitmap image. Monospaced plain text is acceptable, but do better if you can. It may be a window, i.e. not a file.\n\n**Note:** If you wish to try multiple data sets, you might try this generator."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\nHandles negative stems properly.\n\n```\nmy @data = <\n     12 127  28  42  39 113  42  18  44 118  44\n     37 113 124  37  48 127  36  29  31 125 139\n    131 115 105 132 104 123  35 113 122  42 117\n    119  58 109  23 105  63  27  44 105  99  41\n    128 121 116 125  32  61  37 127  29 113 121\n     58 114 126  53 114  96  25 109   7  31 141\n     46  13  27  43 117 116  27   7  68  40  31\n    115 124  42 128  52  71 118 117  38  27 106\n     33 117 116 111  40 119  47 105  57 122 109\n    124 115  43 120  43  27  27  18  28  48 125\n    107 114  34 133  45 120  30 127  31 116 146\n>».Int.sort;\n \nmy Int $stem_unit = 10;\nmy %h = @data.classify: * div $stem_unit;\n \nmy $range = [minmax] %h.keys».Int;\nmy $stem_format =  \"%{$range.min.chars max $range.max.chars}d\";\n \nfor $range.list -> $stem {\n    my $leafs = %h{$stem} // [];\n    say $stem.fmt($stem_format), ' | ', ~$leafs.map: * % $stem_unit;\n}\n\n```\n\nOutput:\n\n```\n 0 | 7 7\n 1 | 2 3 8 8\n 2 | 3 5 7 7 7 7 7 7 8 8 9 9\n 3 | 0 1 1 1 1 2 3 4 5 6 7 7 7 8 9\n 4 | 0 0 1 2 2 2 2 3 3 3 4 4 4 5 6 7 8 8\n 5 | 2 3 7 8 8\n 6 | 1 3 8\n 7 | 1\n 8 | \n 9 | 6 9\n10 | 4 5 5 5 5 6 7 9 9 9\n11 | 1 3 3 3 3 4 4 4 5 5 5 6 6 6 6 7 7 7 7 8 8 9 9\n12 | 0 0 1 1 2 2 3 4 4 4 5 5 5 6 7 7 7 7 8 8\n13 | 1 2 3 9\n14 | 1 6\n```"}]}
{"messages": [{"role": "user", "content": "For this task, the Stern-Brocot sequence is to be generated by an algorithm similar to that employed in generating the Fibonacci sequence.\n\n1. The first and second members of the sequence are both 1:\n   * 1, 1\n2. Start by considering the second member of the sequence\n3. Sum the considered member of the sequence and its precedent, (1 + 1) = 2, and append it to the end of the sequence:\n   * 1, 1, 2\n4. Append the considered member of the sequence to the end of the sequence:\n   * 1, 1, 2, 1\n5. Consider the next member of the series, (the third member i.e. 2)\n6. GOTO 3\n\n   * ─── Expanding another loop we get: ───\n7. Sum the considered member of the sequence and its precedent, (2 + 1) = 3, and append it to the end of the sequence:\n   * 1, 1, 2, 1, 3\n8. Append the considered member of the sequence to the end of the sequence:\n   * 1, 1, 2, 1, 3, 2\n9. Consider the next member of the series, (the fourth member i.e. 1)\n\nThe task is to\n\n* Create a function/method/subroutine/procedure/... to generate the Stern-Brocot sequence of integers using the method outlined above.\n* Show the first fifteen members of the sequence. (This should be: 1, 1, 2, 1, 3, 2, 3, 1, 4, 3, 5, 2, 5, 3, 4)\n* Show the (1-based) index of where the numbers 1-to-10 first appear in the sequence.\n* Show the (1-based) index of where the number 100 first appears in the sequence.\n* Check that the greatest common divisor of all the two consecutive members of the series up to the 1000th member, is always one.\n\nShow your output on this page.\n\nRelated tasks\n:   * Fusc sequence.\n    * Continued fraction/Arithmetic\n\nRef\n\n* Infinite Fractions - Numberphile (Video).\n* Trees, Teeth, and Time: The mathematics of clock making.\n* A002487 The On-Line Encyclopedia of Integer Sequences."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2017-03\n\n```\nconstant @Stern-Brocot = 1, 1, { |(@_[$_ - 1] + @_[$_], @_[$_]) given ++$ } ... *;\n \nput @Stern-Brocot[^15];\n \nfor flat 1..10, 100 -> $ix {\n    say \"First occurrence of {$ix.fmt('%3d')} is at index: {(1+@Stern-Brocot.first($ix, :k)).fmt('%4d')}\";\n}\n \nsay so 1 == all map ^1000: { [gcd] @Stern-Brocot[$_, $_ + 1] }\n\n```\n\nOutput:\n\n```\n1 1 2 1 3 2 3 1 4 3 5 2 5 3 4\nFirst occurrence of   1 is at index:    1\nFirst occurrence of   2 is at index:    3\nFirst occurrence of   3 is at index:    5\nFirst occurrence of   4 is at index:    9\nFirst occurrence of   5 is at index:   11\nFirst occurrence of   6 is at index:   33\nFirst occurrence of   7 is at index:   19\nFirst occurrence of   8 is at index:   21\nFirst occurrence of   9 is at index:   35\nFirst occurrence of  10 is at index:   39\nFirst occurrence of 100 is at index: 1179\nTrue\n```"}]}
{"messages": [{"role": "user", "content": "Stirling numbers of the first kind, or Stirling cycle numbers, count permutations according to their number\nof cycles (counting fixed points as cycles of length one).\n\nThey may be defined directly to be the number of permutations of **n**\nelements with **k** disjoint cycles.\n\nStirling numbers of the first kind express coefficients of polynomial expansions of falling or rising factorials.\n\nDepending on the application, Stirling numbers of the first kind may be \"signed\"\nor \"unsigned\". Signed Stirling numbers of the first kind arise when the\npolynomial expansion is expressed in terms of falling factorials; unsigned when\nexpressed in terms of rising factorials. The only substantial difference is that,\nfor signed Stirling numbers of the first kind, values of S1(n, k) are negative\nwhen n + k is odd.\n\nStirling numbers of the first kind follow the simple identities:\n\n```\n   S1(0, 0) = 1\n   S1(n, 0) = 0 if n > 0\n   S1(n, k) = 0 if k > n\n   S1(n, k) = S1(n - 1, k - 1) + (n - 1) * S1(n - 1, k) # For unsigned\n     or\n   S1(n, k) = S1(n - 1, k - 1) - (n - 1) * S1(n - 1, k) # For signed\n\n```\n\nTask\n\n:   * Write a routine (function, procedure, whatever) to find **Stirling numbers of the first kind**. There are several methods to generate Stirling numbers of the first kind. You are free to choose the most appropriate for your language. If your language has a built-in, or easily, publicly available library implementation, it is acceptable to use that.\n\n:   * Using the routine, generate and show here, on this page, a table (or triangle) showing the Stirling numbers of the first kind, **S1(n, k)**, up to **S1(12, 12)**. it is optional to show the row / column for n == 0 and k == 0. It is optional to show places where S1(n, k) == 0 (when k > n). You may choose to show signed or unsigned Stirling numbers of the first kind, just make a note of which was chosen.\n\n:   * If your language supports large integers, find and show here, on this page, the maximum value of **S1(n, k)** where **n == 100**.\n\nSee also\n\n:   * **Wikipedia - Stirling numbers of the first kind**\n    * **OEIS:A008275 - Signed Stirling numbers of the first kind**\n    * **OEIS:A130534 - Unsigned Stirling numbers of the first kind**\n\nRelated Tasks\n\n:   * **Stirling numbers of the second kind**\n    * **Lah numbers**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\n```\nsub Stirling1 (Int \\n, Int \\k) {\n    return 1 unless n || k;\n    return 0 unless n && k;\n    state %seen;\n    (%seen{\"{n - 1}|{k - 1}\"} //= Stirling1(n - 1, k - 1)) +\n    (n - 1) * (%seen{\"{n - 1}|{k}\"} //= Stirling1(n - 1, k))\n}\n\nmy $upto = 12;\n\nmy $mx = (1..^$upto).map( { Stirling1($upto, $_) } ).max.chars;\n\nput 'Unsigned Stirling numbers of the first kind: S1(n, k):';\nput 'n\\k', (0..$upto)».fmt: \"%{$mx}d\";\n\nfor 0..$upto -> $row {\n    $row.fmt('%-3d').print;\n    put (0..$row).map( { Stirling1($row, $_) } )».fmt: \"%{$mx}d\";\n}\n\nsay \"\\nMaximum value from the S1(100, *) row:\";\nsay (^100).map( { Stirling1 100, $_ } ).max;\n\n```\n\nOutput:\n\n```\nUnsigned Stirling numbers of the first kind: S1(n, k):\nn\\k        0         1         2         3         4         5         6         7         8         9        10        11        12\n0          1\n1          0         1\n2          0         1         1\n3          0         2         3         1\n4          0         6        11         6         1\n5          0        24        50        35        10         1\n6          0       120       274       225        85        15         1\n7          0       720      1764      1624       735       175        21         1\n8          0      5040     13068     13132      6769      1960       322        28         1\n9          0     40320    109584    118124     67284     22449      4536       546        36         1\n10         0    362880   1026576   1172700    723680    269325     63273      9450       870        45         1\n11         0   3628800  10628640  12753576   8409500   3416930    902055    157773     18150      1320        55         1\n12         0  39916800 120543840 150917976 105258076  45995730  13339535   2637558    357423     32670      1925        66         1\n\nMaximum value from the S1(100, *) row:\n19710908747055261109287881673376044669240511161402863823515728791076863288440277983854056472903481625299174865860036734731122707870406148096000000000000000000\n```"}]}
{"messages": [{"role": "user", "content": "Stirling numbers of the second kind, or Stirling partition numbers, are the\nnumber of ways to partition a set of n objects into k non-empty subsets. They are\nclosely related to Bell numbers, and may be derived from them.\n\nStirling numbers of the second kind obey the recurrence relation:\n\n```\n   S2(n, 0) and S2(0, k) = 0 # for n, k > 0\n   S2(n, n) = 1\n   S2(n + 1, k) = k * S2(n, k) + S2(n, k - 1)\n\n```\n\nTask\n\n:   * Write a routine (function, procedure, whatever) to find **Stirling numbers of the second kind**. There are several methods to generate Stirling numbers of the second kind. You are free to choose the most appropriate for your language. If your language has a built-in, or easily, publicly available library implementation, it is acceptable to use that.\n\n:   * Using the routine, generate and show here, on this page, a table (or triangle) showing the Stirling numbers of the second kind, **S2(n, k)**, up to **S2(12, 12)**. it is optional to show the row / column for n == 0 and k == 0. It is optional to show places where S2(n, k) == 0 (when k > n).\n\n:   * If your language supports large integers, find and show here, on this page, the maximum value of **S2(n, k)** where **n == 100**.\n\nSee also\n\n:   * **Wikipedia - Stirling numbers of the second kind**\n    * **OEIS:A008277 - Stirling numbers of the second kind**\n\nRelated Tasks\n\n:   * **Stirling numbers of the first kind**\n    * **Bell numbers**\n    * **Lah numbers**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\n```\nsub Stirling2 (Int \\n, Int \\k) {\n    ((1,), { (0, |@^last) »+« (|(@^last »*« @^last.keys), 0) } … *)[n;k]\n}\n\nmy $upto = 12;\n\nmy $mx = (1..^$upto).map( { Stirling2($upto, $_) } ).max.chars;\n\nput 'Stirling numbers of the second kind: S2(n, k):';\nput 'n\\k', (0..$upto)».fmt: \"%{$mx}d\";\n\nfor 0..$upto -> $row {\n    $row.fmt('%-3d').print;\n    put (0..$row).map( { Stirling2($row, $_) } )».fmt: \"%{$mx}d\";\n}\n\nsay \"\\nMaximum value from the S2(100, *) row:\";\nsay (^100).map( { Stirling2 100, $_ } ).max;\n\n```\n\nOutput:\n\n```\nStirling numbers of the second kind: S2(n, k):\nn\\k      0       1       2       3       4       5       6       7       8       9      10      11      12\n0        1\n1        0       1\n2        0       1       1\n3        0       1       3       1\n4        0       1       7       6       1\n5        0       1      15      25      10       1\n6        0       1      31      90      65      15       1\n7        0       1      63     301     350     140      21       1\n8        0       1     127     966    1701    1050     266      28       1\n9        0       1     255    3025    7770    6951    2646     462      36       1\n10       0       1     511    9330   34105   42525   22827    5880     750      45       1\n11       0       1    1023   28501  145750  246730  179487   63987   11880    1155      55       1\n12       0       1    2047   86526  611501 1379400 1323652  627396  159027   22275    1705      66       1\n\nMaximum value from the S2(100, *) row:\n7769730053598745155212806612787584787397878128370115840974992570102386086289805848025074822404843545178960761551674\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement functions to encrypt and decrypt a message using the straddling checkerboard method. The checkerboard should take a 28 character alphabet (A-Z plus a full stop and an escape character) and two different numbers representing the blanks in the first row. The output will be a series of decimal digits.\n\nNumbers should be encrypted by inserting the escape character before each digit, then including the digit unencrypted. This should be reversed for decryption."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nThe .trans method in Raku improves on Perl 5's tr/// by allowing multi-character translation tables.\n\nWe build the full table during .new, which simplifies .encode and .decode.\n\n```\nclass Straddling_Checkerboard {\n    has @!flat_board; # 10x3 stored as 30x1\n    has $!plain2code; # full translation table, invertable\n    has @!table;      # Printable layout, like Wikipedia entry\n \n    my $numeric_escape = '/';\n    my $exclude = /<-[A..Z0..9.]>/; # Omit the escape character\n\n    method display_table { gather { take ~ .list for @!table } };\n\n    method decode ( Str $s --> Str ) {\n        $s.trans($!plain2code.antipairs);\n    }\n\n    method encode ( Str $s, :$collapse? --> Str ) {\n        my $replace = $collapse ?? '' !! '.';\n        $s.uc.subst( $exclude, $replace, :g ).trans($!plain2code);\n    }\n\n    submethod BUILD ( :$alphabet, :$u where 0..9, :$v where 0..9 ) {\n        die if $u == $v;\n        die if $alphabet.comb.sort.join ne [~] flat './', 'A'..'Z';\n\n        @!flat_board = $alphabet.uc.comb;\n        @!flat_board.splice( $u min $v, 0, Any );\n        @!flat_board.splice( $u max $v, 0, Any );\n\n        @!table = [ ' ',|            [ 0 ..  9]                              ],\n                  [ ' ',|@!flat_board[ 0 ..  9].map: {.defined ?? $_ !! ' '} ],\n                  [ $u, |@!flat_board[10 .. 19]                              ],\n                  [ $v, |@!flat_board[20 .. 29]                              ];\n\n        my @order = 0..9; # This may be passed as a param in the future\n\n        my @nums = flat @order,\n                   @order.map({ +\"$u$_\" }),\n                   @order.map({ +\"$v$_\" });\n\n        my %c2p = @nums Z=> @!flat_board;\n        %c2p{$_}:delete if %c2p{$_} eqv Any for keys %c2p;\n        my %p2c = %c2p.invert;\n        %p2c{$_} = %p2c{$numeric_escape} ~ $_ for 0..9;\n        $!plain2code = [%p2c.keys] => [%p2c.values];\n    }\n}\n\nsub MAIN ( :$u = 3, :$v = 7, :$alphabet = 'HOLMESRTABCDFGIJKNPQUVWXYZ./' ) {\n    my Straddling_Checkerboard $sc .= new: :$u, :$v, :$alphabet;\n    $sc.display_table;\n\n    for 0..1 -> $collapse {\n        my $original = 'One night-it was on the twentieth of March, 1888-I was returning';\n        my $en = $sc.encode($original, :$collapse);\n        my $de = $sc.decode($en);\n        say '';\n        say \"Original: $original\";\n        say \"Encoded:  $en\";\n        say \"Decoded:  $de\";\n    }\n}\n\n```\n\nOutput:\n\n```\n  0 1 2 3 4 5 6 7 8 9\n  H O L   M E S   R T\n3 A B C D F G I J K N\n7 P Q U V W X Y Z . /\n\nOriginal: One night-it was on the twentieth of March, 1888-I was returning\nEncoded:  13957839363509783697874306781397890578974539936590781347843083207878791798798798783678743067885972839363935\nDecoded:  ONE.NIGHT.IT.WAS.ON.THE.TWENTIETH.OF.MARCH..1888.I.WAS.RETURNING\n\nOriginal: One night-it was on the twentieth of March, 1888-I was returning\nEncoded:  139539363509369743061399059745399365901344308320791798798798367430685972839363935\nDecoded:  ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\n**n**   is a   **strange number**   (expressed in base ten)   if every adjacent decimal digit differs from its neighbour by a prime number.\n\nTask\n\nShow all strange numbers for   100   <   **n**   <   500\n\nStretch goal\n\nShow the number of 10-digit strange numbers that begin with 1"}, {"role": "assistant", "content": "```\nsub infix:<′>(\\x,\\y) { abs(x - y) ∈ (2, 3, 5, 7) }\n\nmy ($low,$high) = 100, 500;\nmy @strange.push: $_ if so all .comb.rotor(2 => -1).map: { .[0] ′ .[1] } for $low ^..^ $high;\n\nsay \"Between $low and $high there are {+@strange} strange numbers:\\n\";\nprint @strange.batch(20)».fmt(\"%4d\").join: \"\\n\";\n\n```\n\nOutput:\n\n```\nBetween 100 and 500 there are 87 strange numbers:\n\n 130  131  135  136  138  141  142  146  147  149  161  163  164  168  169  181  183  185  186  202\n 203  205  207  241  242  246  247  249  250  252  253  257  258  270  272  274  275  279  292  294\n 296  297  302  303  305  307  313  314  316  318  350  352  353  357  358  361  363  364  368  369\n 381  383  385  386  413  414  416  418  420  424  425  427  429  461  463  464  468  469  470  472\n 474  475  479  492  494  496  497\n```"}]}
{"messages": [{"role": "user", "content": "**n**   is a **strange plus number** if the sum of the first two digits is prime and the sum of the second two digits is also prime.\n\nWhere     100   <   **n**   <   500\n\nRelated task\n\n* Strange\\_numbers"}, {"role": "assistant", "content": "```\nunit sub MAIN ($start = 100, $end = 500);\nput +$_, \" matching numbers from $start to $end:\\n\", $_ given\n  ($start .. $end).hyper(:256batch,:8degree).grep: { all .comb.rotor(2 => -1).map: { .sum.is-prime } };\n\n```\n\nOutput:\n\n```\n65 matching numbers from 100 to 500:\n111 112 114 116 120 121 123 125 129 141 143 147 149 161 165 167 202 203 205 207 211 212 214 216 230 232 234 238 250 252 256 258 292 294 298 302 303 305 307 320 321 323 325 329 341 343 347 349 383 385 389 411 412 414 416 430 432 434 438 470 474 476 492 494 498\n```"}]}
{"messages": [{"role": "user", "content": "Primes   **n,   m,**   and   **p**   are   *strange unique primes*   if   **n,   m,**   and   **p**   are unique and their sum     **n + m + p**     is also prime. Assume **n** < **m** < **p**.\n\nTask\n:   * Find all triplets of strange unique primes in which   **n,   m,**   and   **p**   are all less than   **30**.\n    * (stretch goal)   Show the count (only) of all the triplets of strange unique primes in which     **n, m,** and **p**    are all less than   **1,000**."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# 20210312 Raku programming solution\n\nfor 30, 1000 -> \\k {\n   given (2..k).grep(*.is-prime).combinations(3).grep(*.sum.is-prime) {\n      say \"Found \", +$_, \" strange unique prime triplets up to \", k\n   }\n}\n\n```\n\nOutput:\n\n```\nFound 42 strange unique prime triplets up to 30\nFound 241580 strange unique prime triplets up to 1000\n\n```"}]}
{"messages": [{"role": "user", "content": "Description\n\nIn linear algebra, the Strassen algorithm   (named after Volker Strassen),   is an algorithm for matrix multiplication.\n\nIt is faster than the standard matrix multiplication algorithm and is useful in practice for large matrices,   but would be slower than the fastest known algorithms for extremely large matrices.\n\nTask\n\nWrite a routine, function, procedure etc. in your language to implement the Strassen algorithm for matrix multiplication.\n\nWhile practical implementations of Strassen's algorithm usually switch to standard methods of matrix multiplication for small enough sub-matrices (currently anything less than   512×512   according to Wikipedia),   for the purposes of this task you should not switch until reaching a size of 1 or 2.\n\nRelated task\n:   * Matrix multiplication\n\nSee also\n:   * Wikipedia article"}, {"role": "assistant", "content": "Special thanks go to the module author, Fernando Santagata, on showing how to deal with a pass-by-value case.\n\n**Translation of**: Julia\n\n```\n# 20210126 Raku programming solution\n\nuse Math::Libgsl::Constants;\nuse Math::Libgsl::Matrix;\nuse Math::Libgsl::BLAS;\n \nmy @M;\n \nsub SQM (\\in) { # create custom sq matrix from CSV \n   die \"Not a ■\" if (my \\L = in.split(/\\,/)).sqrt != (my \\size = L.sqrt.Int);\n   my Math::Libgsl::Matrix \\M .= new: size, size;\n   for ^size Z L.rotor(size) -> ($i, @row) { M.set-row: $i, @row } \n   M\n}\n \nsub infix:<⊗>(\\x,\\y) { # custom multiplication \n   my Math::Libgsl::Matrix \\z .= new: x.size1, x.size2;\n   dgemm(CblasNoTrans, CblasNoTrans, 1, x, y, 1, z);\n   z\n}\n \nsub infix:<⊕>(\\x,\\y) { # custom addition\n   my Math::Libgsl::Matrix \\z .= new: x.size1, x.size2;\n   z.copy(x).add(y) \n}\n \nsub infix:<⊖>(\\x,\\y) { # custom subtraction\n   my Math::Libgsl::Matrix \\z .= new: x.size1, x.size2;\n   z.copy(x).sub(y)\n}\n \nsub Strassen($A, $B) {\n \n   { return $A ⊗ $B } if (my \\n = $A.size1) == 1;\n \n   my Math::Libgsl::Matrix        ($A11,$A12,$A21,$A22,$B11,$B12,$B21,$B22); \n   my Math::Libgsl::Matrix        ($P1,$P2,$P3,$P4,$P5,$P6,$P7);\n   my Math::Libgsl::Matrix::View  ($mv1,$mv2,$mv3,$mv4,$mv5,$mv6,$mv7,$mv8);\n   ($mv1,$mv2,$mv3,$mv4,$mv5,$mv6,$mv7,$mv8)».=new ;\n\n   my \\half = n div 2; # dimension of quarter submatrices    \n\n   $A11 = $mv1.submatrix($A, 0,0,       half,half); # \n   $A12 = $mv2.submatrix($A, 0,half,    half,half); #  create quarter views \n   $A21 = $mv3.submatrix($A, half,0,    half,half); #  of operand matrices  \n   $A22 = $mv4.submatrix($A, half,half, half,half); # \n   $B11 = $mv5.submatrix($B, 0,0,       half,half); #       11    12 \n   $B12 = $mv6.submatrix($B, 0,half,    half,half); # \n   $B21 = $mv7.submatrix($B, half,0,    half,half); #       21    22 \n   $B22 = $mv8.submatrix($B, half,half, half,half); # \n \n   $P1 = Strassen($A12 ⊖ $A22, $B21 ⊕ $B22);\n   $P2 = Strassen($A11 ⊕ $A22, $B11 ⊕ $B22);\n   $P3 = Strassen($A11 ⊖ $A21, $B11 ⊕ $B12);\n   $P4 = Strassen($A11 ⊕ $A12, $B22        );\n   $P5 = Strassen($A11,         $B12 ⊖ $B22);\n   $P6 = Strassen($A22,         $B21 ⊖ $B11);\n   $P7 = Strassen($A21 ⊕ $A22, $B11        );\n \n   my Math::Libgsl::Matrix        $C .= new: n, n;               # Build C from\n   my Math::Libgsl::Matrix::View  ($mvC11,$mvC12,$mvC21,$mvC22); #    C11 C12\n   ($mvC11,$mvC12,$mvC21,$mvC22)».=new ;                         #    C21 C22\n\n   given $mvC11.submatrix($C, 0,0,       half,half) { .add: (($P1 ⊕ $P2) ⊖ $P4) ⊕ $P6 }; \n   given $mvC12.submatrix($C, 0,half,    half,half) { .add:   $P4 ⊕ $P5 };\n   given $mvC21.submatrix($C, half,0,    half,half) { .add:   $P6 ⊕ $P7 };\n   given $mvC22.submatrix($C, half,half, half,half) { .add: (($P2 ⊖ $P3) ⊕ $P5) ⊖ $P7 };\n\n   $C \n}\n \nfor $=pod[0].contents { next if /^\\n$/ ; @M.append: SQM $_ }\n \nfor @M.rotor(2) { \n   my $product = @_[0] ⊗ @_[1];\n#   $product.get-row($_)».round(1).fmt('%2d').put for ^$product.size1;\n \n   say \"Regular multiply:\";\n   $product.get-row($_)».fmt('%.10g').put for ^$product.size1;\n \n   $product = Strassen @_[0], @_[1];\n \n   say \"Strassen multiply:\";\n   $product.get-row($_)».fmt('%.10g').put for ^$product.size1;\n} \n \n=begin code   \n1,2,3,4\n5,6,7,8\n1,1,1,1,2,4,8,16,3,9,27,81,4,16,64,256\n4,-3,4/3,-1/4,-13/3,19/4,-7/3,11/24,3/2,-2,7/6,-1/4,-1/6,1/4,-1/6,1/24\n1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16\n1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1\n=end code\n\n```\n\nOutput:\n\n```\nRegular multiply:\n19 22\n43 50\nStrassen multiply:\n19 22\n43 50\nRegular multiply:\n1 0 -1.387778781e-16 -2.081668171e-17\n1.33226763e-15 1 -4.440892099e-16 -1.110223025e-16\n0 0 1 0\n7.105427358e-15 0 7.105427358e-15 1\nStrassen multiply:\n1 5.684341886e-14 -2.664535259e-15 -1.110223025e-16\n-1.136868377e-13 1 -7.105427358e-15 2.220446049e-15\n0 0 1 5.684341886e-14\n0 0 -2.273736754e-13 1\nRegular multiply:\n1 2 3 4\n5 6 7 8\n9 10 11 12\n13 14 15 16\nStrassen multiply:\n1 2 3 4\n5 6 7 8\n9 10 11 12\n13 14 15 16\n```"}]}
{"messages": [{"role": "user", "content": "2-stream merge\n:   Read two sorted streams of items from external source (e.g. disk, or network), and write one stream of sorted items to external sink.\n:   Common algorithm: keep 1 buffered item from each source, select minimal of them, write it, fetch another item from that stream from which the written item was.\n\n*N*-stream merge\n:   The same as above, but reading from    ***N***    sources.\n:   Common algorithm: same as above, but keep buffered items and their source descriptors in a heap.\n\nAssume streams are very big. You must not suck them whole in the memory, but read them as streams."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.02\n\n```\nsub merge_streams ( @streams ) {\n    my @s = @streams.map({ hash( STREAM => $_, HEAD => .get ) })\\\n                    .grep({ .<HEAD>.defined });\n\n    return gather while @s {\n        my $h = @s.min: *.<HEAD>;\n        take $h<HEAD>;\n        $h<HEAD> := $h<STREAM>.get\n            orelse @s .= grep( { $_ !=== $h } );\n    }\n}\n\nsay merge_streams([ @*ARGS».&open ]);\n\n```"}]}
{"messages": [{"role": "user", "content": "Most languages provide a way to concatenate two string values, but some languages also provide a convenient way to append in-place to an existing string variable without referring to the variable twice.\n\nTask\n\nCreate a string variable equal to any text value.\n\nAppend the string variable with another string literal in the most idiomatic way, without double reference if your language supports it.\n\nShow the contents of the variable after the append operation."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $str = \"foo\";\n$str ~= \"bar\";\nsay $str;\n\n```\n\nOutput:\n\n```\nfoobar\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nTake the string     **alphaBETA**     and demonstrate how to convert it to:\n\n:   :   :   * upper-case     and\n            * lower-case\n\nUse the default encoding of a string literal or plain ASCII if there is no string literal in your language.\n\nNote: In some languages alphabets toLower and toUpper is not reversable.\n\nShow any additional case conversion functions   (e.g. swapping case, capitalizing the first letter, etc.)   that may be included in the library of your language.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\nIn Raku, case modification is implemented as builtin subroutine or method:\n\n```\nmy $word = \"alpha BETA\" ;\nsay uc $word;         # all uppercase (subroutine call)\nsay $word.uc;         # all uppercase (method call)\n# from now on we use only method calls as examples\nsay $word.lc;         # all lowercase\nsay $word.tc;         # first letter titlecase\nsay $word.tclc;       # first letter titlecase, rest lowercase\nsay $word.wordcase;   # capitalize each word\n```\n\nOutput:\n\n```\nALPHA BETA\nalpha beta\nAlpha BETA\nAlpha beta\nAlpha Beta\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate how to compare two strings from within the language and how to achieve a lexical comparison.\n\nThe task should demonstrate:\n\n* Comparing two strings for exact equality\n* Comparing two strings for inequality (i.e., the inverse of exact equality)\n* Comparing two strings to see if one is lexically ordered before than the other\n* Comparing two strings to see if one is lexically ordered after than the other\n* How to achieve both case sensitive comparisons and case insensitive comparisons within the language\n* How the language handles comparison of numeric strings if these are not treated lexically\n* Demonstrate any other kinds of string comparisons that the language provides, particularly as it relates to your type system.\n\nFor example, you might demonstrate the difference between generic/polymorphic comparison and coercive/allomorphic comparison if your language supports such a distinction.\n\nHere \"generic/polymorphic\" comparison means that the function or operator you're using doesn't always do string comparison, but bends the actual semantics of the comparison depending on the types one or both arguments; with such an operator, you achieve string comparison only if the arguments are sufficiently string-like in type or appearance.\n\nIn contrast, a \"coercive/allomorphic\" comparison function or operator has fixed string-comparison semantics regardless of the argument type;   instead of the operator bending, it's the arguments that are forced to bend instead and behave like strings if they can,   and the operator simply fails if the arguments cannot be viewed somehow as strings.   A language may have one or both of these kinds of operators;   see the Raku entry for an example of a language with both kinds of operators.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku uses strong typing dynamically (and gradual typing statically), but normal string and numeric comparisons are coercive. (You may use generic comparison operators if you want polymorphic comparison—but usually you don't. :)\n\nString comparisons never do case folding because that's a very complicated subject in the modern world of Unicode. (You can explicitly apply an appropriate case-folding function to the arguments before doing the comparison, or for \"equality\" testing you can do matching with a case-insensitive regex, assuming Unicode's language-neutral case-folding rules are okay.)\n\n```\nsub compare($a,$b) {\n    my $A = \"{$a.WHAT.^name} '$a'\";\n    my $B = \"{$b.WHAT.^name} '$b'\";\n\n    if $a eq $b { say \"$A and $B are lexically equal\" }\n    if $a ne $b { say \"$A and $B are not lexically equal\" }\n\n    if $a gt $b { say \"$A is lexically after $B\" }\n    if $a lt $b { say \"$A is lexically before than $B\" }\n\n    if $a ge $b { say \"$A is not lexically before $B\" }\n    if $a le $b { say \"$A is not lexically after $B\" }\n\n    if $a === $b { say \"$A and $B are identical objects\" }\n    if $a !=== $b { say \"$A and $B are not identical objects\" }\n\n    if $a eqv $b { say \"$A and $B are generically equal\" }\n    if $a !eqv $b { say \"$A and $B are not generically equal\" }\n\n    if $a before $b { say \"$A is generically after $B\" }\n    if $a after $b { say \"$A is generically before $B\" }\n\n    if $a !after $b { say \"$A is not generically before $B\" }\n    if $a !before $b { say \"$A is not generically after $B\" }\n\n    say \"The lexical relationship of $A and $B is { $a leg $b }\" if $a ~~ Stringy;\n    say \"The generic relationship of $A and $B is { $a cmp $b }\";\n    say \"The numeric relationship of $A and $B is { $a <=> $b }\" if $a ~~ Numeric;\n    say '';\n}\n\ncompare 'YUP', 'YUP';\ncompare 'BALL', 'BELL';\ncompare 24, 123;\ncompare 5.1, 5;\ncompare 5.1e0, 5 + 1/10;\n\n```\n\nOutput:\n\n```\nStr 'YUP' and Str 'YUP' are lexically equal\nStr 'YUP' is not lexically before Str 'YUP'\nStr 'YUP' is not lexically after Str 'YUP'\nStr 'YUP' and Str 'YUP' are identical objects\nStr 'YUP' and Str 'YUP' are generically equal\nStr 'YUP' is not generically before Str 'YUP'\nStr 'YUP' is not generically after Str 'YUP'\nThe lexical relationship of Str 'YUP' and Str 'YUP' is Same\nThe generic relationship of Str 'YUP' and Str 'YUP' is Same\n\nStr 'BALL' and Str 'BELL' are not lexically equal\nStr 'BALL' is lexically before than Str 'BELL'\nStr 'BALL' is not lexically after Str 'BELL'\nStr 'BALL' and Str 'BELL' are not identical objects\nStr 'BALL' and Str 'BELL' are not generically equal\nStr 'BALL' is generically after Str 'BELL'\nStr 'BALL' is not generically before Str 'BELL'\nThe lexical relationship of Str 'BALL' and Str 'BELL' is Increase\nThe generic relationship of Str 'BALL' and Str 'BELL' is Increase\n\nInt '24' and Int '123' are not lexically equal\nInt '24' is lexically after Int '123'\nInt '24' is not lexically before Int '123'\nInt '24' and Int '123' are not identical objects\nInt '24' and Int '123' are not generically equal\nInt '24' is generically after Int '123'\nInt '24' is not generically before Int '123'\nThe generic relationship of Int '24' and Int '123' is Increase\nThe numeric relationship of Int '24' and Int '123' is Increase\n\nRat '5.1' and Int '5' are not lexically equal\nRat '5.1' is lexically after Int '5'\nRat '5.1' is not lexically before Int '5'\nRat '5.1' and Int '5' are not identical objects\nRat '5.1' and Int '5' are not generically equal\nRat '5.1' is generically before Int '5'\nRat '5.1' is not generically after Int '5'\nThe generic relationship of Rat '5.1' and Int '5' is Decrease\nThe numeric relationship of Rat '5.1' and Int '5' is Decrease\n\nNum '5.1' and Rat '5.1' are lexically equal\nNum '5.1' is not lexically before Rat '5.1'\nNum '5.1' is not lexically after Rat '5.1'\nNum '5.1' and Rat '5.1' are not identical objects\nNum '5.1' and Rat '5.1' are not generically equal\nNum '5.1' is not generically before Rat '5.1'\nNum '5.1' is not generically after Rat '5.1'\nThe generic relationship of Num '5.1' and Rat '5.1' is Same\nThe numeric relationship of Num '5.1' and Rat '5.1' is Same\n```\n\n### Unicode normalization by default\n\nBe aware that Raku applies normalization (Unicode NFC form (Normalization Form Canonical)) by default to all input and output except for file names See docs. Raku follows the Unicode spec. Raku follows **all** of the Unicode spec, including parts that some people don't like. There are some graphemes for which the Unicode consortium has specified that the NFC form is a different (though usually visually identical) grapheme. Referred to in Unicode standard annex #15 as **Canonical Equivalence**. Raku adheres to that spec.\n\nOne that people seem to get hung up on is the Kelvin symbol \"K\" getting automatically converted to ASCII uppercase \"K\".\n\n```\nsay \"\\c[KELVIN SIGN]\".uniname;\n# => LATIN CAPITAL LETTER K\n\nmy $kelvin = \"\\c[KELVIN SIGN]\";\nmy $k = \"\\c[LATIN CAPITAL LETTER K]\";\nsay ($kelvin eq $k); # True, lexically equal\nsay ($kelvin eqv $k); # True, generically equal\nsay ($kelvin === $k); # True, identical objects\n\n```\n\nIn most programming language the previous two objects wouldn't be equivalent, but since Raku follows the Unicode specification, and normalization is applied automatically, they show up as equivalent.\n\nIt's officially identified as a possible trap for string handling. See docs."}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a string variable equal to any text value.\n\nCreate another string variable whose value is the original variable concatenated with another string literal.\n\nTo illustrate the operation, show the content of the variables.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #22 \"Thousand Oaks\"\n\n```\nmy $s = 'hello';\nsay $s ~ ' literal';\nmy $s1 = $s ~ ' literal';\nsay $s1;\n\n# or, using mutating concatenation:\n\n$s ~= ' literal';\nsay $s;\n```\n\nNote also that most concatenation in Raku is done implicitly via interpolation."}]}
{"messages": [{"role": "user", "content": "Given a string and defined variables or values, string interpolation is the replacement of defined character sequences in the string by values or variable values.\n\n:   For example, given an original string of `\"Mary had a X lamb.\"`, a value of \"big\", and if the language replaces X in its interpolation routine, then the result of its interpolation would be the string `\"Mary had a big lamb\"`.\n\n:   (Languages usually include an infrequently used character or sequence of characters to indicate what is to be replaced such as \"%\", or \"#\" rather than \"X\").\n\nTask\n\n1. Use your languages inbuilt string interpolation abilities to interpolate a string missing the text `\"little\"` which is held in a variable, to produce the output string `\"Mary had a little lamb\"`.\n2. If possible, give links to further documentation on your languages string interpolation features.\n\nNote: The task is not to create a string interpolation routine, but to show a language's built-in capability.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $extra = \"little\";\nsay \"Mary had a $extra lamb\";           # variable interpolation\nsay \"Mary had a { $extra } lamb\";       # expression interpolation\nprintf \"Mary had a %s lamb.\\n\", $extra; # standard printf\nsay $extra.fmt(\"Mary had a %s lamb\");   # inside-out printf\nmy @lambs = <Jimmy Bobby Tommy>;\nsay Q :array { $$$ The lambs are called @lambs[]\\\\\\.} # only @-sigiled containers are interpolated\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind the *character* and *byte* length of a string.\n\nThis means encodings like UTF-8 need to be handled properly, as there is not necessarily a one-to-one relationship between bytes and characters.\n\nBy *character*, we mean an individual Unicode *code point*, not a user-visible *grapheme* containing combining characters.\n\nFor example, the character length of \"møøse\" is 5 but the byte length is 7 in UTF-8 and 10 in UTF-16.\n\nNon-BMP code points (those between 0x10000 and 0x10FFFF) must also be handled correctly: answers should produce actual character counts in code points, not in code unit counts.\n\nTherefore a string like \"𝔘𝔫𝔦𝔠𝔬𝔡𝔢\" (consisting of the 7 Unicode characters U+1D518 U+1D52B U+1D526 U+1D520 U+1D52C U+1D521 U+1D522) is 7 characters long, **not** 14 UTF-16 code units; and it is 28 bytes long whether encoded in UTF-8 or in UTF-16.\n\nPlease mark your examples with ===Character Length=== or ===Byte Length===.\n\nIf your language is capable of providing the string length in graphemes, mark those examples with ===Grapheme Length===.\n\nFor example, the string \"J̲o̲s̲é̲\" (\"J\\x{332}o\\x{332}s\\x{332}e\\x{301}\\x{332}\") has 4 user-visible graphemes, 9 characters (code points), and 14 bytes when encoded in UTF-8.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Byte Length\n\n```\nsay 'møøse'.encode('UTF-8').bytes;\n```\n\n### Character Length\n\n```\nsay 'møøse'.codes;\n```\n\n### Grapheme Length\n\n```\nsay 'møøse'.chars;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven two strings, demonstrate the following three types of string matching:\n\n:   :   1. Determining if the first string starts with second string\n        2. Determining if the first string contains the second string at any location\n        3. Determining if the first string ends with the second string\n\nOptional requirements:\n\n:   :   1. Print the location of the match for part 2\n        2. Handle multiple occurrences of a string for part 2.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUsing string methods:\n\n```\n$haystack.starts-with($needle)  # True if $haystack starts with $needle\n$haystack.contains($needle)     # True if $haystack contains $needle\n$haystack.ends-with($needle)    # True if $haystack ends with $needle\n```\n\nUsing regexes:\n\n```\nso $haystack ~~ /^ $needle  /  # True if $haystack starts with $needle\nso $haystack ~~ /  $needle  /  # True if $haystack contains $needle\nso $haystack ~~ /  $needle $/  # True if $haystack ends with $needle\n```\n\nUsing `substr`:\n\n```\nsubstr($haystack, 0, $needle.chars) eq $needle  # True if $haystack starts with $needle\nsubstr($haystack, *-$needle.chars) eq $needle   # True if $haystack ends with $needle\n```\n\nBonus task:\n\n```\n$haystack.match($needle, :g)».from;  # List of all positions where $needle appears in $haystack\n$haystack.indices($needle :overlap); # Also find any overlapping instances of $needle in $haystack\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a string variable equal to any text value.\n\nPrepend the string variable with another string literal.\n\nIf your language supports any idiomatic ways to do this without referring to the variable twice in one expression, include such solutions.\n\nTo illustrate the operation, show the content of the variable."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# explicit concatentation\n$_ = 'byte';\n$_ = 'kilo' ~ $_;\n.say;\n\n# interpolation as concatenation\n$_ = 'buck';\n$_ = \"mega$_\";\n.say;\n\n# lvalue substr\n$_ = 'bit';\nsubstr-rw($_,0,0) = 'nano';\n.say;\n\n# regex substitution\n$_ = 'fortnight';\ns[^] = 'micro';\n.say;\n\n# reversed append assignment\n$_ = 'cooper'; \n$_ [R~]= 'mini';\n.say;\n\n```\n\nOutput:\n\n```\nkilobyte\nmegabuck\nnanobit\nmicrofortnight\nminicooper\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a function that strips a set of characters from a string.\n\nThe function should take two arguments:\n\n:   :   :   1. a string to be stripped\n            2. a string containing the set of characters to be stripped\n\nThe returned string should contain the first string, stripped of any characters in the second argument:\n\n```\n print stripchars(\"She was a soul stripper. She took my heart!\",\"aei\")\nSh ws  soul strppr. Sh took my hrt!\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub strip_chars ( $s, $chars ) {\n    return $s.trans( $chars.comb X=> '' );\n}\n\nsay strip_chars( 'She was a soul stripper. She took my heart!', 'aei' );\n\n```\n\nOutput:\n\n```\nSh ws  soul strppr. Sh took my hrt!\n```"}]}
{"messages": [{"role": "user", "content": "A block comment begins with a   *beginning delimiter*   and ends with a   *ending delimiter*,   including the delimiters.   These delimiters are often multi-character sequences.\n\nTask\n\nStrip block comments from program text (of a programming language much like classic C).\n\nYour demos should at least handle simple, non-nested and multi-line block comment delimiters.\n\nThe block comment delimiters are the two-character sequences:\n\n:   :   :   * **/\\***      (beginning delimiter)\n            * **\\*/**      (ending delimiter)\n\nSample text for stripping:\n\n```\n  /**\n   * Some comments\n   * longer comments here that we can parse.\n   *\n   * Rahoo \n   */\n   function subroutine() {\n    a = /* inline comment */ b + c ;\n   }\n   /*/ <-- tricky comments */\n\n   /**\n    * Another comment.\n    */\n    function something() {\n    }\n\n```\n\nExtra credit\n\nEnsure that the stripping code is not hard-coded to the particular delimiters described above, but instead allows the caller to specify them.   (If your language supports them,   optional parameters   may be useful for this.)\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsample().split(/ '/*' .+? '*/' /).print;\n\nsub sample {\n'   /**\n    * Some comments\n    * longer comments here that we can parse.\n    *\n    * Rahoo\n    */\n    function subroutine() {\n     a = /* inline comment */ b + c ;\n    }\n    /*/ <-- tricky comments */\n\n    /**\n     * Another comment.\n     */\n    function something() {\n    }\n'}\n\n```\n\nOutput:\n\n```\n   \n    function subroutine() {\n     a =  b + c ;\n    }\n    \n\n    \n    function something() {\n    }\n\n```"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nThe task is to remove text that follow any of a set of comment markers, (in these examples either a hash or a semicolon) from a string or input line.\n\n**Whitespace debacle:**   There is some confusion about whether to remove any whitespace from the input line.\n\nAs of 2 September 2011, at least 8 languages (C, C++, Java, Perl, Python, Ruby, sed, UNIX Shell) were incorrect, out of 36 total languages, because they did not trim whitespace by 29 March 2011 rules. Some other languages might be incorrect for the same reason.\n\n**Please discuss this issue at Talk:Strip comments from a string.**\n\n* From 29 March 2011, this task required that: *\"The comment marker and any whitespace at the beginning or ends of the resultant line should be removed. A line without comments should be trimmed of any leading or trailing whitespace before being produced as a result.\"* The task had 28 languages, which did not all meet this new requirement.\n* From 28 March 2011, this task required that: *\"Whitespace before the comment marker should be removed.\"*\n* From 30 October 2010, this task did not specify whether or not to remove whitespace.\n\nThe following examples will be truncated to either \"apples, pears \" or \"apples, pears\".\n\n(This example has flipped between \"apples, pears \" and \"apples, pears\" in the past.)\n\n```\napples, pears # and bananas\napples, pears ; and bananas\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n$*IN.slurp.subst(/ \\h* <[ # ; ]> \\N* /, '', :g).print\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nStrip control codes and extended characters from a string.\n\nThe solution should demonstrate how to achieve each of the following results:\n\n:   * a string with control codes stripped (but extended characters not stripped)\n    * a string with control codes and extended characters stripped\n\nIn ASCII, the control codes have decimal codes 0 through to 31 and 127.\n\nOn an ASCII based system, if the control codes are stripped, the resultant string would have all of its characters within the range of 32 to 126 decimal on the ASCII table.\n\nOn a non-ASCII based system, we consider characters that do not have a corresponding glyph on the ASCII table (within the ASCII range of 32 to 126 decimal) to be an extended character for the purpose of this task.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nmy $str = (0..400).roll(80)».chr.join;\n\nsay $str;\nsay $str.subst(/<:Cc>/,      '', :g); # unicode property: control character\nsay $str.subst(/<-[\\ ..~]>/, '', :g);\n\n```\n\n```\nkşaNĹĭŗ�|Ęw���\"ÄlĄWł8iCƁę��Ż�¬�5ĎĶ'óü¸'ÍŸ;ŢƐ¦�´ŷQċűÒŴ$ÃŅ�Đįð+=ĥƂ+Ōĭħ¼ŕc¤H~ìïēÕ\nkşaNĹĭŗ|Ęw\"ÄlĄWł8iCƁ꯬5ĎĶ'óü¸'ÍŸ;ŢƐ¦´ŷQċűÒŴ$ÃŅĐįð+=ĥƂ+Ōĭħ¼ŕc¤H~ìïēÕ\nkaN|w\"lW8iC5'';Q$+=+cH~\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate how to strip leading and trailing whitespace from a string.\n\nThe solution should demonstrate how to achieve the following three results:\n\n* String with leading whitespace removed\n* String with trailing whitespace removed\n* String with both leading and trailing whitespace removed\n\nFor the purposes of this task whitespace includes non printable characters such as the space character, the tab character, and other such characters that have no corresponding graphical representation.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\n```\nmy $s = \"\\r\\n \\t\\x2029 Good Stuff \\x202F\\n\";\nsay $s.trim;\nsay $s.trim.raku;\nsay $s.trim-leading.raku;\nsay $s.trim-trailing.raku;\n\n```\n\nOutput:\n\n```\nGood Stuff\n\"Good Stuff\"\n\"Good Stuff  \\n\"\n\"\\r\\n \\t
 Good Stuff\"\n\n```"}]}
{"messages": [{"role": "user", "content": "Definitions   (as per number theory)\n:   :   * The   **prime(*p*)**   is the    ***p*th   prime.**\n\n        :   :   :   * **prime(1)**   is   **2**\n                    * **prime(4)**   is   **7**\n\n        * A    **strong   prime**   is when     **prime(*p*)**   is   **>**   **[prime(*p*-1) + prime(*p*+1)] ÷ 2**\n        * A   **weak    prime**   is when     **prime(*p*)**   is   **<**   **[prime(*p*-1) + prime(*p*+1)] ÷ 2**\n\nNote that the definition for   **strong primes**   is different when used in the context of   cryptography.\n\nTask\n:   :   * Find and display (on one line) the first   **36**   strong primes.\n        * Find and display the   *count*   of the strong primes below   1,000,000.\n        * Find and display the   *count*   of the strong primes below 10,000,000.\n        * Find and display (on one line) the first   **37**   weak primes.\n        * Find and display the   *count*   of the weak primes below   1,000,000.\n        * Find and display the   *count*   of the weak primes below 10,000,000.\n        * (Optional)   display the   *counts*   and   \"below numbers\"   with commas.\n\nShow all output here.\n\nRelated Task\n:   :   * Safe primes and unsafe primes.\n\nAlso see\n:   :   * The OEIS article A051634: strong primes.\n        * The OEIS article A051635: weak primes."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.11\n\n```\nsub comma { $^i.flip.comb(3).join(',').flip }\n\nuse Math::Primesieve;\n\nmy $sieve = Math::Primesieve.new;\n\nmy @primes = $sieve.primes(10_000_019);\n\nmy (@weak, @balanced, @strong);\n\nfor 1 ..^ @primes - 1 -> $p {\n    given (@primes[$p - 1] + @primes[$p + 1]) / 2 {\n        when * > @primes[$p] {     @weak.push: @primes[$p] }\n        when * < @primes[$p] {   @strong.push: @primes[$p] }\n        default              { @balanced.push: @primes[$p] }\n    }\n}\n\nfor @strong,   'strong',   36,\n    @weak,     'weak',     37,\n    @balanced, 'balanced', 28\n  -> @pr, $type, $d {\n    say \"\\nFirst $d $type primes:\\n\", @pr[^$d]».&comma;\n    say \"Count of $type primes <=  {comma 1e6}:  \", comma +@pr[^(@pr.first: * > 1e6,:k)];\n    say \"Count of $type primes <= {comma 1e7}: \", comma +@pr;\n}\n\n```\n\nOutput:\n\n```\nFirst 36 strong primes:\n(11 17 29 37 41 59 67 71 79 97 101 107 127 137 149 163 179 191 197 223 227 239 251 269 277 281 307 311 331 347 367 379 397 419 431 439)\nCount of strong primes <=  1,000,000:  37,723\nCount of strong primes <= 10,000,000: 320,991\n\nFirst 37 weak primes:\n(3 7 13 19 23 31 43 47 61 73 83 89 103 109 113 131 139 151 167 181 193 199 229 233 241 271 283 293 313 317 337 349 353 359 383 389 401)\nCount of weak primes <=  1,000,000:  37,780\nCount of weak primes <= 10,000,000: 321,750\n\nFirst 28 balanced primes:\n(5 53 157 173 211 257 263 373 563 593 607 653 733 947 977 1,103 1,123 1,187 1,223 1,367 1,511 1,747 1,753 1,907 2,287 2,417 2,677 2,903)\nCount of balanced primes <=  1,000,000:  2,994\nCount of balanced primes <= 10,000,000: 21,837\n```"}]}
{"messages": [{"role": "user", "content": "A Sturmian word is a binary sequence, finite or infinite, that makes up the cutting sequence for a positive real number x, as shown in the picture.\n\nExample Sturmian word when x = 0.618..., the golden ratio.\n\nThe Sturmian word can be computed thus as an algorithm:\n\n* If \n\n  x\n  >\n  1\n  {\\displaystyle {\\displaystyle x>1}}\n  , then it is the inverse of the Sturmian word for \n\n  1\n\n  /\n  x\n  {\\displaystyle {\\displaystyle 1/x}}\n  . So we have reduced to the case of \n\n  0\n  <\n  x\n  ≤\n  1\n  {\\displaystyle {\\displaystyle 0<x\\leq 1}}\n  .\n* Iterate over \n\n  f\n  l\n  o\n  o\n  r\n  (\n  1\n  x\n  )\n  ,\n  f\n  l\n  o\n  o\n  r\n  (\n  2\n  x\n  )\n  ,\n  f\n  l\n  o\n  o\n  r\n  (\n  3\n  x\n  )\n  ,\n  …\n  {\\displaystyle {\\displaystyle floor(1x),floor(2x),floor(3x),\\dots }}\n* If \n\n  k\n  x\n  {\\displaystyle {\\displaystyle kx}}\n   is an integer, then the program terminates. Else, if \n\n  f\n  l\n  o\n  o\n  r\n  (\n  (\n  k\n  −\n  1\n  )\n  x\n  )\n  =\n  f\n  l\n  o\n  o\n  r\n  (\n  k\n  x\n  )\n  {\\displaystyle {\\displaystyle floor((k-1)x)=floor(kx)}}\n  , then the program outputs 0, else, it outputs 10.\n\nThe problem:\n\n* Given a positive rational number \n\n  m\n  n\n  {\\displaystyle {\\displaystyle {\\frac {m}{n}}}}\n  , specified by two positive integers \n\n  m\n  ,\n  n\n  {\\displaystyle {\\displaystyle m,n}}\n  , output its entire Sturmian word.\n* Given a quadratic real number \n\n  b\n\n\n  a\n  +\n  m\n  n\n  >\n  0\n  {\\displaystyle {\\displaystyle {\\frac {b{\\sqrt {a}}+m}{n}}>0}}\n  , specified by integers \n\n  a\n  ,\n  b\n  ,\n  m\n  ,\n  n\n  {\\displaystyle {\\displaystyle a,b,m,n}}\n  , where \n\n  a\n  {\\displaystyle {\\displaystyle a}}\n   is not a perfect square, output the first \n\n  k\n  {\\displaystyle {\\displaystyle k}}\n   letters of Sturmian words when given a positive number \n\n  k\n  {\\displaystyle {\\displaystyle k}}\n  .\n\n(If the programming language can represent infinite data structures, then that works too.)\n\nA simple check is to do this for the inverse golden ratio \n\n5\n−\n1\n2\n{\\displaystyle {\\displaystyle {\\frac {{\\sqrt {5}}-1}{2}}}}\n, that is, \n\na\n=\n5\n,\nb\n=\n1\n,\nm\n=\n−\n1\n,\nn\n=\n2\n{\\displaystyle {\\displaystyle a=5,b=1,m=-1,n=2}}\n, which would just output the Fibonacci word.\n\nStretch goal: calculate the Sturmian word for other kinds of definable real numbers, such as cubic roots.\n\nThe key difficulty is accurately calculating \n\nf\nl\no\no\nr\n(\nk\n\n\na\n)\n{\\displaystyle {\\displaystyle floor(k{\\sqrt {a}})}}\n for large \n\nk\n{\\displaystyle {\\displaystyle k}}\n. Floating point arithmetic would lose precision. One can either do this simply by directly searching for some integer \n\na\n′\n{\\displaystyle {\\displaystyle a'}}\n such that \n\na\n\n′\n\n2\n≤\n\nk\n\n2\na\n<\n(\n\na\n′\n+\n1\n\n)\n\n2\n{\\displaystyle {\\displaystyle a'^{2}\\leq k^{2}a<(a'+1)^{2}}}\n, or by more trickly methods, such as the continued fraction approach.\n\nFirst calculate the continued fraction convergents to \n\na\n{\\displaystyle {\\displaystyle {\\sqrt {a}}}}\n. Let \n\nm\nn\n{\\displaystyle {\\displaystyle {\\frac {m}{n}}}}\n be a convergent to \n\na\n{\\displaystyle {\\displaystyle {\\sqrt {a}}}}\n, such that \n\nn\n≥\nk\n{\\displaystyle {\\displaystyle n\\geq k}}\n, then since the convergent sequence is the **best rational approximant** for denominators up to that point, we know for sure that, if we write out \n\n0\nk\n,\n\n\n1\nk\n,\n…\n{\\displaystyle {\\displaystyle {\\frac {0}{k}},{\\frac {1}{k}},\\dots }}\n, the sequence would stride right across the gap \n\n(\nm\n\n/\nn\n,\n2\nx\n−\nm\n\n/\nn\n)\n{\\displaystyle {\\displaystyle (m/n,2x-m/n)}}\n. Thus, we can take the largest \n\nl\n{\\displaystyle {\\displaystyle l}}\n such that \n\nl\n\n/\nk\n≤\nm\n\n/\nn\n{\\displaystyle {\\displaystyle l/k\\leq m/n}}\n, and we would know for sure that \n\nl\n=\nf\nl\no\no\nr\n(\nk\n\n\na\n)\n{\\displaystyle {\\displaystyle l=floor(k{\\sqrt {a}})}}\n.\n\nIn summary, \n\nf\nl\no\no\nr\n(\nk\n\n\na\n)\n=\nf\nl\no\no\nr\n(\nm\nk\n\n/\nn\n)\n{\\displaystyle {\\displaystyle floor(k{\\sqrt {a}})=floor(mk/n)}}\n where \n\nm\n\n/\nn\n{\\displaystyle {\\displaystyle m/n}}\n is the first continued fraction approximant to \n\na\n{\\displaystyle {\\displaystyle {\\sqrt {a}}}}\n with a denominator \n\nn\n≥\nk\n{\\displaystyle {\\displaystyle n\\geq k}}"}, {"role": "assistant", "content": "**Translation of**: Julia\n\n```\n# 20240215 Raku programming solution\n\nsub chenfoxlyndonfactorization(Str $s) {\n sub sturmian-word($m, $n) {\n   return sturmian-word($n, $m).trans('0' => '1', '1' => '0') if $m > $n; \n   my ($res, $k, $prev) = '', 1, 0;\n   while ($k * $m) % $n > 0 {\n      my $curr = ($k * $m) div $n;\n      $res ~= $prev == $curr ?? '0' !! '10';\n      $prev = $curr;\n      $k++;\n   }\n   return $res;\n}\n\nsub fib-word($n) {\n   my ($Sn_1, $Sn) = '0', '01';\n   for 2..$n { ($Sn, $Sn_1) = ($Sn~$Sn_1, $Sn) }\n   return $Sn;\n}\n\nmy $fib = fib-word(7);\nmy $sturmian = sturmian-word(13, 21);\nsay \"{$sturmian} <== 13/21\" if $fib.substr(0, $sturmian.chars) eq $sturmian;\n\nsub cfck($a, $b, $m, $n, $k) {\n   my (@p, @q) := [0, 1], [1, 0]; \n   my $r = (sqrt($a) * $b + $m) / $n;\n   for ^$k {\n      my $whole = $r.Int;\n      my ($pn, $qn) = $whole * @p[*-1] + @p[*-2], $whole * @q[*-1] + @q[*-2];\n      @p.push($pn);\n      @q.push($qn);\n      $r = 1/($r - $whole);\n   }\n   return [@p[*-1], @q[*-1]];\n}\n\nmy $cfck-result = cfck(5, 1, -1, 2, 8);\nsay \"{sturmian-word($cfck-result[0], $cfck-result[1])} <== 1/phi (8th convergent golden ratio)\";\n\n```\n\nOutput:\n\nSame as Julia example.\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "A sub-unit square is a square number (product of two identical non-negative integers) that remains a square after having a 1 subtracted from each digit in the square.\n\nE.G.\n\nThe number **1** is a sub-unit square. **1** - **1** is **0**, which is also a square, though it's kind-of a degenerate case.\n\nThe number **3136** is a sub-unit square. **3136** (**56²**) with unit **1** subtracted from each digit is **2025** (**45²**).\n\nA sub-unit square cannot contain a digit zero (**0**) since zero minus one is negative one. Every known sub-unit square, with the exception of **1**, ends with the digits **36**.\n\nTask\n\n* Find and display at least the first five sub-unit squares.\n\nSee also\n\n* OEIS:A061844 - Squares that remain squares if you decrease every digit by 1"}, {"role": "assistant", "content": "First seven take about 5 seconds with this implementation. The eighth would take several hours at least.\n\n```\nmy @upper = 1,|(1 .. *).map((* × 2)²);\nmy @lower = (^∞).map: *²;\nmy \\R = [\\+] 0, 1, 10, 100 … *;\n\nmy $l = 0;\n\n.say for (gather {\n    (^∞).map: -> $u {\n        next if @upper[$u].contains: 0;\n        my $chars = @upper[$u].chars;\n        loop {\n            $l++ and next   if @upper[$u] - @lower[$l]  > R[$chars];\n            take @upper[$u] if @upper[$u] - @lower[$l] == R[$chars];\n            last;\n        }\n    }\n})[^7]\n\n```\n\nOutput:\n\n```\n1\n36\n3136\n24336\n5973136\n71526293136\n318723477136\n```"}]}
{"messages": [{"role": "user", "content": "Subleq is an example of a One-Instruction Set Computer (OISC).\n\nIt is named after its only instruction, which is **SU**btract and **B**ranch if **L**ess than or **EQ**ual to zero.\n\nTask\n\nYour task is to create an interpreter which emulates a SUBLEQ machine.\n\nThe machine's memory consists of an array of signed integers.   These integers may be interpreted in three ways:\n\n:   :   :   :   * simple numeric values\n                * memory addresses\n                * characters for input or output\n\nAny reasonable word size that accommodates all three of the above uses is fine.\n\nThe program should load the initial contents of the emulated machine's memory, set the instruction pointer to the first address (which is defined to be address 0), and begin emulating the machine, which works as follows:\n\n:   1. Let **A** be the value in the memory location identified by the instruction pointer;   let **B** and **C** be the values stored in the next two consecutive addresses in memory.\n    2. Advance the instruction pointer three words, to point at the address *after* the address containing **C**.\n    3. If **A** is **-1** (negative unity), then a character is read from the machine's input and its numeric value stored in the address given by **B**. **C** is unused. (Most implementations adopt the C convention of signaling EOF by storing -1 as the read-in character.)\n    4. If **B** is **-1** (negative unity), then the number contained in the address given by **A** is interpreted as a character and written to the machine's output. **C** is unused.\n    5. Otherwise, both **A** and **B** are treated as addresses. The number contained in address **A** is subtracted from the number in address **B** (and the difference left in address **B**). If the result is positive, execution continues uninterrupted; if the result is zero or negative, the instruction pointer is set to **C**.\n    6. If the instruction pointer becomes negative, execution halts.\n\nYour solution may initialize the emulated machine's memory in any convenient manner, but if you accept it as input, it should be a separate input stream from the one fed to the emulated machine once it is running. And if fed as text input, it should be in the form of raw subleq \"machine code\" - whitespace-separated decimal numbers, with no symbolic names or other assembly-level extensions, to be loaded into memory starting at address   **0**   (zero).\n\nFor purposes of this task, show the output of your solution when fed the below   \"Hello, world!\"   program.\n\nAs written, this example assumes ASCII or a superset of it, such as any of the Latin-N character sets or Unicode;   you may translate the numbers representing characters (starting with 72=ASCII 'H') into another character set if your implementation runs in a non-ASCII-compatible environment. If 0 is not an appropriate terminator in your character set, the program logic will need some adjustment as well.\n\n```\n15 17 -1 17 -1 -1 16 1 -1 16 3 -1 15 15 0 0 -1 72 101 108 108 111 44 32 119 111 114 108 100 33 10 0\n```\n\nThe above \"machine code\" corresponds to something like this in a hypothetical assembler language for a signed 8-bit version of the machine:\n\n```\nstart:\n    0f 11 ff subleq (zero), (message), -1 ; subtract 0 from next character value to print;\n                                          ; terminate if it's <=0\n    11 ff ff subleq (message), -1, -1     ; output character\n    10 01 ff subleq (neg1), (start+1), -1 ; modify above two instructions by subtracting -1 \n    10 03 ff subleq (neg1), (start+3), -1 ;   (adding 1) to their target addresses \n    0f 0f 00 subleq (zero), (zero), start ; if 0-0 <= 0 (i.e. always) goto start\n\n; useful constants\nzero: \n    00      .data 0  \nneg1: \n    ff      .data -1\n; the message to print\nmessage: .data \"Hello, world!\\n\\0\"\n    48 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 0a 00\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nmy @hello-world = \n|<15 17 -1 17 -1 -1 16 1 -1 16 3 -1 15 15 0 0 -1>,\n|\"Hello, world!\\n\\0\".comb.map(*.ord);\n\nsub run-subleq(@memory) {\n  my $ip = 0;\n  while $ip >= 0 && $ip < @memory {\n    my ($a, $b, $c) = @memory[$ip..*];\n    $ip += 3;\n    if $a < 0 {\n      @memory[$b] = getc.ord;\n    } elsif $b < 0 {\n      print @memory[$a].chr;\n    } else {\n      if (@memory[$b] -= @memory[$a]) <= 0 {\n        $ip = $c;\n      } \n    }\n  }\n}\n\nrun-subleq @hello-world;\n\n```\n\nOutput:\n\n```\nHello, world!\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a function/procedure/method/subroutine that takes a set/array/list/stream/table/collection of words with integer weights, and identifies a non-empty subset of them whose weights sum to zero (cf. the Dropbox Diet candidate screening exercise and the Subset sum problem Wikipedia article).\n\nFor example\n\nThis set of weighted words, one solution would be the set of words:\n\n:   :   :   * {elysee,   efferent,   deploy,   departure,   centipede,   bonnet,   balm,   archbishop}\n\nbecause their respective weights of:\n\n:   :   :   * -326,   54,   44,   952,   -658,   452,   397,   and   -915\n\nsum to zero.\n\n:   :   :   :   :   :   Table of weighted words\n\n                        | word | weight |\n                        | --- | --- |\n                        | alliance | -624 |\n                        | archbishop | -915 |\n                        | balm | 397 |\n                        | bonnet | 452 |\n                        | brute | 870 |\n                        | centipede | -658 |\n                        | cobol | 362 |\n                        | covariate | 590 |\n                        | departure | 952 |\n                        | deploy | 44 |\n                        | diophantine | 645 |\n                        | efferent | 54 |\n                        | elysee | -326 |\n                        | eradicate | 376 |\n                        | escritoire | 856 |\n                        | exorcism | -983 |\n                        | fiat | 170 |\n                        | filmy | -874 |\n                        | flatworm | 503 |\n                        | gestapo | 915 |\n                        | infra | -847 |\n                        | isis | -982 |\n                        | lindholm | 999 |\n                        | markham | 475 |\n                        | mincemeat | -880 |\n                        | moresby | 756 |\n                        | mycenae | 183 |\n                        | plugging | -266 |\n                        | smokescreen | 423 |\n                        | speakeasy | -745 |\n                        | vein | 813 |\n\nAnother solution would be the set of words {flatworm, gestapo, infra, isis, lindholm, plugging, smokescreen, speakeasy}, because their respective weights of 503, 915, -847, -982, 999, -266, 423, and -745 also sum to zero.\n\nYou may assume the weights range from -1000 to 1000.\n\nIf there are multiple solutions, only one needs to be found.\n\nUse any algorithm you want and demonstrate it on a set of at least 30 weighted words with the results shown in a human readable form.\n\nNote that an implementation that depends on enumerating all possible subsets is likely to be infeasible."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @pairs =\n    alliance => -624, archbishop => -915, balm => 397, bonnet => 452,\n    brute => 870, centipede => -658, cobol => 362, covariate => 590,\n    departure => 952, deploy => 44, diophantine => 645, efferent => 54,\n    elysee => -326, eradicate => 376, escritoire => 856, exorcism => -983,\n    fiat => 170, filmy => -874, flatworm => 503, gestapo => 915,\n    infra => -847, isis => -982, lindholm => 999, markham => 475,\n    mincemeat => -880, moresby => 756, mycenae => 183, plugging => -266,\n    smokescreen => 423, speakeasy => -745, vein => 813;\nmy @weights = @pairs».value;\nmy %name = @pairs.hash.invert;\n\n.say for (1..27).hyper(:3batch).map: -> $n {\n    given @weights.combinations($n).first({ 0 == [+] @^comb }) {\n        when .so { \"Length $n: ({.map: {%name{$_}}})\" }\n        default  { \"Length $n: (none)\" }\n    }\n}\n\n```\n\nOutput:\n\n```\nLength 1: (none)\nLength 2: (archbishop gestapo)\nLength 3: (centipede markham mycenae)\nLength 4: (alliance balm deploy mycenae)\nLength 5: (alliance brute covariate deploy mincemeat)\nLength 6: (alliance archbishop balm deploy gestapo mycenae)\nLength 7: (alliance archbishop bonnet cobol departure exorcism moresby)\nLength 8: (alliance archbishop balm bonnet fiat flatworm isis lindholm)\nLength 9: (alliance archbishop balm bonnet brute covariate eradicate mincemeat plugging)\nLength 10: (alliance archbishop balm bonnet brute centipede cobol departure deploy mincemeat)\nLength 11: (alliance archbishop balm bonnet brute centipede cobol departure infra moresby speakeasy)\nLength 12: (alliance archbishop balm bonnet brute centipede cobol covariate diophantine efferent elysee infra)\nLength 13: (alliance archbishop balm bonnet brute centipede cobol covariate departure efferent eradicate filmy isis)\nLength 14: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy elysee filmy markham speakeasy)\nLength 15: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy elysee exorcism flatworm infra mycenae)\nLength 16: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy diophantine elysee exorcism filmy gestapo infra)\nLength 17: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy diophantine exorcism isis mincemeat mycenae plugging vein)\nLength 18: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy diophantine efferent elysee exorcism filmy isis mycenae vein)\nLength 19: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy diophantine efferent elysee eradicate exorcism fiat infra isis smokescreen)\nLength 20: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy diophantine efferent elysee eradicate exorcism gestapo infra isis smokescreen speakeasy)\nLength 21: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy diophantine efferent elysee eradicate exorcism flatworm infra lindholm mincemeat plugging speakeasy)\nLength 22: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy diophantine efferent elysee eradicate escritoire exorcism fiat filmy flatworm mincemeat plugging speakeasy)\nLength 23: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy diophantine efferent elysee eradicate escritoire exorcism infra isis mincemeat moresby mycenae smokescreen speakeasy)\nLength 24: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy diophantine efferent elysee exorcism filmy gestapo infra markham mincemeat moresby mycenae plugging smokescreen speakeasy)\nLength 25: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy diophantine eradicate exorcism fiat filmy flatworm infra isis lindholm markham mincemeat moresby mycenae plugging speakeasy)\nLength 26: (alliance archbishop balm bonnet brute centipede cobol covariate departure deploy diophantine elysee eradicate escritoire exorcism fiat filmy gestapo infra isis markham mincemeat mycenae plugging speakeasy vein)\nLength 27: (alliance archbishop balm bonnet brute centipede covariate departure deploy efferent elysee eradicate escritoire exorcism fiat filmy flatworm infra isis lindholm markham mincemeat moresby mycenae plugging smokescreen speakeasy)\n```"}]}
{"messages": [{"role": "user", "content": "Substitution Cipher Implementation - File Encryption/Decryption\n\nTask\n\nEncrypt an input/source file by replacing every upper/lower case alphabets of the source file with another predetermined upper/lower case alphabets or symbols and save it into another output/encrypted file and then again convert that output/encrypted file into original/decrypted file.\n\nThis type of Encryption/Decryption scheme is often called a Substitution Cipher.\n\nRelated tasks\n\n* Caesar cipher\n* Rot-13\n* Vigenère Cipher/Cryptanalysis\n\nSee also\n\n* Wikipedia: Substitution cipher"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2015-11-20\n\nFeed it an action (encode, decode) and a file name at the command line and it will spit out the (en|de)coded file to STDOUT. Redirect into a file to save it. If no parameters are passed in, does the demo encode/decode.\n\n```\nmy $chr = (' ' .. '}').join('');\nmy $key = $chr.comb.pick(*).join('');\n\n# Be very boring and use the same key every time to fit task reqs.\n$key = q☃3#}^\",dLs*>tPMcZR!fmC rEKhlw1v4AOgj7Q]YI+|pDB82a&XFV9yzuH<WT%N;iS.0e:`G\\n['6@_{bk)=-5qx(/?$JoU☃;\n\nsub MAIN ($action = 'encode', $file = '') {\n\n    die 'Only options are encode or decode.' unless $action ~~ any 'encode'|'decode';\n\n    my $text = qq:to/END/;\n        Here we have to do is there will be a input/source file in which \n        we are going to Encrypt the file by replacing every upper/lower \n        case alphabets of the source file with another predetermined \n        upper/lower case alphabets or symbols and save it into another \n        output/encrypted file and then again convert that output/encrypted \n        file into original/decrypted file. This type of Encryption/Decryption\n        scheme is often called a Substitution Cipher.\n        END\n\n    $text = $file.IO.slurp if $file;\n\n    say \"Key = $key\\n\";\n\n    if $file {\n        say &::($action)($text);\n    } else {\n        my $encoded;\n        say \"Encoded text: \\n {$encoded = encode $text}\";\n        say \"Decoded text: \\n {decode $encoded}\";\n    }\n}\n\nsub encode ($text) { $text.trans($chr => $key) }\n\nsub decode ($text) { $text.trans($key => $chr) }\n\n```\n\nOutput:\n\nwith no passed parameters\n\n```\nKey = 3#}^\",dLs*>tPMcZR!fmC rEKhlw1v4AOgj7Q]YI+|pDB82a&XFV9yzuH<WT%N;iS.0e:`G\\n['6@_{bk)=-5qx(/?$JoU\n\nEncoded text: \n +`=`3(`3n.x`35b3:b3[-35n`=`3([@@30`3.3[{kq5Z-bq=e`3G[@`3[{3(n[en3\n(`3.=`3\\b[{\\35b3]{e=?k535n`3G[@`30?3=`k@.e[{\\3`x`=?3qkk`=Z@b(`=3\ne.-`3.@kn.0`5-3bG35n`3-bq=e`3G[@`3([5n3.{b5n`=3k=`:`5`=_[{`:3\nqkk`=Z@b(`=3e.-`3.@kn.0`5-3b=3-?_0b@-3.{:3-.x`3[53[{5b3.{b5n`=3\nbq5kq5Z`{e=?k5`:3G[@`3.{:35n`{3.\\.[{3eb{x`=535n.53bq5kq5Z`{e=?k5`:3\nG[@`3[{5b3b=[\\[{.@Z:`e=?k5`:3G[@`c39n[-35?k`3bG3]{e=?k5[b{ZQ`e=?k5[b{\n-en`_`3[-3bG5`{3e.@@`:3.3Vq0-5[5q5[b{37[kn`=c\n\nDecoded text: \n Here we have to do is there will be a input/source file in which \nwe are going to Encrypt the file by replacing every upper/lower \ncase alphabets of the source file with another predetermined \nupper/lower case alphabets or symbols and save it into another \noutput/encrypted file and then again convert that output/encrypted \nfile into original/decrypted file. This type of Encryption/Decryption\nscheme is often called a Substitution Cipher.\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay a substring:\n\n:   * starting from   **n**   characters in and of   **m**   length;\n    * starting from   **n**   characters in,   up to the end of the string;\n    * whole string minus the last character;\n    * starting from a known   character   within the string and of   **m**   length;\n    * starting from a known   substring   within the string and of   **m**   length.\n\nIf the program uses UTF-8 or UTF-16,   it must work on any valid Unicode code point,\nwhether in the   Basic Multilingual Plane   or above it.\n\nThe program must reference logical characters (code points),   not 8-bit code units for UTF-8 or 16-bit code units for UTF-16.\n\nPrograms for other encodings (such as 8-bit ASCII, or EUC-JP) are not required to handle all Unicode characters.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $str = 'abcdefgh';\nmy $n = 2;\nmy $m = 3;\nsay $str.substr($n, $m);\nsay $str.substr($n);\nsay $str.substr(0, *-1);\nsay $str.substr($str.index('d'), $m);\nsay $str.substr($str.index('de'), $m);\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind all primes in which all substrings (in base ten) are also primes.\n\nThis *can* be achieved by filtering all primes below 500 (there are 95 of them), but there *are* better ways.\n\nAdvanced\n\nSolve by testing at most 15 numbers for primality. Show a list of all numbers tested that were not prime."}, {"role": "assistant", "content": "```\nmy @p = (^10).grep: *.is-prime;\n\nsay gather while @p {\n    .take for @p;\n\n    @p = ( @p X~ <3 7> ).grep: { .is-prime and .substr(*-2,2).is-prime }\n}\n\n```\n\nOutput:\n\n```\n(2 3 5 7 23 37 53 73 373)\n```\n\n### Stretch Goal\n\n```\nmy $prime-tests = 0;\nmy @non-primes;\nsub spy-prime ($n) {\n    $prime-tests++;\n    my $is-p = $n.is-prime;\n\n    push @non-primes, $n unless $is-p;\n    return $is-p;\n}\n\nmy @p = <2 3 5 7>;\n\nsay gather while @p {\n    .take for @p;\n\n    @p = ( @p X~ <3 7> ).grep: { !.ends-with(33|77) and .&spy-prime };\n}\n.say for :$prime-tests, :@non-primes;\n\n```\n\nOutput:\n\n```\n(2 3 5 7 23 37 53 73 373)\nprime-tests => 11\nnon-primes => [27 57 237 537 737 3737]\n```"}]}
{"messages": [{"role": "user", "content": "The task is to demonstrate how to remove the first and last characters from a string.\n\nThe solution should demonstrate how to obtain the following results:\n\n* String with first character removed\n* String with last character removed\n* String with both the first and last characters removed\n\nIf the program uses UTF-8 or UTF-16, it must work on any valid Unicode code point, whether in the Basic Multilingual Plane or above it.\n\nThe program must reference logical characters (code points), not 8-bit code units for UTF-8 or 16-bit code units for UTF-16.\n\nPrograms for other encodings (such as 8-bit ASCII, or EUC-JP) are not required to handle all Unicode characters.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku provides both functional and method forms of substr. Note that, unlike in Perl 5, offsets from the end do not use negative numbers, but instead require a function expressing the negative offset relative to the length parameter, which is supplied by the operator. The form \\*-1 is just a simple way to write such a function.\n\nWe use musical sharps and flats to illustrate that Raku is comfortable with characters from any Unicode plane.\n\n```\nmy $s = '𝄪♯♮♭𝄫';\n\nprint qq:to/END/;\n    Original:\n    $s\n\n    Remove first character:\n    { substr($s, 1) }\n    { $s.substr(1) }\n\n    Remove last character:\n    { substr($s, 0, *-1) }\n    { $s.substr( 0, *-1) }\n    { $s.chop }\n\n    Remove first and last characters:\n    { substr($s, 1, *-1) }\n    { $s.substr(1, *-1) }\n    END\n\n```\n\nOutput:\n\n```\nOriginal:\n𝄪♯♮♭𝄫\n\nRemove first character:\n♯♮♭𝄫\n♯♮♭𝄫\n \nRemove last character:\n𝄪♯♮♭\n𝄪♯♮♭\n𝄪♯♮♭\n \nRemove first and last characters:\n♯♮♭\n♯♮♭\n```"}]}
{"messages": [{"role": "user", "content": "A *subtractive generator* calculates a sequence of random numbers, where each number is congruent to the subtraction of two previous numbers from the sequence.   \nThe formula is\n\n* r\n\n  n\n  =\n\n  r\n\n  (\n  n\n  −\n  i\n  )\n  −\n\n  r\n\n  (\n  n\n  −\n  j\n  )\n\n\n  (\n  mod\n\n  m\n  )\n  {\\displaystyle {\\displaystyle r\\_{n}=r\\_{(n-i)}-r\\_{(n-j)}{\\pmod {m}}}}\n\nfor some fixed values of \n\ni\n{\\displaystyle {\\displaystyle i}}\n, \n\nj\n{\\displaystyle {\\displaystyle j}}\n and \n\nm\n{\\displaystyle {\\displaystyle m}}\n, all positive integers. Supposing that \n\ni\n>\nj\n{\\displaystyle {\\displaystyle i>j}}\n, then the state of this generator is the list of the previous numbers from \n\nr\n\nn\n−\ni\n{\\displaystyle {\\displaystyle r\\_{n-i}}}\n to \n\nr\n\nn\n−\n1\n{\\displaystyle {\\displaystyle r\\_{n-1}}}\n. Many states generate uniform random integers from \n\n0\n{\\displaystyle {\\displaystyle 0}}\n to \n\nm\n−\n1\n{\\displaystyle {\\displaystyle m-1}}\n, but some states are bad. A state, filled with zeros, generates only zeros. If \n\nm\n{\\displaystyle {\\displaystyle m}}\n is even, then a state, filled with even numbers, generates only even numbers. More generally, if \n\nf\n{\\displaystyle {\\displaystyle f}}\n is a factor of \n\nm\n{\\displaystyle {\\displaystyle m}}\n, then a state, filled with multiples of \n\nf\n{\\displaystyle {\\displaystyle f}}\n, generates only multiples of \n\nf\n{\\displaystyle {\\displaystyle f}}\n.\n\nAll subtractive generators have some weaknesses. The formula correlates \n\nr\n\nn\n{\\displaystyle {\\displaystyle r\\_{n}}}\n, \n\nr\n\n(\nn\n−\ni\n)\n{\\displaystyle {\\displaystyle r\\_{(n-i)}}}\n and \n\nr\n\n(\nn\n−\nj\n)\n{\\displaystyle {\\displaystyle r\\_{(n-j)}}}\n; these three numbers are not independent, as true random numbers would be. Anyone who observes \n\ni\n{\\displaystyle {\\displaystyle i}}\n consecutive numbers can predict the next numbers, so the generator is not cryptographically secure. The authors of *Freeciv* (utility/rand.c) and *xpat2* (src/testit2.c) knew another problem: the low bits are less random than the high bits.\n\nThe subtractive generator has a better reputation than the linear congruential generator, perhaps because it holds more state. A subtractive generator might never multiply numbers: this helps where multiplication is slow. A subtractive generator might also avoid division: the value of \n\nr\n\n(\nn\n−\ni\n)\n−\n\nr\n\n(\nn\n−\nj\n)\n{\\displaystyle {\\displaystyle r\\_{(n-i)}-r\\_{(n-j)}}}\n is always between \n\n−\nm\n{\\displaystyle {\\displaystyle -m}}\n and \n\nm\n{\\displaystyle {\\displaystyle m}}\n, so a program only needs to add \n\nm\n{\\displaystyle {\\displaystyle m}}\n to negative numbers.\n\nThe choice of \n\ni\n{\\displaystyle {\\displaystyle i}}\n and \n\nj\n{\\displaystyle {\\displaystyle j}}\n affects the period of the generator. A popular choice is \n\ni\n=\n55\n{\\displaystyle {\\displaystyle i=55}}\n and \n\nj\n=\n24\n{\\displaystyle {\\displaystyle j=24}}\n, so the formula is\n\n* r\n\n  n\n  =\n\n  r\n\n  (\n  n\n  −\n  55\n  )\n  −\n\n  r\n\n  (\n  n\n  −\n  24\n  )\n\n\n  (\n  mod\n\n  m\n  )\n  {\\displaystyle {\\displaystyle r\\_{n}=r\\_{(n-55)}-r\\_{(n-24)}{\\pmod {m}}}}\n\nThe subtractive generator from *xpat2* uses\n\n* r\n\n  n\n  =\n\n  r\n\n  (\n  n\n  −\n  55\n  )\n  −\n\n  r\n\n  (\n  n\n  −\n  24\n  )\n\n\n  (\n  mod\n\n\n  10\n\n  9\n  )\n  {\\displaystyle {\\displaystyle r\\_{n}=r\\_{(n-55)}-r\\_{(n-24)}{\\pmod {10^{9}}}}}\n\nThe implementation is by J. Bentley and comes from program\\_tools/universal.c of the DIMACS (netflow) archive at Rutgers University. It credits Knuth, TAOCP, Volume 2, Section 3.2.2 (Algorithm A).\n\nBentley uses this clever algorithm to seed the generator.\n\n1. Start with a single \n\n   s\n   e\n   e\n   d\n   {\\displaystyle {\\displaystyle seed}}\n    in range \n\n   0\n   {\\displaystyle {\\displaystyle 0}}\n    to \n\n   10\n\n   9\n   −\n   1\n   {\\displaystyle {\\displaystyle 10^{9}-1}}\n   .\n2. Set \n\n   s\n\n   0\n   =\n   s\n   e\n   e\n   d\n   {\\displaystyle {\\displaystyle s\\_{0}=seed}}\n    and \n\n   s\n\n   1\n   =\n   1\n   {\\displaystyle {\\displaystyle s\\_{1}=1}}\n   . The inclusion of \n\n   s\n\n   1\n   =\n   1\n   {\\displaystyle {\\displaystyle s\\_{1}=1}}\n    avoids some bad states (like all zeros, or all multiples of 10).\n3. Compute \n\n   s\n\n   2\n   ,\n\n   s\n\n   3\n   ,\n   .\n   .\n   .\n   ,\n\n   s\n\n   54\n   {\\displaystyle {\\displaystyle s\\_{2},s\\_{3},...,s\\_{54}}}\n    using the subtractive formula \n\n   s\n\n   n\n   =\n\n   s\n\n   (\n   n\n   −\n   2\n   )\n   −\n\n   s\n\n   (\n   n\n   −\n   1\n   )\n\n\n   (\n   mod\n\n\n   10\n\n   9\n   )\n   {\\displaystyle {\\displaystyle s\\_{n}=s\\_{(n-2)}-s\\_{(n-1)}{\\pmod {10^{9}}}}}\n   .\n4. Reorder these 55 values so \n\n   r\n\n   0\n   =\n\n   s\n\n   34\n   {\\displaystyle {\\displaystyle r\\_{0}=s\\_{34}}}\n   , \n\n   r\n\n   1\n   =\n\n   s\n\n   13\n   {\\displaystyle {\\displaystyle r\\_{1}=s\\_{13}}}\n   , \n\n   r\n\n   2\n   =\n\n   s\n\n   47\n   {\\displaystyle {\\displaystyle r\\_{2}=s\\_{47}}}\n   , ..., \n\n   r\n\n   n\n   =\n\n   s\n\n   (\n   34\n   ∗\n   (\n   n\n   +\n   1\n   )\n\n\n   (\n   mod\n\n   55\n   )\n   )\n   {\\displaystyle {\\displaystyle r\\_{n}=s\\_{(34\\*(n+1){\\pmod {55}})}}}\n   .\n   * This is the same order as \n\n     s\n\n     0\n     =\n\n     r\n\n     54\n     {\\displaystyle {\\displaystyle s\\_{0}=r\\_{54}}}\n     , \n\n     s\n\n     1\n     =\n\n     r\n\n     33\n     {\\displaystyle {\\displaystyle s\\_{1}=r\\_{33}}}\n     , \n\n     s\n\n     2\n     =\n\n     r\n\n     12\n     {\\displaystyle {\\displaystyle s\\_{2}=r\\_{12}}}\n     , ..., \n\n     s\n\n     n\n     =\n\n     r\n\n     (\n     (\n     34\n     ∗\n     n\n     )\n     −\n     1\n\n\n     (\n     mod\n\n     55\n     )\n     )\n     {\\displaystyle {\\displaystyle s\\_{n}=r\\_{((34\\*n)-1{\\pmod {55}})}}}\n     .\n   * This rearrangement exploits how 34 and 55 are relatively prime.\n5. Compute the next 165 values \n\n   r\n\n   55\n   {\\displaystyle {\\displaystyle r\\_{55}}}\n    to \n\n   r\n\n   219\n   {\\displaystyle {\\displaystyle r\\_{219}}}\n   . Store the last 55 values.\n\nThis generator yields the sequence \n\nr\n\n220\n{\\displaystyle {\\displaystyle r\\_{220}}}\n, \n\nr\n\n221\n{\\displaystyle {\\displaystyle r\\_{221}}}\n, \n\nr\n\n222\n{\\displaystyle {\\displaystyle r\\_{222}}}\n and so on. For example, if the seed is 292929, then the sequence begins with \n\nr\n\n220\n=\n467478574\n{\\displaystyle {\\displaystyle r\\_{220}=467478574}}\n, \n\nr\n\n221\n=\n512932792\n{\\displaystyle {\\displaystyle r\\_{221}=512932792}}\n, \n\nr\n\n222\n=\n539453717\n{\\displaystyle {\\displaystyle r\\_{222}=539453717}}\n. By starting at \n\nr\n\n220\n{\\displaystyle {\\displaystyle r\\_{220}}}\n, this generator avoids a bias from the first numbers of the sequence. This generator must store the last 55 numbers of the sequence, so to compute the next \n\nr\n\nn\n{\\displaystyle {\\displaystyle r\\_{n}}}\n. Any array or list would work; a ring buffer is ideal but not necessary.\n\nImplement a subtractive generator that replicates the sequences from *xpat2*."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n**Works with**: Rakudo version 2018.03\n\n```\nsub bentley-clever($seed) {\n    constant $mod = 1_000_000_000;\n    my @seeds = ($seed % $mod, 1, (* - *) % $mod ... *)[^55];\n    my @state = @seeds[ 34, (* + 34 ) % 55 ... 0 ];\n\n    sub subrand() {\n        push @state, (my $x = (@state.shift - @state[*-24]) % $mod);\n        $x;\n    }\n\n    subrand for 55 .. 219;\n\n    &subrand ... *;\n}\n\nmy @sr = bentley-clever(292929);\n.say for @sr[^10];\n\n```\n\nHere we just make the seeder return the random sequence as a lazy list.\n\nOutput:\n\n```\n467478574\n512932792\n539453717\n20349702\n615542081\n378707948\n933204586\n824858649\n506003769\n380969305\n```"}]}
{"messages": [{"role": "user", "content": "The series of increasing prime numbers begins: `2, 3, 5, 7, 11, 13, 17, 19, 23, 29, ...`\n\nThe task applies a filter to the series returning groups of *successive* primes, (s'primes), that differ from the next by a given value or values.\n\n**Example 1:** Specifying that the difference between s'primes be `2` leads to the groups:\n\n:   `(3, 5), (5, 7), (11, 13), (17, 19), (29, 31), ...`\n\n(Known as Twin primes or Prime pairs)\n\n**Example 2:** Specifying more than one difference *between* s'primes leads to groups of size one greater than the number of differences. Differences of `2, 4` leads to the groups:\n\n:   `(5, 7, 11), (11, 13, 17), (17, 19, 23), (41, 43, 47), ...`.\n\nIn the first group 7 is two more than 5 and 11 is four more than 7; as well as 5, 7, and 11 being *successive* primes.\nDifferences are checked in the order of the values given, (differences of `4, 2` would give different groups entirely).\n\nTask\n\n* In each case use a list of primes less than 1\\_000\\_000\n* For the following Differences show the first and last group, as well as the number of groups found:\n\n:   1. Differences of `2`.\n    2. Differences of `1`.\n    3. Differences of `2, 2`.\n    4. Differences of `2, 4`.\n    5. Differences of `4, 2`.\n    6. Differences of `6, 4, 2`.\n\n* Show output here.\n\nNote: Generation of a list of primes is a secondary aspect of the task. Use of a built in function, well known library, or importing/use of prime generators from other Rosetta Code tasks is encouraged.\n\nreferences\n:   1. https://pdfs.semanticscholar.org/78a1/7349819304863ae061df88dbcb26b4908f03.pdf\n    2. https://www.primepuzzles.net/puzzles/puzz\\_011.htm\n    3. https://matheplanet.de/matheplanet/nuke/html/viewtopic.php?topic=232720&start=0"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Categorized by Successive\n\n**Works with**: Rakudo version 2019.03\n\nEssentially the code from the Sexy primes task with minor tweaks.\n\n```\nuse Math::Primesieve;\nmy $sieve = Math::Primesieve.new;\n\nmy $max = 1_000_000;\nmy @primes = $sieve.primes($max);\nmy $filter = @primes.Set;\nmy $primes = @primes.categorize: &successive;\n\nsub successive ($i) {\n    gather {\n        take '2' if $filter{$i + 2};\n        take '1' if $filter{$i + 1};\n        take '2_2' if all($filter{$i «+« (2,4)});\n        take '2_4' if all($filter{$i «+« (2,6)});\n        take '4_2' if all($filter{$i «+« (4,6)});\n        take '6_4_2' if all($filter{$i «+« (6,10,12)}) and\n            none($filter{$i «+« (2,4,8)});\n    }\n}\n\nsub comma { $^i.flip.comb(3).join(',').flip }\n\nfor (2,), (1,), (2,2), (2,4), (4,2), (6,4,2) -> $succ {\n    say \"## Sets of {1+$succ} successive primes <= { comma $max } with \" ~\n        \"successive differences of { $succ.join: ', ' }\";\n    my $i = $succ.join: '_';\n    for 'First', 0, ' Last', * - 1 -> $where, $ind {\n        say \"$where group: \", join ', ', [\\+] flat $primes{$i}[$ind], |$succ\n    }\n    say '      Count: ', +$primes{$i}, \"\\n\";\n}\n\n```\n\nOutput:\n\n```\n## Sets of 2 successive primes <= 1,000,000 with successive differences of 2\nFirst group: 3, 5\n Last group: 999959, 999961\n      Count: 8169\n\n## Sets of 2 successive primes <= 1,000,000 with successive differences of 1\nFirst group: 2, 3\n Last group: 2, 3\n      Count: 1\n\n## Sets of 3 successive primes <= 1,000,000 with successive differences of 2, 2\nFirst group: 3, 5, 7\n Last group: 3, 5, 7\n      Count: 1\n\n## Sets of 3 successive primes <= 1,000,000 with successive differences of 2, 4\nFirst group: 5, 7, 11\n Last group: 999431, 999433, 999437\n      Count: 1393\n\n## Sets of 3 successive primes <= 1,000,000 with successive differences of 4, 2\nFirst group: 7, 11, 13\n Last group: 997807, 997811, 997813\n      Count: 1444\n\n## Sets of 4 successive primes <= 1,000,000 with successive differences of 6, 4, 2\nFirst group: 31, 37, 41, 43\n Last group: 997141, 997147, 997151, 997153\n      Count: 306\n\n```\n\n### Precomputed Differences\n\n**Works with**: Rakudo version 2019.03\n\n```\nuse Math::Primesieve;\n\nconstant $max    = 1_000_000;\nconstant @primes = Math::Primesieve.primes($max);\nconstant @diffs  = @primes.skip Z- @primes;\n\nsay \"Given all ordered primes <= $max, sets with successive differences of:\";\nfor (2,), (1,), (2,2), (2,4), (4,2), (6,4,2) -> @succ {\n    my $size = @succ.elems;\n\n    my @group_start_offsets = @diffs.rotor( $size => 1-$size )\n                                    .grep(:k, { $_ eqv @succ });\n\n    my ($first, $last) = @group_start_offsets[0, *-1]\n                         .map: { @primes.skip($_).head($size + 1) };\n\n    say sprintf '%10s has %5d sets: %15s … %s',\n        @succ.gist, @group_start_offsets.elems, $first, $last;\n}\n\n```\n\nOutput:\n\n```\nGiven all ordered primes <= 1000000, sets with successive differences of:\n       (2) has  8169 sets:             3 5 … 999959 999961\n       (1) has     1 sets:             2 3 … 2 3\n     (2 2) has     1 sets:           3 5 7 … 3 5 7\n     (2 4) has  1393 sets:          5 7 11 … 999431 999433 999437\n     (4 2) has  1444 sets:         7 11 13 … 997807 997811 997813\n   (6 4 2) has   306 sets:     31 37 41 43 … 997141 997147 997151 997153\n```"}]}
{"messages": [{"role": "user", "content": "The **Sudan function** is a classic example of a recursive function, notable especially because it is not a primitive recursive function. This is also true of the better-known Ackermann function. The Sudan function was the first function having this property to be published.\n\nThe Sudan function is usually defined as follows (svg):\n\nF\n\n0\n(\nx\n,\ny\n)\n\n=\nx\n+\ny\n\nF\n\nn\n+\n1\n(\nx\n,\n0\n)\n\n=\nx\n\n\nif \nn\n≥\n0\n\nF\n\nn\n+\n1\n(\nx\n,\ny\n+\n1\n)\n\n=\n\nF\n\nn\n(\n\nF\n\nn\n+\n1\n(\nx\n,\ny\n)\n,\n\nF\n\nn\n+\n1\n(\nx\n,\ny\n)\n+\ny\n+\n1\n)\n\n\nif \nn\n≥\n0\n{\\displaystyle {\\displaystyle {\\begin{array}{lll}F\\_{0}(x,y)&=x+y\\\\F\\_{n+1}(x,0)&=x&{\\text{if }}n\\geq 0\\\\F\\_{n+1}(x,y+1)&=F\\_{n}(F\\_{n+1}(x,y),F\\_{n+1}(x,y)+y+1)&{\\text{if }}n\\geq 0\\\\\\end{array}}}}\n\nTask\n\nWrite a function which returns the value of F(x, y)."}, {"role": "assistant", "content": "Outputting wiki-tables to more closely emulate the wikipedia examples. Not very efficient but good enough.\n\n```\nmulti F (0, $x, $y) { $x + $y }\nmulti F ($n where * > 0, $x, 0) { $x }\nmulti F ($n, $x, $y) { F($n-1, F($n, $x, $y-1), F($n, $x, $y-1) + $y) }\n\n# Testing\nfor 0, 6, 1, 15 -> $f, $g {\n    my @range = ^$g;\n    say \"\\{|class=\\\"wikitable\\\"\\n\", \"|+ F\\<sub>$f\\</sub> (x,y)\\n\" ~ '!x\\y!!', join '!!', @range;\n    -> $r { say \"|-\\n\" ~ '|' ~ join '||', $r, @range.map:{ F($f, $r, $_) } } for @range;\n    say( \"|}\" );\n}\n\n```\n\nOutput:\n\nF0 (x,y)\n\n| x\\y | 0 | 1 | 2 | 3 | 4 | 5 |\n| --- | --- | --- | --- | --- | --- | --- |\n| 0 | 0 | 1 | 2 | 3 | 4 | 5 |\n| 1 | 1 | 2 | 3 | 4 | 5 | 6 |\n| 2 | 2 | 3 | 4 | 5 | 6 | 7 |\n| 3 | 3 | 4 | 5 | 6 | 7 | 8 |\n| 4 | 4 | 5 | 6 | 7 | 8 | 9 |\n| 5 | 5 | 6 | 7 | 8 | 9 | 10 |\n\nF1 (x,y)\n\n| x\\y | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| 0 | 0 | 1 | 4 | 11 | 26 | 57 | 120 | 247 | 502 | 1013 | 2036 | 4083 | 8178 | 16369 | 32752 |\n| 1 | 1 | 3 | 8 | 19 | 42 | 89 | 184 | 375 | 758 | 1525 | 3060 | 6131 | 12274 | 24561 | 49136 |\n| 2 | 2 | 5 | 12 | 27 | 58 | 121 | 248 | 503 | 1014 | 2037 | 4084 | 8179 | 16370 | 32753 | 65520 |\n| 3 | 3 | 7 | 16 | 35 | 74 | 153 | 312 | 631 | 1270 | 2549 | 5108 | 10227 | 20466 | 40945 | 81904 |\n| 4 | 4 | 9 | 20 | 43 | 90 | 185 | 376 | 759 | 1526 | 3061 | 6132 | 12275 | 24562 | 49137 | 98288 |\n| 5 | 5 | 11 | 24 | 51 | 106 | 217 | 440 | 887 | 1782 | 3573 | 7156 | 14323 | 28658 | 57329 | 114672 |\n| 6 | 6 | 13 | 28 | 59 | 122 | 249 | 504 | 1015 | 2038 | 4085 | 8180 | 16371 | 32754 | 65521 | 131056 |\n| 7 | 7 | 15 | 32 | 67 | 138 | 281 | 568 | 1143 | 2294 | 4597 | 9204 | 18419 | 36850 | 73713 | 147440 |\n| 8 | 8 | 17 | 36 | 75 | 154 | 313 | 632 | 1271 | 2550 | 5109 | 10228 | 20467 | 40946 | 81905 | 163824 |\n| 9 | 9 | 19 | 40 | 83 | 170 | 345 | 696 | 1399 | 2806 | 5621 | 11252 | 22515 | 45042 | 90097 | 180208 |\n| 10 | 10 | 21 | 44 | 91 | 186 | 377 | 760 | 1527 | 3062 | 6133 | 12276 | 24563 | 49138 | 98289 | 196592 |\n| 11 | 11 | 23 | 48 | 99 | 202 | 409 | 824 | 1655 | 3318 | 6645 | 13300 | 26611 | 53234 | 106481 | 212976 |\n| 12 | 12 | 25 | 52 | 107 | 218 | 441 | 888 | 1783 | 3574 | 7157 | 14324 | 28659 | 57330 | 114673 | 229360 |\n| 13 | 13 | 27 | 56 | 115 | 234 | 473 | 952 | 1911 | 3830 | 7669 | 15348 | 30707 | 61426 | 122865 | 245744 |\n| 14 | 14 | 29 | 60 | 123 | 250 | 505 | 1016 | 2039 | 4086 | 8181 | 16372 | 32755 | 65522 | 131057 | 262128 |"}]}
{"messages": [{"role": "user", "content": "Task\n\nSolve a partially filled-in normal   9x9   Sudoku grid   and display the result in a human-readable format.\n\nreferences\n\n* Algorithmics of Sudoku   may help implement this.\n* Python Sudoku Solver Computerphile video."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Brute Force\n\n**Translation of**: Perl\n\n```\nmy @A = <\n    5 3 0  0 2 4  7 0 0 \n    0 0 2  0 0 0  8 0 0 \n    1 0 0  7 0 3  9 0 2 \n \n    0 0 8  0 7 2  0 4 9 \n    0 2 0  9 8 0  0 7 0 \n    7 9 0  0 0 0  0 8 0 \n \n    0 0 0  0 3 0  5 0 6 \n    9 6 0  0 1 0  3 0 0 \n    0 5 0  6 9 0  0 1 0\n>;\n \nmy &I = * div 9;  # line number\nmy &J = * % 9;    # column number\nmy &K = { ($_ div 27) * 3 + $_ % 9 div 3 }; # bloc number\n\nsub solve {\n    for ^@A -> $i {\n\tnext if @A[$i];\n\tmy @taken-values = @A[\n\t    grep {\n\t\tI($_) == I($i) || J($_) == J($i) || K($_) == K($i)\n\t    }, ^@A\n\t];\n\tfor grep none(@taken-values), 1..9 {\n\t    @A[$i] = $_;\n\t    solve;\n\t}\n\treturn @A[$i] = 0;\n    }\n    my $i = 1;\n    for ^@A {\n\tprint \"@A[$_] \";\n\tprint \" \"  if $i %% 3;\n\tprint \"\\n\" if $i %% 9;\n\tprint \"\\n\" if $i++ %% 27;\n    }\n}\nsolve;\n\n```\n\nOutput:\n\n```\n5 3 9  8 2 4  7 6 1  \n6 7 2  1 5 9  8 3 4  \n1 8 4  7 6 3  9 5 2  \n\n3 1 8  5 7 2  6 4 9  \n4 2 5  9 8 6  1 7 3  \n7 9 6  3 4 1  2 8 5  \n\n8 4 1  2 3 7  5 9 6  \n9 6 7  4 1 5  3 2 8  \n2 5 3  6 9 8  4 1 7\n```\n\n### Finesse It\n\nThis is an alternative solution that uses a more ellaborate set of choices instead of brute-forcing it.\n\n```\n#\n# In this code, a sudoku puzzle is represented as a two-dimentional\n# array. The cells that are not yet solved are represented by yet\n# another array of all the possible values.\n#\n# This implementation is not a simple brute force evaluation of all\n# the options, but rather makes four extra attempts to guide the\n# solution:\n#\n#  1) For every change in the grid, usually made by an attempt at a\n#     solution, we will reduce the search space of the possible values\n#     in all the other cells before going forward.\n#\n#  2) When a cell that is not yet resolved is the only one that can\n#     hold a specific value, resolve it immediately instead of\n#     performing the regular search.\n#\n#  3) Instead of trying from cell 1,1 and moving in sequence, this\n#     implementation will start trying on the cell that is the closest\n#     to being solved already.\n#\n#  4) Instead of trying all possible values in sequence, start with\n#     the value that is the most unique. I.e.: If the options for this\n#     cell are 1,4,6 and 6 is only a candidate for two of the\n#     competing cells, we start with that one.\n#\n\n# keep a list with all the cells, handy for traversal\nmy @cells = do for (flat 0..8 X 0..8) -> $x, $y { [ $x, $y ] };\n\n#\n# Try to solve this puzzle and return the resolved puzzle if it is at\n# all solvable in this configuration.\nsub solve($sudoku, Int $level) {\n    # cleanup the impossible values first,\n    if (cleanup-impossible-values($sudoku, $level)) {\n        # try to find implicit answers\n        while (find-implicit-answers($sudoku, $level)) {\n            # and every time you find some, re-do the cleanup and try again\n            cleanup-impossible-values($sudoku, $level);\n        }\n        # Now let's actually try to solve a new value. But instead of\n        # going in sequence, we select the cell that is the closest to\n        # being solved already. This will reduce the overall number of\n        # guesses.\n        for sort { solution-complexity-factor($sudoku, $_[0], $_[1]) },\n        grep { $sudoku[$_[0]][$_[1]] ~~ Array },\n        @cells -> $cell\n        {\n            my Int ($x, $y) = @($cell);\n            # Now let's try the possible values in the order of\n            # uniqueness.\n            for sort { matches-in-competing-cells($sudoku, $x, $y, $_) }, @($sudoku[$x][$y]) -> $val {\n                trace $level, \"Trying $val on \"~($x+1)~\",\"~($y+1)~\" \"~$sudoku[$x][$y].raku;\n                my $solution = clone-sudoku($sudoku);\n                $solution[$x][$y] = $val;\n                my $solved = solve($solution, $level+1);\n                if $solved {\n                    trace $level, \"Solved... ($val on \"~($x+1)~\",\"~($y+1)~\")\";\n                    return $solved;\n                }\n            }\n            # if we fell through, it means that we found no valid\n            # value for this cell\n            trace $level, \"Backtrack, path unsolvable... (on \"~($x+1)~\" \"~($y+1)~\")\";\n            return False;\n        }\n        # all cells are already solved.\n        return $sudoku;\n    } else {\n        # if the cleanup failed, it means this is an invalid grid.\n        return False;\n    }\n}\n\n# This function reduces the search space from values that are already\n# assigned to competing cells.\nsub cleanup-impossible-values($sudoku, Int $level = 1) {\n    my Bool $resolved;\n    repeat {\n        $resolved = False;\n        for grep { $sudoku[$_[0]][$_[1]] ~~ Array },\n        @cells -> $cell {\n            my Int ($x, $y) = @($cell);\n            # which block is this cell in\n            my Int $bx = Int($x / 3);\n            my Int $by = Int($y / 3);\n            \n            # A unfilled cell is not resolved, so it shouldn't match\n            my multi match-resolved-cell(Array $other, Int $this) {\n                return False;\n            }\n            my multi match-resolved-cell(Int $other, Int $this) {\n                return $other == $this;\n            }\n\n            # Reduce the possible values to the ones that are still\n            # valid\n            my @r =\n                grep { !match-resolved-cell($sudoku[any(0..2)+3*$bx][any(0..2)+3*$by], $_) }, # same block\n                grep { !match-resolved-cell($sudoku[any(0..8)][$y], $_) }, # same line\n                grep { !match-resolved-cell($sudoku[$x][any(0..8)], $_) }, # same column\n                @($sudoku[$x][$y]);\n            if (@r.elems == 1) {\n                # if only one element is left, then make it resolved\n                $sudoku[$x][$y] = @r[0];\n                $resolved = True;\n            } elsif (@r.elems == 0) {\n                # This is an invalid grid\n                return False;\n            } else {\n                $sudoku[$x][$y] = @r;\n            }\n        }\n    } while $resolved; # repeat if there was any change\n    return True;\n}\n\nsub solution-complexity-factor($sudoku, Int $x, Int $y) {\n    my Int $bx = Int($x / 3); # this block\n    my Int $by = Int($y / 3);\n    my multi count-values(Array $val) {\n        return $val.elems;\n    }\n    my multi count-values(Int $val) {\n        return 1;\n    }\n    # the number of possible values should take precedence\n    my Int $f = 1000 * count-values($sudoku[$x][$y]);\n    for (flat 0..2 X 0..2) -> $lx, $ly {\n        $f += count-values($sudoku[$lx+$bx*3][$ly+$by*3])\n    }\n    for 0..^($by*3), (($by+1)*3)..8 -> $ly {\n        $f += count-values($sudoku[$x][$ly])\n    }\n    for 0..^($bx*3), (($bx+1)*3)..8 -> $lx {\n        $f += count-values($sudoku[$lx][$y])\n    }\n    return $f;\n}\n\nsub matches-in-competing-cells($sudoku, Int $x, Int $y, Int $val) {\n    my Int $bx = Int($x / 3); # this block\n    my Int $by = Int($y / 3);\n    # Function to decide which possible value to try first\n    my multi cell-matching(Int $cell) {\n        return $val == $cell ?? 1 !! 0;\n    }\n    my multi cell-matching(Array $cell) {\n        return $cell.grep({ $val == $_ }) ?? 1 !! 0;\n    }\n    my Int $c = 0;\n    for (flat 0..2 X 0..2) -> $lx, $ly {\n        $c += cell-matching($sudoku[$lx+$bx*3][$ly+$by*3])\n    }\n    for 0..^($by*3), (($by+1)*3)..8 -> $ly {\n        $c += cell-matching($sudoku[$x][$ly])\n    }\n    for 0..^($bx*3), (($bx+1)*3)..8 -> $lx {\n        $c += cell-matching($sudoku[$lx][$y])\n    }\n    return $c;\n}\n\nsub find-implicit-answers($sudoku, Int $level) {\n    my Bool $resolved = False;\n    for grep { $sudoku[$_[0]][$_[1]] ~~ Array },\n    @cells -> $cell {\n        my Int ($x, $y) = @($cell);\n        for @($sudoku[$x][$y]) -> $val {\n            # If this is the only cell with this val as a possibility,\n            # just make it resolved already\n            if (matches-in-competing-cells($sudoku, $x, $y, $val) == 1) {\n                $sudoku[$x][$y] = $val;\n                $resolved = True;\n            }\n        }\n    }\n    return $resolved;\n}\n\nmy $puzzle =\n    map { [ map { $_ == 0 ?? [1..9] !! $_+0  }, @($_) ] },\n    [ 0,0,0,0,3,7,6,0,0 ],\n    [ 0,0,0,6,0,0,0,9,0 ],\n    [ 0,0,8,0,0,0,0,0,4 ],\n    [ 0,9,0,0,0,0,0,0,1 ],\n    [ 6,0,0,0,0,0,0,0,9 ],\n    [ 3,0,0,0,0,0,0,4,0 ],\n    [ 7,0,0,0,0,0,8,0,0 ],\n    [ 0,1,0,0,0,9,0,0,0 ],\n    [ 0,0,2,5,4,0,0,0,0 ];\n\nmy $solved = solve($puzzle, 0);\nif $solved {\n    print-sudoku($solved,0);\n} else {\n    say \"unsolvable.\";\n}\n\n# Utility functions, not really part of the solution\n\nsub trace(Int $level, Str $message) {\n    # say '.' x $level, $message; # un-comment for verbose logging\n}\n\nsub clone-sudoku($sudoku) {\n    my $clone;\n    for (flat 0..8 X 0..8) -> $x, $y {\n        $clone[$x][$y] = $sudoku[$x][$y];\n    }\n    return $clone;\n}\n\nsub print-sudoku($sudoku, Int $level = 1) {\n    trace $level, '-' x 5*9;\n    for @($sudoku) -> $row {\n        trace $level, join \" \", do for @($row) -> $cell {\n            $cell ~~ Array ?? \"#{$cell.elems}#\" !! \" $cell \" \n        }\n    }\n}\n\n```\n\nOutput:\n\n```\n 9   5   4   1   3   7   6   8   2 \n 2   7   3   6   8   4   1   9   5 \n 1   6   8   2   9   5   7   3   4 \n 4   9   5   7   2   8   3   6   1 \n 6   8   1   4   5   3   2   7   9 \n 3   2   7   9   6   1   5   4   8 \n 7   4   9   3   1   2   8   5   6 \n 5   1   6   8   7   9   4   2   3 \n 8   3   2   5   4   6   9   1   7 \n\n```"}]}
{"messages": [{"role": "user", "content": "A suffix tree is a data structure commonly used in string algorithms.\n\nGiven a string S of length n, its suffix tree is a tree T such that:\n\n* T has exactly n leaves numbered from 1 to n.\n* Except for the root, every internal node has at least two children.\n* Each edge of T is labelled with a non-empty substring of S.\n* No two edges starting out of a node can have string labels beginning with the same character.\n* The string obtained by concatenating all the string labels found on the path from the root to leaf i spells out suffix S[i..n], for i from 1 to n.\n\nSuch a tree does not exist for all strings. To ensure existence, a character that is not found in S must be appended at its end. The character '$' is traditionally used for this purpose.\n\nFor this task, build and display the suffix tree of the string \"banana$\". Displaying the tree can be done using the code from the visualize a tree task, but any other convenient method is accepted.\n\nThere are several ways to implement the tree data structure, for instance how edges should be labelled. Latitude is given in this matter, but notice that a simple way to do it is to label each node with the label of the edge leading to it.\n\nThe computation time for an efficient algorithm should be \n\nO\n(\nn\n)\n{\\displaystyle {\\displaystyle O(n)}}\n, but such an algorithm might be difficult to implement. An easier, \n\nO\n(\n\nn\n\n2\n)\n{\\displaystyle {\\displaystyle O(n^{2})}}\n algorithm is accepted."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.04\n\nHere is quite a naive algorithm, probably \n\nO\n(\n\nn\n\n2\n)\n{\\displaystyle {\\displaystyle O(n^{2})}}\n.\n\nThe display code is a variant of the visualize a tree task code.\n\n```\nmulti suffix-tree(Str $str) { suffix-tree flat map &flip, [\\~] $str.flip.comb }\nmulti suffix-tree(@a) {\n    hash\n    @a == 0 ?? () !!\n    @a == 1 ?? ( @a[0] => [] ) !!\n    gather for @a.classify(*.substr(0, 1)) {\n        my $subtree = suffix-tree(grep *.chars, map *.substr(1), .value[]);\n        if $subtree == 1 {\n            my $pair = $subtree.pick;\n            take .key ~ $pair.key => $pair.value;\n        } else {\n            take .key => $subtree;\n        }\n    }\n}\n\nmy $tree = root => suffix-tree 'banana$';\n\n.say for visualize-tree $tree, *.key, *.value.List;\n\nsub visualize-tree($tree, &label, &children,\n                   :$indent = '',\n                   :@mid = ('├─', '│ '),\n                   :@end = ('└─', '  '),\n) {\n    sub visit($node, *@pre) {\n        gather {\n            take @pre[0] ~ $node.&label;\n            my @children = sort $node.&children;\n            my $end = @children.end;\n            for @children.kv -> $_, $child {\n                when $end { take visit($child, (@pre[1] X~ @end)) }\n                default   { take visit($child, (@pre[1] X~ @mid)) }\n            }\n        }\n    }\n    flat visit($tree, $indent xx 2);\n}\n\n```\n\nOutput:\n\n```\nroot\n├─$\n├─a\n│ ├─$\n│ └─na\n│   ├─$\n│   └─na$\n├─banana$\n└─na\n  ├─$\n  └─na$\n```"}]}
{"messages": [{"role": "user", "content": "**Suffixation**:   a letter or a group of letters added to the end of a word to change its meaning.\n\n:   :   :   :   :   :   :   ─────   or, as used herein   ─────\n\n**Suffixation**:   the addition of a metric or \"binary\" metric suffix to a number, with/without rounding.\n\nTask\n\nWrite a function(s) to append (if possible)   a metric   or   a \"binary\" metric   suffix to a\nnumber   (displayed in decimal).\n\nThe number may be rounded   (as per user specification)   (via shortening of the number when the number of\ndigits past the decimal point are to be used).\n\nTask requirements\n:   :   * write a function (or functions) to add   (if possible)   a suffix to a number\n        * the function(s) should be able to express the number (possibly with a suffix) in as many decimal digits as specified\n        * the sign should be preserved   (if present)\n        * the number may have commas within the number   (the commas need not be preserved)\n        * the number may have a decimal point and/or an exponent as in:   -123.7e-01\n        * the suffix that might be appended should be in uppercase;   however, the   **i**   should be in lowercase\n        * support:\n\n        :   :   * the            metric suffixes:   **K  M  G  T  P  E  Z  Y  X  W  V  U**\n                * the binary metric suffixes:   **Ki Mi Gi Ti Pi Ei Zi Yi Xi Wi Vi Ui**\n                * the (full name) suffix:   **googol**   (lowercase)   (equal to **1e100**)     (optional)\n                * a number of decimal digits past the decimal point   (with rounding).   The default is to display all significant digits\n\n        * validation of the (supplied/specified) arguments is optional but recommended\n        * display   (with identifying text):\n\n        :   :   * the original number   (with identifying text)\n                * the number of digits past the decimal point being used   (or none, if not specified)\n                * the type of suffix being used   (metric or \"binary\" metric)\n                * the (new) number with the appropriate   (if any)   suffix\n                * all output here on this page\n\nMetric suffixes to be supported   (whether or not they're officially sanctioned)\n\n```\n     K     multiply the number by  10^3              kilo      (1,000)\n     M     multiply the number by  10^6              mega      (1,000,000)\n     G     multiply the number by  10^9              giga      (1,000,000,000)\n     T     multiply the number by  10^12             tera      (1,000,000,000,000)\n     P     multiply the number by  10^15             peta      (1,000,000,000,000,000)\n     E     multiply the number by  10^18             exa       (1,000,000,000,000,000,000)\n     Z     multiply the number by  10^21             zetta     (1,000,000,000,000,000,000,000)\n     Y     multiply the number by  10^24             yotta     (1,000,000,000,000,000,000,000,000)\n     X     multiply the number by  10^27             xenta     (1,000,000,000,000,000,000,000,000,000)\n     W     multiply the number by  10^30             wekta     (1,000,000,000,000,000,000,000,000,000,000)\n     V     multiply the number by  10^33             vendeka   (1,000,000,000,000,000,000,000,000,000,000,000)\n     U     multiply the number by  10^36             udekta    (1,000,000,000,000,000,000,000,000,000,000,000,000)\n\n```\n\n\"Binary\" suffixes to be supported   (whether or not they're officially sanctioned)\n\n```\n     Ki    multiply the number by  2^10              kibi      (1,024)\n     Mi    multiply the number by  2^20              mebi      (1,048,576)\n     Gi    multiply the number by  2^30              gibi      (1,073,741,824)\n     Ti    multiply the number by  2^40              tebi      (1,099,571,627,776)\n     Pi    multiply the number by  2^50              pebi      (1,125,899,906,884,629)\n     Ei    multiply the number by  2^60              exbi      (1,152,921,504,606,846,976)\n     Zi    multiply the number by  2^70              zebi      (1,180,591,620,717,411,303,424)\n     Yi    multiply the number by  2^80              yobi      (1,208,925,819,614,629,174,706,176)\n     Xi    multiply the number by  2^90              xebi      (1,237,940,039,285,380,274,899,124,224)\n     Wi    multiply the number by  2^100             webi      (1,267,650,600,228,229,401,496,703,205,376)\n     Vi    multiply the number by  2^110             vebi      (1,298,074,214,633,706,907,132,624,082,305,024)\n     Ui    multiply the number by  2^120             uebi      (1,329,227,995,784,915,872,903,807,060,280,344,576)\n\n```\n\nFor instance, with this pseudo─code\n\n```\n                                 /* 1st arg: the number to be transformed.*/\n                                 /* 2nd arg: # digits past the dec. point.*/\n                                 /* 3rd arg: the type of suffix to use.   */\n                                 /*         2   indicates \"binary\" suffix.*/\n                                 /*        10   indicates  decimal suffix.*/\n     a = '456,789,100,000,000'   /* \"A\"  has  eight  trailing zeros.      */\n     say ' aa=' suffize(a)       /* Display a suffized number to terminal.*/\n                                 /* The  \"1\"   below shows one decimal ···*/\n                                 /*         digit past the decimal point. */\n     n = suffize(a, 1)           /* SUFFIZE  is the function name.        */\n     n = suffize(a, 1, 10)       /* (identical to the above statement.)   */\n     say '  n=' n                /* Display value of  N  to terminal.     */\n                                 /* Note the rounding that occurs.        */\n     f = suffize(a, 1,  2)       /* SUFFIZE  with one fractional digit    */\n     say '  f=' f                /* Display value of  F  to terminal.     */\n                                 /* Display value in \"binary\" metric.     */\n     bin = suffize(a, 5, 2)      /* SUFFIZE with binary metric suffix.    */\n     say 'bin=' bin              /* Display value of  BIN  to terminal.   */\n     win = suffize(a, 0, 2)      /* SUFFIZE with binary metric suffix.    */\n     say 'win=' win              /* Display value of  WIN  to terminal.   */\n     xvi = ' +16777216 '         /* this used to be a big computer ···    */\n     big = suffize(xvi, , 2)     /* SUFFIZE with binary metric suffix.    */\n     say 'big=' big              /* Display value of  BIG  to terminal.   */\n\n```\n\nwould display:\n\n```\n      aa= 456.7891T\n       n= 456.8T\n       f= 415.4Ti\n     bin= 415.44727Ti\n     win= 415Ti\n     big= 16Mi\n\n```\n\nUse these test cases\n\n```\n               87,654,321\n              -998,877,665,544,332,211,000      3\n              +112,233                          0\n               16,777,216                       1\n               456,789,100,000,000              2\n               456,789,100,000,000              2      10\n               456,789,100,000,000              5       2\n               456,789,100,000.000e+00          0      10\n              +16777216                         ,       2\n               1.2e101\n               (your primary disk free space)   1                  ◄■■■■■■■ optional\n\n```\n\nUse whatever parameterizing your computer language supports,   and it's permitted to create as many\nseparate functions as are needed   (if needed)   if   function arguments aren't allowed to\nbe omitted or varied.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\nPass in a number string, optionally a type, and optionally the number of digits to round to.\n\nThe types supported are B, M & G for binary, metric or gigantic. (At this point, the only gigantic unit is googol, so maybe it stands for googol. ¯\\\\_(ツ)\\_/¯ )\n\nIf no type is specified, M (metric) is assumed.\n\nIf you desire the number to be rounded, pass in a number representing the placed past the decimal to round to. If you pass in a negative number for rounding, it will round to a negative number of places past the decimal.\n\n```\nsub sufficate ($val is copy, $type is copy = 'M', $round is copy = Any) {\n   if +$type ~~ Int { $round = $type; $type = 'M' }\n   my $s = '';\n   if $val.substr(0,1) eq '-' { $s = '-'; $val.=substr(1) }\n   $val.=subst(',', '', :g);\n   if $val ~~ m:i/'e'/ {\n       my ($m,$e) = $val.split(/<[eE]>/);\n       $val = ($e < 0)\n           ?? $m * FatRat.new(1,10**-$e)\n           !! $m * 10**$e;\n   }\n   my %s = do given $type {\n       when 'M' { <K M G T P E Z Y X W V U> Z=> (1000, * * 1000 … *) }\n       when 'B' { <Ki Mi Gi Ti Pi Ei Zi Yi Xi Wi Vi Ui> Z=> (1024, * * 1024 … *) }\n       when 'G' { googol => 10**100 }\n       default { return 'What we have here is a failure to communicate...' }\n   }\n   my $k = do given $val {\n       when .abs < (my $m = min %s.values) { %s.first( *.value == $m ).key };\n       when .abs > (my $x = max %s.values) { %s.first( *.value == $x ).key };\n       default { %s.sort(*.value).first({$val.abs/%s{$_.key} < min %s.values}).key}\n   }\n   $round.defined\n       ?? $s ~ comma(($val.abs/%s{$k}).round(10**-$round)) ~ $k\n       !! $s ~ comma($val.abs/%s{$k}) ~ $k\n}\n\nsub comma ($i is copy) {\n    my $s = $i < 0 ?? '-' !! '';\n    my ($whole, $frac) = $i.split('.');\n    $frac = $frac.defined ?? \".$frac\" !! '';\n    $s ~ $whole.abs.flip.comb(3).join(',').flip ~ $frac\n}\n\n## TESTING\n\nmy @tests =\n   '87,654,321',\n   '-998,877,665,544,332,211,000 3',\n   '+112,233 0',\n   '16,777,216 1',\n   '456,789,100,000,000',\n   '456,789,100,000,000 M 2',\n   '456,789,100,000,000 B 5',\n   '456,789,100,000.000e+00 M 0',\n   '+16777216 B',\n   '1.2e101 G',\n   \"{run('df', '/', :out).out.slurp.words[10] * 1024} B 2\", # Linux df returns Kilobytes by default\n   '347,344 M -2', # round to -2 past the decimal\n   '1122334455 Q', # bad unit type example\n;\n\nprintf \"%33s : %s\\n\", $_, sufficate(|.words) for @tests;\n\n```\n\nOutput:\n\n```\n                       87,654,321 : 87.654321M\n   -998,877,665,544,332,211,000 3 : -998.878E\n                       +112,233 0 : 112K\n                     16,777,216 1 : 16.8M\n              456,789,100,000,000 : 456.7891T\n          456,789,100,000,000 M 2 : 456.79T\n          456,789,100,000,000 B 5 : 415.44727Ti\n      456,789,100,000.000e+00 M 0 : 457G\n                      +16777216 B : 16Mi\n                        1.2e101 G : 12googol\n                 703674818560 B 2 : 655.35Gi\n                     347,344 M -2 : 300K\n                     1122334455 Q : What we have here is a failure to communicate...\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCompute the sum and product of an array of integers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @ary = 1, 5, 10, 100;\nsay 'Sum: ',     [+] @ary;\nsay 'Product: ', [*] @ary;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSolve the \"*Impossible Puzzle*\":\n\nX and Y are two different whole numbers greater than 1. Their sum is no greater than 100, and Y is greater than X. S and P are two mathematicians (and consequently perfect logicians); S knows the sum X+Y and P knows the product X\\*Y. Both S and P know all the information in this paragraph.\n\nThe following conversation occurs:\n\n* S says \"P does not know X and Y.\"\n* P says \"Now I know X and Y.\"\n* S says \"Now I also know X and Y!\"\n\nWhat are X and Y?\n\nGuidance\n\nIt can be hard to wrap one's head around what the three lines of dialog between S (the \"sum guy\") and P (the \"product guy\") convey about the values of X and Y.  \nSo for your convenience, here's a break-down:\n\n|  | Quote | Implied fact |\n| --- | --- | --- |\n| 1) | S says \"P does not know X and Y.\" | For every possible sum decomposition of the number X+Y, the product has in turn *more than one* product decomposition. |\n| 2) | P says \"Now I know X and Y.\" | The number X\\*Y has *only one* product decomposition for which fact 1 is true. |\n| 3) | S says \"Now I also know X and Y.\" | The number X+Y has *only one* sum decomposition for which fact 2 is true. |\n\nTerminology:\n\n* *\"sum decomposition\" of a number* = Any pair of positive integers (A, B) so that A+B equals the number. Here, with the additional constraint 2 ≤ A < B.\n* *\"product decomposition\" of a number* = Any pair of positive integers (A, B) so that A\\*B equals the number. Here, with the additional constraint 2 ≤ A < B.\n\nYour program can solve the puzzle by considering all possible pairs (X, Y) in the range 2 ≤ X < Y ≤ 98, and then successively eliminating candidates based on the three facts. It turns out only one solution remains!  \nSee the Python example for an implementation that uses this approach with a few optimizations.\n\nSee also\n\n* Wikipedia:   Sum and Product Puzzle\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n**Works with**: Rakudo version 2016.07\n\n```\nsub grep-unique (&by, @list) { @list.classify(&by).values.grep(* == 1).map(*[0]) }\nsub sums        ($n)         { ($_, $n - $_ for 2 .. $n div 2) }\nsub product     ([$x, $y])   { $x * $y }\nsub sum         ([$x, $y])   { $x + $y }\n\nmy @all-pairs = (|($_ X $_+1 .. 98) for 2..97);\n\n# Fact 1:\nmy %p-unique := Set.new: map ~*, grep-unique &product, @all-pairs;\nmy @s-pairs = @all-pairs.grep: { none (%p-unique{~$_} for sums sum $_) };\n\n# Fact 2:\nmy @p-pairs = grep-unique &product, @s-pairs;\n\n# Fact 3:\nmy @final-pairs = grep-unique &sum, @p-pairs;\n\nprintf \"X = %d, Y = %d\\n\", |$_ for @final-pairs;\n\n```\n\nOutput:\n\n```\nX = 4, Y = 13\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a sum data type:\n\nA sum data type is a data structure used to hold a value that could take on several different, but fixed, types.\nOnly one of the types can be in use at any one time.\n\nSum data types are considered an algebraic data type and are also known as tagged union, variant, variant record, choice type, discriminated union, disjoint union or coproduct.\n\nRelated task\n\n* Compound data type\n\nSee also\n\n* Array\n* Associative array: Creation, Iteration\n* Collections\n* Compound data type\n* Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal\n* Linked list\n* Queue: Definition, Usage\n* Set\n* Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal\n* Stack"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku doesn't really have Sum Types as a formal data structure but they can be emulated with enums and switches or multi-dispatch. Note that in this case, feeding the dispatcher an incorrect value results in a hard fault; it doesn't just dispatch to the default. Of course those rules can be relaxed or made more restrictive depending on your particular use case.\n\n```\nenum Traffic-Signal < Red Yellow Green Blue >;\n\nsub message (Traffic-Signal $light) {\n    with $light {\n        when Red    { 'Stop!'                                       }\n        when Yellow { 'Speed Up!'                                   }\n        when Green  { 'Go! Go! Go!'                                 }\n        when Blue   { 'Wait a minute, How did we end up in Japan?!' }\n        default     { 'Whut?'                                       }\n    }\n}\n\nmy \\Pink = 'A Happy Balloon';\n\n\nfor Red, Green, Blue, Pink -> $signal {\n    say message $signal;\n}\n\n```\n\nOutput:\n\n```\nStop!\nGo! Go! Go!\nWait a minute, How did we end up in Japan?!\nType check failed in binding to parameter '$light'; expected Traffic-Signal but got Str (\"A Happy Balloon\")\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nTake a   Natural Number   in a given base and return the sum of its digits:\n\n:   * **1**10         sums to   **1**\n    * **1234**10   sums to   **10**\n    * **fe**16       sums to   **29**\n    * **f0e**16     sums to   **29**"}, {"role": "assistant", "content": "(formerly Perl 6)\nThis will handle input numbers in any base from 2 to 36.\nThe results are in base 10.\n\n```\nsay Σ $_ for <1 1234 1020304 fe f0e DEADBEEF>;\n\nsub Σ { [+] $^n.comb.map: { :36($_) } }\n```\n\nOutput:\n\n```\n1\n10\n10\n29\n29\n104\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nThe objective is to write a function that finds the sum of all positive multiples of 3 or 5 below *n*.\n\nShow output for *n* = 1000.\n\nThis is is the same as Project Euler problem 1.\n\n**Extra credit:** do this efficiently for *n* = 1e20 or higher."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub sum35($n) { [+] grep * %% (3|5), ^$n; }\n\nsay sum35 1000;\n```\n\nOutput:\n\n```\n233168\n```\n\nHere's an analytical approach that scales much better for large values.\n\n```\nsub sum-mults($first, $limit) {\n    (my $last = $limit - 1) -= $last % $first;\n    ($last div $first) * ($first + $last) div 2;\n}\n\nsub sum35(\\n) {\n    sum-mults(3,n) + sum-mults(5,n) - sum-mults(15,n);\n}\n\nsay sum35($_) for 1,10,100...10**30;\n```\n\nOutput:\n\n```\n0\n23\n2318\n233168\n23331668\n2333316668\n233333166668\n23333331666668\n2333333316666668\n233333333166666668\n23333333331666666668\n2333333333316666666668\n233333333333166666666668\n23333333333331666666666668\n2333333333333316666666666668\n233333333333333166666666666668\n23333333333333331666666666666668\n2333333333333333316666666666666668\n233333333333333333166666666666666668\n23333333333333333331666666666666666668\n2333333333333333333316666666666666666668\n233333333333333333333166666666666666666668\n23333333333333333333331666666666666666666668\n2333333333333333333333316666666666666666666668\n233333333333333333333333166666666666666666666668\n23333333333333333333333331666666666666666666666668\n2333333333333333333333333316666666666666666666666668\n233333333333333333333333333166666666666666666666666668\n23333333333333333333333333331666666666666666666666666668\n2333333333333333333333333333316666666666666666666666666668\n233333333333333333333333333333166666666666666666666666666668\n```"}]}
{"messages": [{"role": "user", "content": "Compute the   **n**th   term of a series,   i.e. the sum of the   **n**   first terms of the corresponding sequence.\n\nInformally this value, or its limit when   **n**   tends to infinity, is also called the *sum of the series*, thus the title of this task.\n\nFor this task, use:\n\n:   :   :   :   :   :   S\n\n                        n\n                        =\n\n                        ∑\n\n                        k\n                        =\n                        1\n\n                        n\n\n\n                        1\n\n                        k\n\n                        2\n                        {\\displaystyle {\\displaystyle S\\_{n}=\\sum \\_{k=1}^{n}{\\frac {1}{k^{2}}}}}\n\n:   :   and compute   \n\n        S\n\n        1000\n        {\\displaystyle {\\displaystyle S\\_{1000}}}\n\nThis approximates the   zeta function   for   S=2,   whose exact value\n\n:   :   :   :   :   :   ζ\n                        (\n                        2\n                        )\n                        =\n\n                        π\n\n                        2\n                        6\n                        {\\displaystyle {\\displaystyle \\zeta (2)={\\pi ^{2} \\over 6}}}\n\nis the solution of the Basel problem."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.04\n\nIn general, the `$n`th partial sum of a series whose terms are given by a unary function `&f` is\n\n```\n[+] map &f, 1 .. $n\n```\n\nSo what's needed in this case is\n\n```\nsay [+] map { 1 / $^n**2 }, 1 .. 1000;\n```\n\nOr, using the \"hyper\" metaoperator to vectorize, we can use a more \"point free\" style while keeping traditional precedence:\n\n```\nsay [+] 1 «/« (1..1000) »**» 2;\n```\n\nOr we can use the X \"cross\" metaoperator, which is convenient even if one side or the other is a scalar. In this case, we demonstrate a scalar on either side:\n\n```\nsay [+] 1 X/ (1..1000 X** 2);\n```\n\nNote that cross ops are parsed as list infix precedence rather than using the precedence of the base op as hypers do. Hence the difference in parenthesization.\n\nWith list comprehensions, you can write:\n\n```\nsay [+] (1 / $_**2 for 1..1000);\n```\n\nThat's fine for a single result, but if you're going to be evaluating the sequence multiple times, you don't want to be recalculating the sum each time, so it's more efficient to define the sequence as a constant to let the run-time automatically cache those values already calculated. In a lazy language like Raku, it's generally considered a stronger abstraction to write the correct infinite sequence, and then take the part of it you're interested in.\nHere we define an infinite sequence of partial sums (by adding a backslash into the reduction to make it look \"triangular\"), then take the 1000th term of that:\n\n```\nconstant @x = [\\+] 0, { 1 / ++(state $n) ** 2 } ... *;\nsay @x[1000];  # prints 1.64393456668156\n```\n\nNote that infinite constant sequences can be lazily generated in Raku, or this wouldn't work so well...\n\nA cleaner style is to combine these approaches with a more FP look:\n\n```\nconstant ζish = [\\+] map -> \\𝑖 { 1 / 𝑖**2 }, 1..*;\nsay ζish[1000];\n```\n\nPerhaps the cleanest way is to just define the zeta function and evaluate it for s=2, possibly using memoization:\n\n```\nuse experimental :cached;\nsub ζ($s) is cached { [\\+] 1..* X** -$s }\nsay ζ(2)[1000];\n```\n\nNotice how the thus-defined zeta function returns a lazy list of approximated values, which is arguably the closest we can get from the mathematical definition."}]}
{"messages": [{"role": "user", "content": "Given a positive integer, sum its positive divisors.\n\nTask\n\nShow the result for the first 100 positive integers."}, {"role": "assistant", "content": "Yet more tasks that are tiny variations of each other. Tau function, Tau number, Sum of divisors and Product of divisors all use code with minimal changes. What the heck, post 'em all.\n\n```\nuse Prime::Factor:ver<0.3.0+>;\nuse Lingua::EN::Numbers;\n\nsay \"\\nTau function - first 100:\\n\",        # ID\n(1..*).map({ +.&divisors })[^100]\\          # the task\n.batch(20)».fmt(\"%3d\").join(\"\\n\");          # display formatting\n\nsay \"\\nTau numbers - first 100:\\n\",         # ID\n(1..*).grep({ $_ %% +.&divisors })[^100]\\   # the task\n.batch(10)».&comma».fmt(\"%5s\").join(\"\\n\");  # display formatting\n\nsay \"\\nDivisor sums - first 100:\\n\",        # ID\n(1..*).map({ [+] .&divisors })[^100]\\       # the task\n.batch(20)».fmt(\"%4d\").join(\"\\n\");          # display formatting\n\nsay \"\\nDivisor products - first 100:\\n\",    # ID\n(1..*).map({ [×] .&divisors })[^100]\\       # the task\n.batch(5)».&comma».fmt(\"%16s\").join(\"\\n\");  # display formatting\n\n```\n\nOutput:\n\n```\nTau function - first 100:\n  1   2   2   3   2   4   2   4   3   4   2   6   2   4   4   5   2   6   2   6\n  4   4   2   8   3   4   4   6   2   8   2   6   4   4   4   9   2   4   4   8\n  2   8   2   6   6   4   2  10   3   6   4   6   2   8   4   8   4   4   2  12\n  2   4   6   7   4   8   2   6   4   8   2  12   2   4   6   6   4   8   2  10\n  5   4   2  12   4   4   4   8   2  12   4   6   4   4   4  12   2   6   6   9\n\nTau numbers - first 100:\n    1     2     8     9    12    18    24    36    40    56\n   60    72    80    84    88    96   104   108   128   132\n  136   152   156   180   184   204   225   228   232   240\n  248   252   276   288   296   328   344   348   360   372\n  376   384   396   424   441   444   448   450   468   472\n  480   488   492   504   516   536   560   564   568   584\n  600   612   625   632   636   640   664   672   684   708\n  712   720   732   776   792   804   808   824   828   852\n  856   864   872   876   880   882   896   904   936   948\n  972   996 1,016 1,040 1,044 1,048 1,056 1,068 1,089 1,096\n\nDivisor sums - first 100:\n   1    3    4    7    6   12    8   15   13   18   12   28   14   24   24   31   18   39   20   42\n  32   36   24   60   31   42   40   56   30   72   32   63   48   54   48   91   38   60   56   90\n  42   96   44   84   78   72   48  124   57   93   72   98   54  120   72  120   80   90   60  168\n  62   96  104  127   84  144   68  126   96  144   72  195   74  114  124  140   96  168   80  186\n 121  126   84  224  108  132  120  180   90  234  112  168  128  144  120  252   98  171  156  217\n\nDivisor products - first 100:\n               1                2                3                8                5\n              36                7               64               27              100\n              11            1,728               13              196              225\n           1,024               17            5,832               19            8,000\n             441              484               23          331,776              125\n             676              729           21,952               29          810,000\n              31           32,768            1,089            1,156            1,225\n      10,077,696               37            1,444            1,521        2,560,000\n              41        3,111,696               43           85,184           91,125\n           2,116               47      254,803,968              343          125,000\n           2,601          140,608               53        8,503,056            3,025\n       9,834,496            3,249            3,364               59   46,656,000,000\n              61            3,844          250,047        2,097,152            4,225\n      18,974,736               67          314,432            4,761       24,010,000\n              71  139,314,069,504               73            5,476          421,875\n         438,976            5,929       37,015,056               79    3,276,800,000\n          59,049            6,724               83  351,298,031,616            7,225\n           7,396            7,569       59,969,536               89  531,441,000,000\n           8,281          778,688            8,649            8,836            9,025\n 782,757,789,696               97          941,192          970,299    1,000,000,000\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and display the sum of elements that are below the main diagonal of a matrix.\n\nThe matrix should be a square matrix.\n\n:   :   :   ───   Matrix to be used:   ───\n\n```\n     [[1,3,7,8,10],\n      [2,4,16,14,4],\n      [3,1,9,18,11],\n      [12,14,17,18,20],\n      [7,1,3,9,5]] \n\n```"}, {"role": "assistant", "content": "```\nsub lower-triangle-sum (@matrix) { sum flat (1..@matrix).map( { @matrix[^$_]»[^($_-1)] } )»[*-1] }\n\nsay lower-triangle-sum \n[\n    [  1,  3,  7,  8, 10 ],\n    [  2,  4, 16, 14,  4 ],\n    [  3,  1,  9, 18, 11 ],\n    [ 12, 14, 17, 18, 20 ],\n    [  7,  1,  3,  9,  5 ]\n];\n\n```\n\nOutput:\n\n```\n69\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show sum of first   **n**   cubes,   where **n < 50** (ie show 50 entries for n=0..49)"}, {"role": "assistant", "content": "```\nmy @sums_of_all_cubes = [\\+] ^Inf X** 3;\n\nsay .fmt('%7d') for @sums_of_all_cubes.head(50).batch(10);\n\n```\n\nOutput:\n\n```\n     0       1       9      36     100     225     441     784    1296    2025\n  3025    4356    6084    8281   11025   14400   18496   23409   29241   36100\n 44100   53361   64009   76176   90000  105625  123201  142884  164836  189225\n216225  246016  278784  314721  354025  396900  443556  494209  549081  608400\n672400  741321  815409  894916  980100 1071225 1168561 1272384 1382976 1500625\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nLet **p(i)** be a sequence of prime numbers. such that 2=p(1), 3=p(2), 5=p(3), ...\n  \nConsider the **p(1),p(3),p(5), ... ,p(i)**, for each **p(i) < 1,000** and **i** is odd.\n  \nLet **sum** be any prefix sum of these primesa.\n  \nIf **sum** is prime then print **i**, **p(i)** and **sum**."}, {"role": "assistant", "content": "```\nmy @odd  = grep { ++$ !%% 2 }, grep &is-prime, 2 ..^ 1000;\nmy @sums = [\\+] @odd;\n\nsay .fmt('%5d') for grep { .[2].is-prime }, ( (1,3…*) Z @odd Z @sums );\n\n```\n\nOutput:\n\n```\n    1     2     2\n    3     5     7\n   11    31    89\n   27   103   659\n   35   149  1181\n   67   331  5021\n   91   467  9923\n   95   499 10909\n   99   523 11941\n  119   653 17959\n  143   823 26879\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show here all positive integers **n** less than **100** where:\n\n* the sum of the digits of the square of **n** is prime; and\n* the sum of the digits of the cube of **n** is also prime.\n\nExample\n\n**16** satisfies the task descrption because 16 x 16 = 256 has a digit sum of 13 which is prime and\n16 x 16 x 16 = 4096 has a digit sum of 19 which is also prime."}, {"role": "assistant", "content": "```\nsay ^100 .grep: { .².comb.sum.is-prime && .³.comb.sum.is-prime }\n\n```\n\nOutput:\n\n```\n(16 17 25 28 34 37 47 52 64)\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program to find the sum of squares of a numeric vector.\n\nThe program should work on a zero-length vector (with an answer of   **0**).\n\nRelated task\n\n* Mean"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsay [+] map * ** 2, (3, 1, 4, 1, 5, 9);\n```\n\nIf this expression seems puzzling, note that `* ** 2` is equivalent to `{$^x ** 2}`— the leftmost asterisk is not the multiplication operator but the `Whatever` star, which specifies currying behavior.\nAnother convenient way to distribute the exponentiation is via the cross metaoperator, which\nas a list infix is looser than comma in precedence but tighter than the reduction list operator:\n\n```\nsay [+] <3 1 4 1 5 9> X** 2\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and show numbers   **n**   with property that the sum of the decimal digits of   **n**   is substring of   **n**,   where   **n   <   1,000**\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nsay \"{+$_} matching numbers\\n{.batch(10)».fmt('%3d').join: \"\\n\"}\" given (^1000).grep: { .contains: .comb.sum }\n\n```\n\nOutput:\n\n```\n48 matching numbers\n  0   1   2   3   4   5   6   7   8   9\n 10  20  30  40  50  60  70  80  90 100\n109 119 129 139 149 159 169 179 189 199\n200 300 400 500 600 700 800 900 910 911\n912 913 914 915 916 917 918 919\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShow on this page the first 20 prime sums of two consecutive integers.\n\nExtra credit\n\nShow the ten millionth such prime sum."}, {"role": "assistant", "content": "```\nmy @n-n1-triangular = map { $_, $_ + 1, $_ + ($_ + 1) }, ^Inf;\n\nmy @wanted = @n-n1-triangular.grep: *.[2].is-prime;\n\nprintf \"%2d + %2d = %2d\\n\", |.list for @wanted.head(20);\n\n```\n\nOutput:\n\n```\n 1 +  2 =  3\n 2 +  3 =  5\n 3 +  4 =  7\n 5 +  6 = 11\n 6 +  7 = 13\n 8 +  9 = 17\n 9 + 10 = 19\n11 + 12 = 23\n14 + 15 = 29\n15 + 16 = 31\n18 + 19 = 37\n20 + 21 = 41\n21 + 22 = 43\n23 + 24 = 47\n26 + 27 = 53\n29 + 30 = 59\n30 + 31 = 61\n33 + 34 = 67\n35 + 36 = 71\n36 + 37 = 73\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind solutions to the    *sum to one hundred*    puzzle.\n\nAdd (insert) the mathematical\noperators      **+**    or    **-**      (plus\nor minus)   before any of the digits in the\n  \ndecimal numeric string    **123456789**    such that the\nresulting mathematical expression adds up to a\n  \nparticular sum   (in this iconic case,   **100**).\n\nExample:\n\n```\n             123 + 4 - 5 + 67 - 89   =   100     \n\n```\n\nShow all output here.\n\n:   * Show all solutions that sum to    **100**\n    * Show the sum that has the maximum   *number*   of solutions   (from zero to infinity‡)\n    * Show the lowest positive sum that   *can't*   be expressed   (has no solutions),   using the rules for this task\n    * Show the ten highest numbers that can be expressed using the rules for this task   (extra credit)\n\n‡   (where   *infinity*   would be a relatively small   123,456,789)\n\nAn example of a sum that can't be expressed   (within the rules of this task)   is:   **5074**\n  \n(which,   of course,   isn't the lowest positive sum that can't be expressed)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.03\n\n```\nmy $sum = 100;\nmy $N   = 10;\nmy @ops = ['-', ''], |( [' + ', ' - ', ''] xx 8 );\nmy @str = [X~] map { .Slip }, ( @ops Z 1..9 );\nmy %sol = @str.classify: *.subst( ' - ', ' -', :g )\\\n                          .subst( ' + ',  ' ', :g ).words.sum;\n\nmy %count.push: %sol.map({ .value.elems => .key });\n\nmy $max-solutions    = %count.max( + *.key );\nmy $first-unsolvable = first { %sol{$_} :!exists }, 1..*;\nsub n-largest-sums (Int $n) { %sol.sort(-*.key)[^$n].fmt: \"%8s => %s\\n\" }\n\ngiven %sol{$sum}:p {\n    say \"{.value.elems} solutions for sum {.key}:\";\n    say \"    $_\" for .value.list;\n}\n\n.say for :$max-solutions, :$first-unsolvable, \"$N largest sums:\", n-largest-sums($N);\n\n```\n\nOutput:\n\n```\n12 solutions for sum 100:\n    -1 + 2 - 3 + 4 + 5 + 6 + 78 + 9\n    1 + 2 + 3 - 4 + 5 + 6 + 78 + 9\n    1 + 2 + 34 - 5 + 67 - 8 + 9\n    1 + 23 - 4 + 5 + 6 + 78 - 9\n    1 + 23 - 4 + 56 + 7 + 8 + 9\n    12 + 3 + 4 + 5 - 6 - 7 + 89\n    12 + 3 - 4 + 5 + 67 + 8 + 9\n    12 - 3 - 4 + 5 - 6 + 7 + 89\n    123 + 4 - 5 + 67 - 89\n    123 + 45 - 67 + 8 - 9\n    123 - 4 - 5 - 6 - 7 + 8 - 9\n    123 - 45 - 67 + 89\nmax-solutions => 46 => [-9 9]\nfirst-unsolvable => 211\n10 largest sums:\n123456789 => 123456789\n 23456790 => 1 + 23456789\n 23456788 => -1 + 23456789\n 12345687 => 12345678 + 9\n 12345669 => 12345678 - 9\n  3456801 => 12 + 3456789\n  3456792 => 1 + 2 + 3456789\n  3456790 => -1 + 2 + 3456789\n  3456788 => 1 - 2 + 3456789\n  3456786 => -1 - 2 + 3456789\n```"}]}
{"messages": [{"role": "user", "content": "There are several ways to generate a self-referential sequence. One very common one (the Look-and-say sequence) is to start with a positive integer, then generate the next term by concatenating enumerated groups of adjacent alike digits:\n\n```\n       0, 10, 1110, 3110, 132110, 1113122110, 311311222110 ...\n\n```\n\nThe terms generated grow in length geometrically and never converge.\n\nAnother way to generate a self-referential sequence is to summarize the previous term.\n\nCount how many of each alike digit there is, then concatenate the sum and digit for each of the sorted enumerated digits. Note that the first five terms are the same as for the previous sequence.\n\n```\n       0, 10, 1110, 3110, 132110, 13123110, 23124110 ... \n\n```\n\nSort the digits largest to smallest. Do not include counts of digits that do not appear in the previous term.\n\nDepending on the seed value, series generated this way always either converge to a stable value or to a short cyclical pattern. (For our purposes, I'll use converge to mean an element matches a previously seen element.) The sequence shown, with a seed value of 0, converges to a stable value of 1433223110 after 11 iterations. The seed value that converges most quickly is 22. It goes stable after the first element. (The next element is 22, which has been seen before.)\n\nTask\n\nFind all the positive integer seed values under 1000000, for the above convergent self-referential sequence, that takes the largest number of iterations before converging. Then print out the number of iterations and the sequence they return. Note that different permutations of the digits of the seed will yield the same sequence. For this task, assume leading zeros are not permitted.\n\n```\nSeed Value(s): 9009 9090 9900\n\nIterations: 21 \n\nSequence: (same for all three seeds except for first element)\n9009\n2920\n192210\n19222110\n19323110\n1923123110\n1923224110\n191413323110\n191433125110\n19151423125110\n19251413226110\n1916151413325110\n1916251423127110\n191716151413326110\n191726151423128110\n19181716151413327110\n19182716151423129110\n29181716151413328110\n19281716151423228110\n19281716151413427110\n19182716152413228110\n\n```\n\nRelated tasks\n\n* Fours is the number of letters in the ...\n* Look-and-say sequence\n* Number names\n* Self-describing numbers\n* Spelling of ordinal numbers\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet\n\nAlso see\n\n* The On-Line Encyclopedia of Integer Sequences."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\n```\nmy @list;\nmy $longest = 0;\nmy %seen;\n\nfor 1 .. 1000000 -> $m {\n    next unless $m ~~ /0/;         # seed must have a zero\n    my $j = join '', $m.comb.sort;\n    next if %seen{$j}:exists;      # already tested a permutation\n    %seen{$j} = '';\n    my @seq = converging($m);\n    my %elems;\n    my $count;\n    for @seq[] -> $value { last if ++%elems{$value} == 2; $count++; };\n    if $longest == $count {\n        @list.push($m);\n    }\n    elsif $longest < $count {\n        $longest = $count;\n        @list = $m;\n        print \"\\b\" x 20, \"$count, $m\"; # monitor progress\n    }\n};\n\nfor @list -> $m {\n    say \"\\nSeed Value(s): \", my $seeds = ~permutations($m).unique.grep( { .substr(0,1) != 0 } );\n    my @seq = converging($m);\n    my %elems;\n    my $count;\n    for @seq[] -> $value { last if ++%elems{$value} == 2; $count++; };\n    say \"\\nIterations: \", $count;\n    say \"\\nSequence: (Only one shown per permutation group.)\";\n   .say for |@seq[^$count], \"\\n\";\n}\n\nsub converging ($seed) { return $seed, -> $l { join '', map { $_.value.elems~$_.key }, $l.comb.classify({$^b}).sort: {-$^c.key} } ... * }\n\nsub permutations ($string, $sofar? = '' ) {\n    return $sofar unless $string.chars;\n    my @perms;\n    for ^$string.chars -> $idx {\n        my $this = $string.substr(0,$idx)~$string.substr($idx+1);\n        my $char = substr($string, $idx,1);\n        @perms.push( |permutations( $this, join '', $sofar, $char ) );\n    }\n    return @perms;\n}\n\n```\n\nOutput:\n\n```\nSeed Value(s): 9009 9090 9900\n\nIterations: 21\n\nSequence: (Only one shown per permutation group.)\n9009\n2920\n192210\n19222110\n19323110\n1923123110\n1923224110\n191413323110\n191433125110\n19151423125110\n19251413226110\n1916151413325110\n1916251423127110\n191716151413326110\n191726151423128110\n19181716151413327110\n19182716151423129110\n29181716151413328110\n19281716151423228110\n19281716151413427110\n19182716152413228110\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nConsidering in order of length, n, all sequences of consecutive\nprimes, p, from 2 onwards, where p < 1000 and n>0, select those\nsequences whose sum is prime, and for these display the length of the\nsequence, the last item in the sequence, and the sum."}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\n\nmy @primes    = grep *.is-prime, ^Inf;\nmy @primesums = [\\+] @primes;\nsay \"{.elems} cumulative prime sums:\\n\",\n    .map( -> $p {\n        sprintf \"The sum of the first %3d (up to {@primes[$p]}) is prime: %s\",\n        1 + $p, comma @primesums[$p]\n      }\n    ).join(\"\\n\")\n    given grep { @primesums[$_].is-prime }, ^1000;\n\n```\n\nOutput:\n\n```\n76 cumulative prime sums:\nThe sum of the first   1 (up to 2) is prime: 2\nThe sum of the first   2 (up to 3) is prime: 5\nThe sum of the first   4 (up to 7) is prime: 17\nThe sum of the first   6 (up to 13) is prime: 41\nThe sum of the first  12 (up to 37) is prime: 197\nThe sum of the first  14 (up to 43) is prime: 281\nThe sum of the first  60 (up to 281) is prime: 7,699\nThe sum of the first  64 (up to 311) is prime: 8,893\nThe sum of the first  96 (up to 503) is prime: 22,039\nThe sum of the first 100 (up to 541) is prime: 24,133\nThe sum of the first 102 (up to 557) is prime: 25,237\nThe sum of the first 108 (up to 593) is prime: 28,697\nThe sum of the first 114 (up to 619) is prime: 32,353\nThe sum of the first 122 (up to 673) is prime: 37,561\nThe sum of the first 124 (up to 683) is prime: 38,921\nThe sum of the first 130 (up to 733) is prime: 43,201\nThe sum of the first 132 (up to 743) is prime: 44,683\nThe sum of the first 146 (up to 839) is prime: 55,837\nThe sum of the first 152 (up to 881) is prime: 61,027\nThe sum of the first 158 (up to 929) is prime: 66,463\nThe sum of the first 162 (up to 953) is prime: 70,241\nThe sum of the first 178 (up to 1061) is prime: 86,453\nThe sum of the first 192 (up to 1163) is prime: 102,001\nThe sum of the first 198 (up to 1213) is prime: 109,147\nThe sum of the first 204 (up to 1249) is prime: 116,533\nThe sum of the first 206 (up to 1277) is prime: 119,069\nThe sum of the first 208 (up to 1283) is prime: 121,631\nThe sum of the first 214 (up to 1307) is prime: 129,419\nThe sum of the first 216 (up to 1321) is prime: 132,059\nThe sum of the first 296 (up to 1949) is prime: 263,171\nThe sum of the first 308 (up to 2029) is prime: 287,137\nThe sum of the first 326 (up to 2161) is prime: 325,019\nThe sum of the first 328 (up to 2203) is prime: 329,401\nThe sum of the first 330 (up to 2213) is prime: 333,821\nThe sum of the first 332 (up to 2237) is prime: 338,279\nThe sum of the first 334 (up to 2243) is prime: 342,761\nThe sum of the first 342 (up to 2297) is prime: 360,979\nThe sum of the first 350 (up to 2357) is prime: 379,667\nThe sum of the first 356 (up to 2393) is prime: 393,961\nThe sum of the first 358 (up to 2411) is prime: 398,771\nThe sum of the first 426 (up to 2957) is prime: 581,921\nThe sum of the first 446 (up to 3137) is prime: 642,869\nThe sum of the first 458 (up to 3251) is prime: 681,257\nThe sum of the first 460 (up to 3257) is prime: 687,767\nThe sum of the first 464 (up to 3301) is prime: 700,897\nThe sum of the first 480 (up to 3413) is prime: 754,573\nThe sum of the first 484 (up to 3461) is prime: 768,373\nThe sum of the first 488 (up to 3491) is prime: 782,263\nThe sum of the first 512 (up to 3671) is prime: 868,151\nThe sum of the first 530 (up to 3821) is prime: 935,507\nThe sum of the first 536 (up to 3863) is prime: 958,577\nThe sum of the first 548 (up to 3947) is prime: 1,005,551\nThe sum of the first 568 (up to 4129) is prime: 1,086,557\nThe sum of the first 620 (up to 4583) is prime: 1,313,041\nThe sum of the first 630 (up to 4657) is prime: 1,359,329\nThe sum of the first 676 (up to 5051) is prime: 1,583,293\nThe sum of the first 680 (up to 5087) is prime: 1,603,597\nThe sum of the first 696 (up to 5233) is prime: 1,686,239\nThe sum of the first 708 (up to 5351) is prime: 1,749,833\nThe sum of the first 734 (up to 5563) is prime: 1,891,889\nThe sum of the first 762 (up to 5807) is prime: 2,051,167\nThe sum of the first 768 (up to 5849) is prime: 2,086,159\nThe sum of the first 776 (up to 5897) is prime: 2,133,121\nThe sum of the first 780 (up to 5939) is prime: 2,156,813\nThe sum of the first 784 (up to 6007) is prime: 2,180,741\nThe sum of the first 808 (up to 6211) is prime: 2,327,399\nThe sum of the first 814 (up to 6263) is prime: 2,364,833\nThe sum of the first 820 (up to 6301) is prime: 2,402,537\nThe sum of the first 836 (up to 6427) is prime: 2,504,323\nThe sum of the first 844 (up to 6529) is prime: 2,556,187\nThe sum of the first 848 (up to 6563) is prime: 2,582,401\nThe sum of the first 852 (up to 6581) is prime: 2,608,699\nThe sum of the first 926 (up to 7243) is prime: 3,120,833\nThe sum of the first 942 (up to 7433) is prime: 3,238,237\nThe sum of the first 984 (up to 7757) is prime: 3,557,303\nThe sum of the first 992 (up to 7853) is prime: 3,619,807\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nThe task description is taken from Project Euler (https://projecteuler.net/problem=10)\n  \nThe sum of the primes below 10 is 2 + 3 + 5 + 7 = 17\n  \nFind the sum of all the primes below **two million**"}, {"role": "assistant", "content": "Slow, but only using compiler built-ins (about 5 seconds)\n\n```\nsay sum (^2e6).grep: {.&is-prime};\n\n```\n\nOutput:\n\n```\n142913828922\n```\n\nMuch faster using external libraries (well under half a second)\n\n```\nuse Math::Primesieve;\nmy $sieve = Math::Primesieve.new;\nsay sum $sieve.primes(2e6.Int);\n\n```\n\nSame output"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nDraw a Sunflower fractal"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.06\n\nThis is not really a fractal. It is more accurately an example of a Fibonacci spiral or Phi-packing.\n\nOr, to be completely accurate: It is a variation of a generative Fermat's spiral using the Vogel model to implement phi-packing. See: https://thatsmaths.com/2014/06/05/sunflowers-and-fibonacci-models-of-efficiency\n\n```\nuse SVG;\n\nmy $seeds  = 3000;\nmy @center = 300, 300;\nmy $scale  = 5;\n\nconstant \\φ = (3 - 5.sqrt) / 2;\n\nmy @c = map {\n    my ($x, $y) = ($scale * .sqrt) «*« |cis($_ * φ * τ).reals »+« @center;\n    [ $x.round(.01), $y.round(.01), (.sqrt * $scale / 100).round(.1) ]\n}, 1 .. $seeds;\n\nsay SVG.serialize(\n    svg => [\n        :600width, :600height, :style<stroke:yellow>,\n        :rect[:width<100%>, :height<100%>, :fill<black>],\n        |@c.map( { :circle[:cx(.[0]), :cy(.[1]), :r(.[2])] } ),\n    ],\n);\n\n```\n\nSee: Phi packing (SVG image)"}]}
{"messages": [{"role": "user", "content": "A super-d number is a positive, decimal (base ten) integer   **n**   such that   **d × nd**   has at least   **d**   consecutive digits   **d**   where\n\n```\n   2 ≤ d ≤ 9\n\n```\n\nFor instance, 753 is a super-3 number because 3 × 7533 = 1280873331.\n\n**Super-d**   numbers are also shown on   **MathWorld**™   as   **super-*d***    or   **super-*d***.\n\nTask\n:   * Write a function/procedure/routine to find super-d numbers.\n    * For   **d=2**   through   **d=6**,   use the routine to show the first   **10**   super-d numbers.\n\nExtra credit\n:   * Show the first   **10**   super-7, super-8, and/or super-9 numbers   (optional).\n\nSee also\n:   * Wolfram MathWorld - Super-d Number.\n    * OEIS: A014569 - Super-3 Numbers."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\n2 - 6 take a few seconds, 7 about 17 seconds, 8 about 90... 9, bleh... around 700 seconds.\n\n```\nsub super (\\d) {\n    my \\run = d x d;\n    ^∞ .hyper.grep: -> \\n { (d * n ** d).Str.contains: run }\n}\n\n(2..9).race(:1batch).map: {\n    my $now = now;\n    put \"\\nFirst 10 super-$_ numbers:\\n{.&super[^10]}\\n{(now - $now).round(.1)} sec.\"\n}\n\n```\n\n```\nFirst 10 super-2 numbers:\n19 31 69 81 105 106 107 119 127 131\n0.1 sec.\n\nFirst 10 super-3 numbers:\n261 462 471 481 558 753 1036 1046 1471 1645\n0.1 sec.\n\nFirst 10 super-4 numbers:\n1168 4972 7423 7752 8431 10267 11317 11487 11549 11680\n0.3 sec.\n\nFirst 10 super-5 numbers:\n4602 5517 7539 12955 14555 20137 20379 26629 32767 35689\n0.6 sec.\n\nFirst 10 super-6 numbers:\n27257 272570 302693 323576 364509 502785 513675 537771 676657 678146\n5.2 sec.\n\nFirst 10 super-7 numbers:\n140997 490996 1184321 1259609 1409970 1783166 1886654 1977538 2457756 2714763\n17.1 sec.\n\nFirst 10 super-8 numbers:\n185423 641519 1551728 1854230 6415190 12043464 12147605 15517280 16561735 18542300\n92.1 sec.\n\nFirst 10 super-9 numbers:\n17546133 32613656 93568867 107225764 109255734 113315082 121251742 175461330 180917907 182557181\n704.7 sec.\n```"}]}
{"messages": [{"role": "user", "content": "A super-Poulet number is a Poulet number (or Fermat pseudoprime to base 2) whose every divisor ***d*** evenly divides ***2d − 2***.\n\nTask\n\n* Find and display the first **20** super-Poulet numbers.\n\nStretch\n\n* Find and display the index and value of the first super-Poulet number greater than one million.\n\nSee also\n\n* Task: Fermat pseudoprimes * Wikipedia: super-Poulet number * OEIS:A050217 - super-Poulet numbers"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\nuse Lingua::EN::Numbers;\n\nmy @poulet = lazy (2..*).hyper(:2000batch).grep: { !.is-prime && (1 == expmod 2, $_ - 1, $_) }\nmy @super-poulet = @poulet.grep: { all .&divisors.skip(1).map: { 2 == expmod 2, $_, $_ } }\n\nsay \"First 20 super-Poulet numbers:\\n\" ~ @super-poulet[^20].gist;\n\nfor 1e6.Int, 1e7.Int -> $threshold {\n    say \"\\nIndex and value of first super-Poulet greater than {$threshold.&cardinal}:\";\n    my $index = @super-poulet.first: * > $threshold, :k;\n    say \"{(1+$index).&ordinal-digit} super-Poulet number == \" ~ @super-poulet[$index].&comma;\n}\n\n```\n\nOutput:\n\n```\nFirst 20 super-Poulet numbers:\n(341 1387 2047 2701 3277 4033 4369 4681 5461 7957 8321 10261 13747 14491 15709 18721 19951 23377 31417 31609)\n\nIndex and value of first super-Poulet greater than one million:\n109th super-Poulet number == 1,016,801\n\nIndex and value of first super-Poulet greater than ten million:\n317th super-Poulet number == 10,031,653\n\n```"}]}
{"messages": [{"role": "user", "content": "A superellipse is a geometric figure defined as the set of all points (x, y) with\n\n:   :   :   |\n\n\n            x\n            a\n            |\n\n            n\n\n            +\n\n\n            |\n\n\n            y\n            b\n            |\n\n            n\n\n            =\n            1\n            ,\n            {\\displaystyle {\\displaystyle \\left|{\\frac {x}{a}}\\right|^{n}\\!+\\left|{\\frac {y}{b}}\\right|^{n}\\!=1,}}\n\nwhere *n*, *a*, and *b* are positive numbers.\n\nTask\n\nDraw a superellipse with n = 2.5, and a = b = 200"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy (\\a, \\b, \\n) = 200, 200, 2.5;\n\n# y in terms of x\nsub y ($x) { floor b × (1 - ($x/a).abs ** n ) ** (1/n) }\n\n# find point pairs for one quadrant\nmy @q = flat map -> \\x { x, y(x) }, ^(a+1);\n\nmy $out = open('superellipse.svg', :w);\n$out.print: [~] qq|<svg height=\"{b×2}\" width=\"{a×2}\" xmlns=\"http://www.w3.org/2000/svg\">\\n|,\n  pline( @q ),\n  pline( @q «×» < 1 -1> ), # flip and mirror\n  pline( @q «×» <-1 -1> ), # for the other\n  pline( @q «×» <-1  1> ), # three quadrants\n  '</svg>';\n\nsub pline (@q) {\n  qq|<polyline points=\"{@q}\"\n  style=\"fill:none;stroke:black;stroke-width:3\"\n  transform=\"translate({a}, {b})\" />\\n|\n}\n\n```\n\nSuperellipse (offsite image)"}]}
{"messages": [{"role": "user", "content": "A superpermutation of N different characters is a string consisting of an arrangement of multiple copies of those N different characters in which every permutation of those characters can be found as a substring.\n\nFor example, representing the characters as A..Z, using N=2 we choose to use the first two characters 'AB'.   \nThe permutations of 'AB' are the two, (i.e. two-factorial), strings: 'AB' and 'BA'.\n\nA too obvious method of generating a superpermutation is to just join all the permutations together forming 'ABBA'.\n\nA little thought will produce the shorter (in fact the shortest) superpermutation of 'ABA' - it contains 'AB' at the beginning and contains 'BA' from the middle to the end.\n\nThe \"too obvious\" method of creation generates a string of length N!\\*N. Using this as a yardstick, the task is to investigate other methods of generating superpermutations of N from 1-to-7 characters, that never generate larger superpermutations.\n\nShow descriptions and comparisons of algorithms used here, and select the \"Best\" algorithm as being the one generating shorter superpermutations.\n\nThe problem of generating the shortest superpermutation for each N *might* be NP complete, although the minimal strings for small values of N have been found by brute -force searches.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet\n\nReference\n\n* The Minimal Superpermutation Problem. by Nathaniel Johnston.\n* oeis A180632 gives 0-5 as 0, 1, 3, 9, 33, 153. 6 is thought to be 872.\n* Superpermutations - Numberphile. A video\n* Superpermutations: the maths problem solved by 4chan - Standupmaths. A video of recent (2018) mathematical progress.\n* New Superpermutations Discovered! Standupmaths & Numberphile."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nfor 1..8 -> $len {\n  my $pre = my $post = my $t = '';\n  for  ('a'..'z')[^$len].permutations -> @p {\n     $t = @p.join('');\n     $post ~= $t        unless index($post, $t);\n     $pre   = $t ~ $pre unless index($pre,  $t);\n  }\n  printf \"%1d: %8d %8d\\n\", $len, $pre.chars, $post.chars;\n}\n\n```\n\nOutput:\n\n```\n1:        1        1\n2:        4        4\n3:       12       15\n4:       48       64\n5:      240      325\n6:     1440     1956\n7:    10080    13699\n8:    80640   109600\n```"}]}
{"messages": [{"role": "user", "content": "The   Sutherland-Hodgman clipping algorithm   finds the polygon that is the intersection between an arbitrary polygon (the “subject polygon”) and a convex polygon (the “clip polygon”).\n\nIt is used in computer graphics (especially 2D graphics) to reduce the complexity of a scene being displayed by eliminating parts of a polygon that do not need to be displayed.\n\nTask\n\nTake the closed polygon defined by the points:\n\n:   [\n    (\n    50\n    ,\n    150\n    )\n    ,\n    (\n    200\n    ,\n    50\n    )\n    ,\n    (\n    350\n    ,\n    150\n    )\n    ,\n    (\n    350\n    ,\n    300\n    )\n    ,\n    (\n    250\n    ,\n    300\n    )\n    ,\n    (\n    200\n    ,\n    250\n    )\n    ,\n    (\n    150\n    ,\n    350\n    )\n    ,\n    (\n    100\n    ,\n    250\n    )\n    ,\n    (\n    100\n    ,\n    200\n    )\n    ]\n    {\\displaystyle {\\displaystyle [(50,150),(200,50),(350,150),(350,300),(250,300),(200,250),(150,350),(100,250),(100,200)]}}\n\nand clip it by the rectangle defined by the points:\n\n:   [\n    (\n    100\n    ,\n    100\n    )\n    ,\n    (\n    300\n    ,\n    100\n    )\n    ,\n    (\n    300\n    ,\n    300\n    )\n    ,\n    (\n    100\n    ,\n    300\n    )\n    ]\n    {\\displaystyle {\\displaystyle [(100,100),(300,100),(300,300),(100,300)]}}\n\nPrint the sequence of points that define the resulting clipped polygon.\n\nExtra credit\n\nDisplay all three polygons on a graphical surface, using a different color for each polygon and filling the resulting polygon.\n\n(When displaying you may use either a north-west or a south-west origin, whichever is more convenient for your display mechanism.)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\n**Translation of**: Sidef\n\n```\nsub intersection ($L11, $L12, $L21, $L22) {\n    my ($Δ1x, $Δ1y) = $L11 »-« $L12;\n    my ($Δ2x, $Δ2y) = $L21 »-« $L22;\n    my $n1 = $L11[0] * $L12[1] - $L11[1] * $L12[0];\n    my $n2 = $L21[0] * $L22[1] - $L21[1] * $L22[0];\n    my $n3 = 1 / ($Δ1x * $Δ2y - $Δ2x * $Δ1y);\n    (($n1 * $Δ2x - $n2 * $Δ1x) * $n3, ($n1 * $Δ2y - $n2 * $Δ1y) * $n3)\n}\n\n\nsub is-inside ($p1, $p2, $p3) {\n    ($p2[0] - $p1[0]) * ($p3[1] - $p1[1]) > ($p2[1] - $p1[1]) * ($p3[0] - $p1[0])\n}\n\nsub sutherland-hodgman (@polygon, @clip) {\n    my @output = @polygon;\n    my $clip-point1 = @clip.tail;\n    for @clip -> $clip-point2 {\n        my @input = @output;\n        @output = ();\n        my $start = @input.tail;\n        for @input -> $end {\n            if is-inside($clip-point1, $clip-point2, $end) {\n                @output.push: intersection($clip-point1, $clip-point2, $start, $end)\n                  unless is-inside($clip-point1, $clip-point2, $start);\n                @output.push: $end;\n            } elsif is-inside($clip-point1, $clip-point2, $start) {\n                @output.push: intersection($clip-point1, $clip-point2, $start, $end);\n            }\n            $start = $end;\n        }\n        $clip-point1 = $clip-point2;\n    }\n    @output\n}\n\nmy @polygon = (50,  150), (200, 50),  (350, 150), (350, 300), (250, 300),\n              (200, 250), (150, 350), (100, 250), (100, 200);\n\nmy @clip    = (100, 100), (300, 100), (300, 300), (100, 300);\n\nmy @clipped = sutherland-hodgman(@polygon, @clip);\n\nsay \"Clipped polygon: \", @clipped;\n\n# Output an SVG as well as it is easier to visualize\nuse SVG;\nmy $outfile = 'Sutherland-Hodgman-polygon-clipping-perl6.svg'.IO.open(:w);\n$outfile.say: SVG.serialize(\n    svg => [\n        :400width, :400height,\n        :rect[ :400width, :400height, :fill<white> ],\n        :text[ :10x, :20y, \"Polygon (blue)\" ],\n        :text[ :10x, :35y, \"Clip port (green)\" ],\n        :text[ :10x, :50y, \"Clipped polygon (red)\" ],\n        :polyline[ :points(@polygon.join: ','), :style<stroke:blue>,  :fill<blue>,  :opacity<.3> ],\n        :polyline[ :points(   @clip.join: ','), :style<stroke:green>, :fill<green>, :opacity<.3> ],\n        :polyline[ :points(@clipped.join: ','), :style<stroke:red>,   :fill<red>,   :opacity<.5> ],\n    ],\n);\n\n```\n\nOutput:\n\n```\nClipped polygon: [(100 116.666667) (125 100) (275 100) (300 116.666667) (300 300) (250 300) (200 250) (175 300) (125 300) (100 250)]\n```\n\nAlso see output image: offsite SVG image"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Sylvester's sequence. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn number theory, **Sylvester's sequence** is an integer sequence in which each term of the sequence is the product of the previous terms, plus one.\n\nIts values grow doubly exponentially, and the sum of its reciprocals forms a series of unit fractions that converges to **1** more rapidly than any other series of unit fractions with the same number of terms.\n\nFurther, the sum of the first **k** terms of the infinite series of reciprocals provides the closest possible underestimate of **1** by any k-term Egyptian fraction.\n\nTask\n\n* Write a routine (function, procedure, generator, whatever) to calculate **Sylvester's sequence**.\n* Use that routine to show the values of the first **10** elements in the sequence.\n* Show the sum of the reciprocals of the first **10** elements on the sequence, ideally as an exact fraction.\n\nRelated tasks\n\n* Egyptian fractions\n* Harmonic series\n\nSee also\n\n* OEIS A000058 - Sylvester's sequence"}, {"role": "assistant", "content": "```\nmy @S = {1 + [*] @S[^($++)]} … *;\n\nput 'First 10 elements of Sylvester\\'s sequence: ', @S[^10];\n\nsay \"\\nSum of the reciprocals of first 10 elements: \", sum @S[^10].map: { FatRat.new: 1, $_ };\n\n```\n\nOutput:\n\n```\nFirst 10 elements of Sylvester's sequence: 2 3 7 43 1807 3263443 10650056950807 113423713055421844361000443 12864938683278671740537145998360961546653259485195807 165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443\n\nSum of the reciprocals of first 10 elements: 0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999635\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven two sets *A* and *B*, compute \n\n(\nA\n∖\nB\n)\n∪\n(\nB\n∖\nA\n)\n.\n{\\displaystyle {\\displaystyle (A\\setminus B)\\cup (B\\setminus A).}}\n\nThat is, enumerate the items that are in *A* or *B* but not both. This set is called the symmetric difference of *A* and *B*.\n\nIn other words: \n\n(\nA\n∪\nB\n)\n∖\n(\nA\n∩\nB\n)\n{\\displaystyle {\\displaystyle (A\\cup B)\\setminus (A\\cap B)}}\n (the set of items that are in at least one of *A* or *B* minus the set of items that are in both *A* and *B*).\n\nOptionally, give the individual differences (\n\nA\n∖\nB\n{\\displaystyle {\\displaystyle A\\setminus B}}\n and \n\nB\n∖\nA\n{\\displaystyle {\\displaystyle B\\setminus A}}\n) as well.\n\nTest cases\n\n```\nA = {John, Bob, Mary, Serena}\nB = {Jim, Mary, John, Bob}\n\n```\n\nNotes\n\n1. If your code uses lists of items to represent sets then ensure duplicate items in lists are correctly handled. For example two lists representing sets of `a = [\"John\", \"Serena\", \"Bob\", \"Mary\", \"Serena\"]` and `b = [\"Jim\", \"Mary\", \"John\", \"Jim\", \"Bob\"]` should produce the result of just two strings: `[\"Serena\", \"Jim\"]`, in any order.\n2. In the mathematical notation above `A \\ B` gives the set of items in A that are not in B; `A ∪ B` gives the set of items in both A and B, (their *union*); and `A ∩ B` gives the set of items that are in both A and B (their *intersection*)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy \\A = set <John Serena Bob Mary Serena>;\nmy \\B = set <Jim Mary John Jim Bob>;\n\nsay  A ∖ B; # Set subtraction\nsay  B ∖ A; # Set subtraction\nsay (A ∪ B) ∖ (A ∩ B);  # Symmetric difference, via basic set operations\nsay  A ⊖ B;             # Symmetric difference, via dedicated operator\n\n```\n\nOutput:\n\n```\nset(Serena)\nset(Jim)\nset(Jim, Serena)\nset(Jim, Serena)\n```"}]}
{"messages": [{"role": "user", "content": "Sync subtitles\n\n**Sync subtitles**\n\nSometimes, when you download a movie, the subtitles are out of sync with the audio in this movie. Video players like VLC solve the problem, but it must be done manually.\n\nMake a program that takes the \"movie.srt\" file, and synchronizes the subtitles \"n\" seconds.\n\n* Try to fast-forward the subtitles by 9 seconds.\n* Try rolling back the subtitles by 9 seconds.\n\nTake the excerpt from the following subtitles file as an example:\n\n**movie.srt**\n\n```\n1\n00:01:31,550 --> 00:01:36,347\nFour billion years ago,\nthe first marine life forms.\n\n2\n00:01:36,555 --> 00:01:42,019\nFirst came the fish...then slowly\nother life forms evolved.\n\n3\n00:01:42,144 --> 00:01:43,979\nTherefore, our ancestors...\n\n4\n00:01:43,979 --> 00:01:45,898\n...came from fish.\n\n5\n00:01:46,232 --> 00:01:47,608\nEveryone, come and see this.\n\n6\n00:01:47,733 --> 00:01:50,361\nCretaceous Tyrannosaurus.\n\n7\n00:01:50,736 --> 00:01:52,488\nFerocious!\n\n8\n00:01:58,035 --> 00:01:58,869\nRed,\n\n9\n00:01:59,203 --> 00:02:00,079\nPong!\n\n10\n00:02:02,540 --> 00:02:03,999\nIsn't this a gecko?\n\n11\n00:02:04,416 --> 00:02:07,419\nHow else can I get a 15 ton T-Rex in here?\n\n12\n00:02:07,503 --> 00:02:11,048\nWith our advanced technology, I shrank it down.\n\n```\n\nReferences\n\n:   * Wikipedia: SubRip"}, {"role": "assistant", "content": "### Brutal\n\n```\n# 20240621 Raku programming solution\n\nsub MAIN() {\n   my @lines = $*IN.lines;\n   for 9, -9 -> $seconds {\n      say \"Original subtitle adjusted by {$seconds.fmt('%+d')} seconds.\";\n      for @lines -> $line {\n         if $line ~~ /(\\d ** 2 ':' \\d ** 2 ':' \\d ** 2 ',' \\d ** 3) ' --> ' (\\d ** 2 ':' \\d ** 2 ':' \\d ** 2 ',' \\d ** 3)/ {\n            my $start = adjust-time($0.Str, $seconds);\n            my $end   = adjust-time($1.Str, $seconds);\n            my $adjusted = $line;\n            $adjusted ~~ s/\\d ** 2 ':' \\d ** 2 ':' \\d ** 2 ',' \\d ** 3 ' --> ' \\d ** 2 ':' \\d ** 2 ':' \\d ** 2 ',' \\d ** 3/$start ~ ' --> ' ~ $end/.Str;\n            say $adjusted\n         } else {\n            say $line;\n         }\n      }\n      say()\n   }\n}\n\nsub adjust-time($time, $seconds) {\n   my ($time_str, $milliseconds_str) = $time.split(',');\n   my (\\hh, \\mm, \\ss) = $time_str.split(':')>>.Int;\n   my $milliseconds = $milliseconds_str.Int;\n   my $datetime = DateTime.new(:year,     :month,      :day, \n                               :hour(hh), :minute(mm), :second(ss));\n   given $datetime .= later(:seconds($seconds)) {\n      return sprintf('%02d:%02d:%02d,%03d',.hour,.minute,.second,$milliseconds)\n   }\n}\n\n```\n\nYou may Attempt This Online!\n\n### Less brutal\n\n```\n# 20240622 Raku programming solution\n\ngrammar SRT { # loc.gov/preservation/digital/formats/fdd/fdd000569.shtml\n   token TOP { ^ <subtitle>+ % \\n $ }\n   token subtitle { <index> \\n <timecode> \\n <text> \\n? }\n   token index { \\d+ }\n   token timecode { <timestamp> ' --> ' <timestamp> }\n   token timestamp { \\d ** 2 ':' \\d ** 2 ':' \\d ** 2 ',' \\d ** 3 }\n   token text { <line>+ % \\n }\n   token line { <-[\\n]>+ }\n}\n\nclass SRT::Actions { has @.subtitles;\n\n   method TOP($/) {\n      @.subtitles = $<subtitle>».made;\n      make @.subtitles\n   }\n\n   method subtitle($/) {\n      make {\n         index => $<index>.Str,\n         start => $<timecode><timestamp>[0].made,\n         end   => $<timecode><timestamp>[1].made,\n         text  => $<text>.made,\n      }\n   }\n\n   method timestamp($/) { make $/.Str }\n\n   method text($/) { make $<line>.join(\"\\n\") }\n}\n\nclass SubtitleAdjuster {\n\n    method adjust-time($time, $seconds) {\n       my ($time-str, $milliseconds-str) = $time.split(',');\n       my (\\hh, \\mm, \\ss) = $time-str.split(':')>>.Int;\n       my \\mls            = $milliseconds-str.Int;\n       my $datetime = DateTime.new( :year, :month, :day,\n                                    :hour(hh), :minute(mm), :second(ss));\n       given $datetime .= later(:seconds($seconds)) {\n          return sprintf('%02d:%02d:%02d,%03d', .hour, .minute, .second, mls)\n       }\n   }\n\n   method adjust-subtitles(@subtitles, Int $seconds) {\n      @subtitles.map({\n         $_<start> = self.adjust-time($_<start>, $seconds);\n         $_<end>   = self.adjust-time($_<end>, $seconds);\n         $_;\n      });\n   }\n\n   method format-srt(@subtitles) {\n      @subtitles.map({\n         $_<index> ~ \"\\n\"\n         ~ $_<start> ~ \" --> \" ~ $_<end> ~ \"\\n\"\n         ~ $_<text> ~ \"\\n\"\n      }).join(\"\\n\");\n   }\n}\n\nmy $srt-content = $*IN.slurp;\nmy $parsed = SRT.parse($srt-content, :actions(SRT::Actions.new));\nmy @subtitles = $parsed.made;\n\nmy $adjuster = SubtitleAdjuster.new;\n\nfor 9, -9 -> \\N {\n   my @adjusted-subtitles = $adjuster.adjust-subtitles(@subtitles.deepmap(*.clone), N);\n   say \"Original subtitle adjusted by {N.fmt('%+d')} seconds.\";\n   say $adjuster.format-srt(@adjusted-subtitles);\n}\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "The goal of this task is to create two concurrent activities (\"Threads\" or \"Tasks\", not processes.) that share data synchronously. Your language may provide syntax or libraries to perform concurrency. Different languages provide different implementations of concurrency, often with different names. Some languages use the term threads, others use the term tasks, while others use co-processes. This task should not be implemented using fork, spawn, or the Linux/UNIX/Win32 pipe command, as communication should be between threads, not processes.\n\nOne of the concurrent units will read from a file named \"input.txt\" and send the contents of that file, one line at a time, to the other concurrent unit, which will print the line it receives to standard output. The printing unit must count the number of lines it prints. After the concurrent unit reading the file sends its last line to the printing unit, the reading unit will request the number of lines printed by the printing unit. The reading unit will then print the number of lines printed by the printing unit.\n\nThis task requires two-way communication between the concurrent units. All concurrent units must cleanly terminate at the end of the program."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2013-02-27\n\n```\nsub MAIN ($infile) {\n    $infile.IO.lines ==> printer() ==> my $count;\n    say \"printed $count lines\";\n}\n\nsub printer(*@lines) {\n    my $lines;\n    for @lines {\n\t.say;\n\t++$lines;\n    }\n    $lines;\n}\n\n```\n\nConcurrent units are established by use of the feed operator, which works much like an in-process object pipe. Since the final feed goes to a variable declaration that belongs to the outer thread, it serves as a backchannel from the printer thread. In this case the outer thread signals the desire for a line count by terminating the pipe to the printing thread.\n(Note: soon these will be implemented with real threads in Raku, but this is currently emulated with coroutine semantics, aka lazy lists.)"}]}
{"messages": [{"role": "user", "content": "Task\n\nOutput the system **time**   (any units will do as long as they are noted) either by a system command or one built into the language.\n\nThe system time can be used for debugging, network information, random number seeds, or something as simple as program performance.\n\nRelated task\n\n* Date format\n\nSee also\n\n* Retrieving system time (wiki)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsay DateTime.now;\ndd DateTime.now.Instant;\n```\n\nOutput:\n\n```\n 2015-11-02T13:34:09+01:00\n Instant $var = Instant.new(<2159577143734/1493>)\n\n```"}]}
{"messages": [{"role": "user", "content": "*Szymański's algorithm* is a mutual exclusion algorithm devised by computer scientist Bolesław Szymański.\n\nThe algorithm allows mutiple processes or tasks to access a serial resource without conflict, using only linear waiting times.\nIt has application in multitasking and communications, especially if there is a need for massive parallelism with limited\nwaiting times for access to resources by the parallel program's components.\n\nTask\n\n* Implement Szymanski's algorithm utilizing parallel processes, threads, or similar coroutines.\n* Your example should implement the steps shown in the Wikipedia's pseudocode at the Wikipedia reference below.\n\nSee also\n\n* [Wikipedia entry for Szymański's algorithm] * [ACM digital entry for Szymański's paper]\n\n\"\"\"\nSzymański's algorithm reference:\nBoleslaw K. Szymanski. A simple solution to Lamport's concurrent programming problem with linear wait.\nProceedings of the 2nd International Conference on Supercomputing, 1988, Figure 2, Page 624.\nhttps://dl.acm.org/doi/pdf/10.1145/55364.55425\nhttps://en.wikipedia.org/wiki/Szyma%C5%84ski%27s\\_algorithm\n\"\"\""}, {"role": "assistant", "content": "```\n# 20230822 Raku programming solution\n\nuse OO::Monitors;\n\nmy \\N = 10;\n\nmonitor Szymański {\n\n   has @.tasks;\n   my $critical = 0;\n\n   method runSzymański($id) {\n      @.tasks[$id] = 1; \n      ( my @others = @.tasks ).splice: $id,1;\n      until @others.all ~~ 0|1|2 { $*THREAD.yield }\n      @.tasks[$id] = 3; \n      if @others.any ~~ 1 {\n         @.tasks[$id] = 2;\n         until @others.any ~~ 4 { $*THREAD.yield }\n      }\n      @.tasks[$id] = 4;\n      until @.tasks[^$id].all ~~ 0|1 { $*THREAD.yield }\n      $critical = ((my $previous = $critical) + $id * 3) div 2;\n      say \"Thread $id changed the critical value from $previous to $critical\";\n      until @.tasks[$id^..*-1].all ~~ 0|1|4 { $*THREAD.yield }\n      @.tasks[$id] = 0\n   }\n}\n\nmy $flag = Szymański.new: tasks => 0 xx N;\nawait Promise.allof( ^N .pick(*).map: { start { $flag.runSzymański: $_ } } );\n\n```\n\nOutput:\n\n```\nThread 6 changed the critical value from 0 to 9\nThread 1 changed the critical value from 9 to 6\nThread 5 changed the critical value from 6 to 10\nThread 4 changed the critical value from 10 to 11\nThread 7 changed the critical value from 11 to 16\nThread 9 changed the critical value from 16 to 21\nThread 8 changed the critical value from 21 to 22\nThread 3 changed the critical value from 22 to 15\nThread 2 changed the critical value from 15 to 10\nThread 0 changed the critical value from 10 to 5\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a database table to exemplify most commonly used data types and options.\n\nRelated task\n\n* Table Creation - Address"}, {"role": "assistant", "content": "(formerly Perl 6)\nIn Raku, there is no 'database' type built in, so it is somewhat ambiguous when specifying 'create a database table'. Raku offers bindings to most common databases through its DBIish module but mostly abstracts away the differences between the underlying databases, which hides many of the finer distinctions of what may be stored where. The actual data types and options available are properties of the database used.\n\nIf on the other hand, we are meant to show built in collective types that may be used to hold tabular data, this may be of some use.\n\nIn general, a container type can hold objects of any data type, even instances of their own type; allowing 'multi-dimensional' (tabular) containers.\n\nRaku offers two broad categories of collective container types; those that do the Positional role and those that do Associative. Positional objects are collective objects that access the individual storage slots using an integer index. Associative objects use some sort of other pointer (typically string) to access their storage slots.\n\nThe various Associative types mostly differ in their value handling. Hash, Map and QuantHash may have any type of object as their value. All the others have some specific, usually numeric, type as their value.\n\n```\nPositional - Object that supports looking up values by integer index\n    Array     Sequence of itemized objects\n    List      Immutable sequence of objects\n\nAssociative - Object that supports looking up values by key (typically string)\n    Bag        Immutable collection of distinct objects with integer weights\n    BagHash    Mutable collection of distinct objects with integer weights\n    Hash       Mapping from strings to itemized values\n    Map        Immutable mapping from strings to values\n    Mix        Immutable collection of distinct objects with Real weights\n    MixHash    Mutable collection of distinct objects with Real weights\n    QuantHash  Collection of objects represented as hash keys\n    Set        Immutable collection of distinct objects, no value except 'present'\n    SetHash    Mutable collection of distinct objects, no value except 'present'\n\n```\n\nIf you want a persistent instance of any of these types, you need to declare the name with some scope constraint, but there are no prerequisites to creating instances. Simply assigning values to them will call them into existence."}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a table to store addresses.\n\nYou may assume that all the addresses to be stored will be located in the USA.   As such, you will need (in addition to a field holding a unique identifier) a field holding the street address, a field holding the city, a field holding the state code, and a field holding the zipcode.   Choose appropriate types for each field.\n\nFor non-database languages, show how you would open a connection to a database (your choice of which) and create an address table in it. You should follow the existing models here for how you would structure the table."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.09\n\nLike Perl DBI, Raku DBIish supports many different databases. An example using SQLite is shown here.\n\n```\nuse DBIish;\n\nmy $dbh = DBIish.connect('SQLite', :database<addresses.sqlite3>);\n\nmy $sth = $dbh.do(q:to/STATEMENT/);\n    DROP TABLE IF EXISTS Address;\n    CREATE TABLE Address (\n        addrID      INTEGER PRIMARY KEY AUTOINCREMENT,\n        addrStreet  TEXT NOT NULL,\n        addrCity    TEXT NOT NULL,\n        addrState   TEXT NOT NULL,\n        addrZIP     TEXT NOT NULL\n    )\n    STATEMENT\n\n```"}]}
{"messages": [{"role": "user", "content": "Invoking NOTES without commandline arguments displays the current contents of the local NOTES.TXT if it exists.\nIf NOTES has arguments, the current date and time are appended to the local NOTES.TXT followed by a newline.\nThen all the arguments, joined with spaces, prepended with a tab, and appended with a trailing newline, are written to NOTES.TXT.\nIf NOTES.TXT doesn't already exist in the current directory then a new NOTES.TXT file should be created."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $file = 'notes.txt';\n\nmulti MAIN() {\n    print slurp($file);\n}\n\nmulti MAIN(*@note) {\n    my $fh = open($file, :a);\n    $fh.say: DateTime.now, \"\\n\\t\", @note;\n    $fh.close;\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Graph. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nTarjan's algorithm is an algorithm in graph theory for finding the strongly connected components of a graph.\n\nIt runs in linear time, matching the time bound for alternative methods including Kosaraju's algorithm and the path-based strong component algorithm.\n\nTarjan's Algorithm is named for its discoverer, Robert Tarjan.\n\nReferences\n\n* The article on Wikipedia.\n\nSee also: Kosaraju"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\n```\nsub tarjan (%k) {\n    my %onstack;\n    my %index;\n    my %lowlink;\n    my @stack;\n    my @connected;\n\n    sub strong-connect ($vertex) {\n         state $index      = 0;\n         %index{$vertex}   = $index;\n         %lowlink{$vertex} = $index++;\n         %onstack{$vertex} = True;\n         @stack.push: $vertex;\n         for |%k{$vertex} -> $connection {\n             if not %index{$connection}.defined {\n                 strong-connect($connection);\n                 %lowlink{$vertex} min= %lowlink{$connection};\n             }\n             elsif %onstack{$connection} {\n                 %lowlink{$vertex} min= %index{$connection};\n             }\n        }\n        if %lowlink{$vertex} eq %index{$vertex} {\n            my @node;\n            repeat {\n                @node.push: @stack.pop;\n                %onstack{@node.tail} = False;\n            } while @node.tail ne $vertex;\n            @connected.push: @node;\n        }\n    }\n\n    .&strong-connect unless %index{$_} for %k.keys;\n\n    @connected\n}\n\n# TESTING\n\n-> $test { say \"\\nStrongly connected components: \", |tarjan($test).sort».sort } for\n\n# hash of vertex, edge list pairs\n(((1),(2),(0),(1,2,4),(3,5),(2,6),(5),(4,6,7)).pairs.hash),\n\n# Same layout test data with named vertices instead of numbered.\n%(:Andy<Bart>,\n  :Bart<Carl>,\n  :Carl<Andy>,\n  :Dave<Bart Carl Earl>,\n  :Earl<Dave Fred>,\n  :Fred<Carl Gary>,\n  :Gary<Fred>,\n  :Hank<Earl Gary Hank>\n)\n\n```\n\nOutput:\n\n```\nStrongly connected components: (0 1 2)(3 4)(5 6)(7)\n\nStrongly connected components: (Andy Bart Carl)(Dave Earl)(Fred Gary)(Hank)\n```"}]}
{"messages": [{"role": "user", "content": "Given a positive integer, count the number of its positive divisors.\n\nTask\n\nShow the result for the first   **100**   positive integers.\n\nRelated task\n\n* Tau number"}, {"role": "assistant", "content": "Yet more tasks that are tiny variations of each other. Tau function, Tau number, Sum of divisors and Product of divisors all use code with minimal changes. What the heck, post 'em all.\n\n```\nuse Prime::Factor:ver<0.3.0+>;\nuse Lingua::EN::Numbers;\n\nsay \"\\nTau function - first 100:\\n\",        # ID\n(1..*).map({ +.&divisors })[^100]\\          # the task\n.batch(20)».fmt(\"%3d\").join(\"\\n\");          # display formatting\n\nsay \"\\nTau numbers - first 100:\\n\",         # ID\n(1..*).grep({ $_ %% +.&divisors })[^100]\\   # the task\n.batch(10)».&comma».fmt(\"%5s\").join(\"\\n\");  # display formatting\n\nsay \"\\nDivisor sums - first 100:\\n\",        # ID\n(1..*).map({ [+] .&divisors })[^100]\\       # the task\n.batch(20)».fmt(\"%4d\").join(\"\\n\");          # display formatting\n\nsay \"\\nDivisor products - first 100:\\n\",    # ID\n(1..*).map({ [×] .&divisors })[^100]\\       # the task\n.batch(5)».&comma».fmt(\"%16s\").join(\"\\n\");  # display formatting\n\n```\n\nOutput:\n\n```\nTau function - first 100:\n  1   2   2   3   2   4   2   4   3   4   2   6   2   4   4   5   2   6   2   6\n  4   4   2   8   3   4   4   6   2   8   2   6   4   4   4   9   2   4   4   8\n  2   8   2   6   6   4   2  10   3   6   4   6   2   8   4   8   4   4   2  12\n  2   4   6   7   4   8   2   6   4   8   2  12   2   4   6   6   4   8   2  10\n  5   4   2  12   4   4   4   8   2  12   4   6   4   4   4  12   2   6   6   9\n\nTau numbers - first 100:\n    1     2     8     9    12    18    24    36    40    56\n   60    72    80    84    88    96   104   108   128   132\n  136   152   156   180   184   204   225   228   232   240\n  248   252   276   288   296   328   344   348   360   372\n  376   384   396   424   441   444   448   450   468   472\n  480   488   492   504   516   536   560   564   568   584\n  600   612   625   632   636   640   664   672   684   708\n  712   720   732   776   792   804   808   824   828   852\n  856   864   872   876   880   882   896   904   936   948\n  972   996 1,016 1,040 1,044 1,048 1,056 1,068 1,089 1,096\n\nDivisor sums - first 100:\n   1    3    4    7    6   12    8   15   13   18   12   28   14   24   24   31   18   39   20   42\n  32   36   24   60   31   42   40   56   30   72   32   63   48   54   48   91   38   60   56   90\n  42   96   44   84   78   72   48  124   57   93   72   98   54  120   72  120   80   90   60  168\n  62   96  104  127   84  144   68  126   96  144   72  195   74  114  124  140   96  168   80  186\n 121  126   84  224  108  132  120  180   90  234  112  168  128  144  120  252   98  171  156  217\n\nDivisor products - first 100:\n               1                2                3                8                5\n              36                7               64               27              100\n              11            1,728               13              196              225\n           1,024               17            5,832               19            8,000\n             441              484               23          331,776              125\n             676              729           21,952               29          810,000\n              31           32,768            1,089            1,156            1,225\n      10,077,696               37            1,444            1,521        2,560,000\n              41        3,111,696               43           85,184           91,125\n           2,116               47      254,803,968              343          125,000\n           2,601          140,608               53        8,503,056            3,025\n       9,834,496            3,249            3,364               59   46,656,000,000\n              61            3,844          250,047        2,097,152            4,225\n      18,974,736               67          314,432            4,761       24,010,000\n              71  139,314,069,504               73            5,476          421,875\n         438,976            5,929       37,015,056               79    3,276,800,000\n          59,049            6,724               83  351,298,031,616            7,225\n           7,396            7,569       59,969,536               89  531,441,000,000\n           8,281          778,688            8,649            8,836            9,025\n 782,757,789,696               97          941,192          970,299    1,000,000,000\n```"}]}
{"messages": [{"role": "user", "content": "A Tau number is a positive integer divisible by the count of its positive divisors.\n\nTask\n\nShow the first   **100**   Tau numbers.\nThe numbers shall be *generated* during run-time (i.e. the code may not contain string literals, sets/arrays of integers, or alike).\n\nRelated task\n\n* Tau function"}, {"role": "assistant", "content": "Yet more tasks that are tiny variations of each other. Tau function, Tau number, Sum of divisors and Product of divisors all use code with minimal changes. What the heck, post 'em all.\n\n```\nuse Prime::Factor:ver<0.3.0+>;\nuse Lingua::EN::Numbers;\n\nsay \"\\nTau function - first 100:\\n\",        # ID\n(1..*).map({ +.&divisors })[^100]\\          # the task\n.batch(20)».fmt(\"%3d\").join(\"\\n\");          # display formatting\n\nsay \"\\nTau numbers - first 100:\\n\",         # ID\n(1..*).grep({ $_ %% +.&divisors })[^100]\\   # the task\n.batch(10)».&comma».fmt(\"%5s\").join(\"\\n\");  # display formatting\n\nsay \"\\nDivisor sums - first 100:\\n\",        # ID\n(1..*).map({ [+] .&divisors })[^100]\\       # the task\n.batch(20)».fmt(\"%4d\").join(\"\\n\");          # display formatting\n\nsay \"\\nDivisor products - first 100:\\n\",    # ID\n(1..*).map({ [×] .&divisors })[^100]\\       # the task\n.batch(5)».&comma».fmt(\"%16s\").join(\"\\n\");  # display formatting\n\n```\n\nOutput:\n\n```\nTau function - first 100:\n  1   2   2   3   2   4   2   4   3   4   2   6   2   4   4   5   2   6   2   6\n  4   4   2   8   3   4   4   6   2   8   2   6   4   4   4   9   2   4   4   8\n  2   8   2   6   6   4   2  10   3   6   4   6   2   8   4   8   4   4   2  12\n  2   4   6   7   4   8   2   6   4   8   2  12   2   4   6   6   4   8   2  10\n  5   4   2  12   4   4   4   8   2  12   4   6   4   4   4  12   2   6   6   9\n\nTau numbers - first 100:\n    1     2     8     9    12    18    24    36    40    56\n   60    72    80    84    88    96   104   108   128   132\n  136   152   156   180   184   204   225   228   232   240\n  248   252   276   288   296   328   344   348   360   372\n  376   384   396   424   441   444   448   450   468   472\n  480   488   492   504   516   536   560   564   568   584\n  600   612   625   632   636   640   664   672   684   708\n  712   720   732   776   792   804   808   824   828   852\n  856   864   872   876   880   882   896   904   936   948\n  972   996 1,016 1,040 1,044 1,048 1,056 1,068 1,089 1,096\n\nDivisor sums - first 100:\n   1    3    4    7    6   12    8   15   13   18   12   28   14   24   24   31   18   39   20   42\n  32   36   24   60   31   42   40   56   30   72   32   63   48   54   48   91   38   60   56   90\n  42   96   44   84   78   72   48  124   57   93   72   98   54  120   72  120   80   90   60  168\n  62   96  104  127   84  144   68  126   96  144   72  195   74  114  124  140   96  168   80  186\n 121  126   84  224  108  132  120  180   90  234  112  168  128  144  120  252   98  171  156  217\n\nDivisor products - first 100:\n               1                2                3                8                5\n              36                7               64               27              100\n              11            1,728               13              196              225\n           1,024               17            5,832               19            8,000\n             441              484               23          331,776              125\n             676              729           21,952               29          810,000\n              31           32,768            1,089            1,156            1,225\n      10,077,696               37            1,444            1,521        2,560,000\n              41        3,111,696               43           85,184           91,125\n           2,116               47      254,803,968              343          125,000\n           2,601          140,608               53        8,503,056            3,025\n       9,834,496            3,249            3,364               59   46,656,000,000\n              61            3,844          250,047        2,097,152            4,225\n      18,974,736               67          314,432            4,761       24,010,000\n              71  139,314,069,504               73            5,476          421,875\n         438,976            5,929       37,015,056               79    3,276,800,000\n          59,049            6,724               83  351,298,031,616            7,225\n           7,396            7,569       59,969,536               89  531,441,000,000\n           8,281          778,688            8,649            8,836            9,025\n 782,757,789,696               97          941,192          970,299    1,000,000,000\n```"}]}
{"messages": [{"role": "user", "content": "A   taxicab number   (the definition that is being used here)   is a positive integer that can be expressed as the sum of two positive cubes in more than one way.\n\nThe first taxicab number is   **1729**,   which is:\n\n:   :   :   13   +   123       and also\n        :   93   +   103.\n\nTaxicab numbers are also known as:\n\n:   :   * taxi numbers\n        * taxi-cab numbers\n        * taxi cab numbers\n        * Hardy-Ramanujan numbers\n\nTask\n\n* Compute and display the lowest 25 taxicab numbers (in numeric order, and in a human-readable format).\n* For each of the taxicab numbers, show the number as well as it's constituent cubes.\n\nExtra credit\n\n* Show the 2,000th taxicab number, and a half dozen more\n\nSee also\n\n* A001235: taxicab numbers on The On-Line Encyclopedia of Integer Sequences.\n* Hardy-Ramanujan Number on MathWorld.\n* taxicab number on MathWorld.\n* taxicab number on Wikipedia   (includes the story on how taxi-cab numbers came to be called)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis uses a pretty simple search algorithm that doesn't necessarily return the Taxicab numbers in order. Assuming we want all the Taxicab numbers within some range S to N, we'll search until we find N values. When we find the Nth value, we continue to search up to the cube root of the largest Taxicab number found up to that point. That ensures we will find all of them inside the desired range without needing to search arbitrarily or use magic numbers. Defaults to returning the Taxicab numbers from 1 to 25. Pass in a different start and end value if you want some other range.\n\n```\nconstant @cu = (^Inf).map: { .³ }\n\nsub MAIN ($start = 1, $end = 25) {\n    my %taxi;\n    my int $taxis = 0;\n    my $terminate = 0;\n    my int $max = 0;\n\n    for 1 .. * -> $c1 {\n        last if ?$terminate && ($terminate < $c1);\n        for 1 .. $c1 -> $c2 {\n            my $this = @cu[$c1] + @cu[$c2];\n            %taxi{$this}.push: [$c2, $c1];\n            if %taxi{$this}.elems == 2 {\n                ++$taxis;\n                $max max= $this;\n            }\n    \t    $terminate = ceiling $max ** (1/3) if $taxis == $end and !$terminate;\n        }   \n    }\n\n    display( %taxi, $start, $end );\n\n}\n\nsub display (%this_stuff, $start, $end) {\n    my $i = $start;\n    printf \"%4d %10d  =>\\t%s\\n\", $i++, $_.key,\n        (.value.map({ sprintf \"%4d³ + %-s\\³\", |$_ })).join: \",\\t\"\n        for %this_stuff.grep( { $_.value.elems > 1 } ).sort( +*.key )[$start-1..$end-1];\n}\n\n```\n\nOutput:\n\nWith no passed parameters (default)\n\n```\n   1       1729  =>\t   9³ + 10³,\t   1³ + 12³\n   2       4104  =>\t   9³ + 15³,\t   2³ + 16³\n   3      13832  =>\t  18³ + 20³,\t   2³ + 24³\n   4      20683  =>\t  19³ + 24³,\t  10³ + 27³\n   5      32832  =>\t  18³ + 30³,\t   4³ + 32³\n   6      39312  =>\t  15³ + 33³,\t   2³ + 34³\n   7      40033  =>\t  16³ + 33³,\t   9³ + 34³\n   8      46683  =>\t  27³ + 30³,\t   3³ + 36³\n   9      64232  =>\t  26³ + 36³,\t  17³ + 39³\n  10      65728  =>\t  31³ + 33³,\t  12³ + 40³\n  11     110656  =>\t  36³ + 40³,\t   4³ + 48³\n  12     110808  =>\t  27³ + 45³,\t   6³ + 48³\n  13     134379  =>\t  38³ + 43³,\t  12³ + 51³\n  14     149389  =>\t  29³ + 50³,\t   8³ + 53³\n  15     165464  =>\t  38³ + 48³,\t  20³ + 54³\n  16     171288  =>\t  24³ + 54³,\t  17³ + 55³\n  17     195841  =>\t  22³ + 57³,\t   9³ + 58³\n  18     216027  =>\t  22³ + 59³,\t   3³ + 60³\n  19     216125  =>\t  45³ + 50³,\t   5³ + 60³\n  20     262656  =>\t  36³ + 60³,\t   8³ + 64³\n  21     314496  =>\t  30³ + 66³,\t   4³ + 68³\n  22     320264  =>\t  32³ + 66³,\t  18³ + 68³\n  23     327763  =>\t  51³ + 58³,\t  30³ + 67³\n  24     373464  =>\t  54³ + 60³,\t   6³ + 72³\n  25     402597  =>\t  56³ + 61³,\t  42³ + 69³\n```\n\nWith passed parameters 2000 2006:\n\n```\n2000 1671816384  =>\t 940³ + 944³,\t 428³ + 1168³\n2001 1672470592  =>\t 632³ + 1124³,\t  29³ + 1187³\n2002 1673170856  =>\t 828³ + 1034³,\t 458³ + 1164³\n2003 1675045225  =>\t 744³ + 1081³,\t 522³ + 1153³\n2004 1675958167  =>\t 711³ + 1096³,\t 492³ + 1159³\n2005 1676926719  =>\t 714³ + 1095³,\t  63³ + 1188³\n2006 1677646971  =>\t 891³ + 990³,\t  99³ + 1188³\n```"}]}
{"messages": [{"role": "user", "content": "On a set of coasters we have, there's a picture of a teacup.   On the rim of the teacup the word   **TEA**   appears a number of times separated by bullet characters   (•).\n\nIt occurred to me that if the bullet were removed and the words run together,   you could start at any letter and still end up with a meaningful three-letter word.\n\nSo start at the   **T**   and read   **TEA**.   Start at the   **E**   and read   **EAT**,   or start at the   **A**   and read   **ATE**.\n\nThat got me thinking that maybe there are other words that could be used rather that   **TEA**.   And that's just English.   What about Italian or Greek or ... um ... Telugu.\n\nFor English, we will use the unixdict (now) located at:   unixdict.txt.\n\n(This will maintain continuity with other Rosetta Code tasks that also use it.)\n\nTask\n\nSearch for a set of words that could be printed around the edge of a teacup.   The words in each set are to be of the same length, that length being greater than two (thus precluding   **AH**   and   **HA**,   for example.)\n\nHaving listed a set, for example   [**ate tea eat**],   refrain from displaying permutations of that set, e.g.:   [**eat tea ate**]   etc.\n\nThe words should also be made of more than one letter   (thus precluding   **III**   and   **OOO**   etc.)\n\nThe relationship between these words is (using ATE as an example) that the first letter of the first becomes the last letter of the second.   The first letter of the second becomes the last letter of the third.   So   **ATE**   becomes   **TEA**   and   **TEA**   becomes   **EAT**.\n\nAll of the possible permutations, using this particular permutation technique, must be words in the list.\n\nThe set you generate for   **ATE**   will never included the word   **ETA**   as that cannot be reached via the first-to-last movement method.\n\nDisplay one line for each set of teacup rim words.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.07.1\n\nThere doesn't seem to be any restriction that the word needs to consist only of lowercase letters, so words of any case are included. Since the example code specifically shows the example words (TEA, EAT, ATE) in uppercase, I elected to uppercase the found words.\n\nAs the specs keep changing, this version will accept ANY text file as its dictionary and accepts parameters to configure the minimum number of characters in a word to consider and whether to allow mono-character words.\n\nDefaults to unixdict.txt, minimum 3 characters and mono-character 'words' disallowed. Feed a file name to use a different word list, an integer to --min-chars and/or a truthy value to --mono to allow mono-chars.\n\n```\nmy %*SUB-MAIN-OPTS = :named-anywhere;\n\nunit sub MAIN ( $dict = 'unixdict.txt', :$min-chars = 3, :$mono = False );\n\nmy %words;\n$dict.IO.slurp.words.map: { .chars < $min-chars ?? (next) !! %words{.uc.comb.sort.join}.push: .uc };\n\nmy @teacups;\nmy %seen;\n\nfor %words.values -> @these {\n    next if !$mono && @these < 2;\n    MAYBE: for @these {\n        my $maybe = $_;\n        next if %seen{$_};\n        my @print;\n        for ^$maybe.chars {\n            if $maybe ∈ @these {\n                @print.push: $maybe;\n                $maybe = $maybe.comb.list.rotate.join;\n            } else {\n                @print = ();\n                next MAYBE\n            }\n        }\n        if @print.elems {\n            @teacups.push: @print;\n            %seen{$_}++ for @print;\n        }\n    }\n}\n\nsay .unique.join(\", \") for sort @teacups;\n\n```\n\nDefaults:\n\nCommand line: raku teacup.p6\n\n```\nAPT, PTA, TAP\nARC, RCA, CAR\nATE, TEA, EAT\n```\n\nAllow mono-chars:\n\nCommand line: raku teacup.p6 --mono=1\n\n```\nAAA\nAPT, PTA, TAP\nARC, RCA, CAR\nATE, TEA, EAT\nIII\n```\n\nUsing a larger dictionary:\n\nwords.txt file from https://github.com/dwyl/english-words\n\nCommand line: raku teacup.p6 words.txt --min-chars=4 --mono=Allow\n\n```\nAAAA\nAAAAAA\nADAD, DADA\nADAR, DARA, ARAD, RADA\nAGAG, GAGA\nALIT, LITA, ITAL, TALI\nAMAN, MANA, ANAM, NAMA\nAMAR, MARA, ARAM, RAMA\nAMEL, MELA, ELAM, LAME\nAMEN, MENA, ENAM, NAME\nAMOR, MORA, ORAM, RAMO\nANAN, NANA\nANIL, NILA, ILAN, LANI\nARAR, RARA\nARAS, RASA, ASAR, SARA\nARIS, RISA, ISAR, SARI\nASEL, SELA, ELAS, LASE\nASER, SERA, ERAS, RASE\nDENI, ENID, NIDE, IDEN\nDOLI, OLID, LIDO, IDOL\nEGOR, GORE, OREG, REGO\nENOL, NOLE, OLEN, LENO\nESOP, SOPE, OPES, PESO\nISIS, SISI\nMMMM\nMORO, OROM, ROMO, OMOR\nOOOO\n```"}]}
{"messages": [{"role": "user", "content": "There are quite a number of temperature scales. For this task we will concentrate on four of the perhaps best-known ones:\nKelvin, Celsius, Fahrenheit, and Rankine.\n\nThe Celsius and Kelvin scales have the same magnitude, but different null points.\n\n:   0 degrees Celsius corresponds to 273.15 kelvin.\n:   0 kelvin is absolute zero.\n\nThe Fahrenheit and Rankine scales also have the same magnitude, but different null points.\n\n:   0 degrees Fahrenheit corresponds to 459.67 degrees Rankine.\n:   0 degrees Rankine is absolute zero.\n\nThe Celsius/Kelvin and Fahrenheit/Rankine scales have a ratio of 5 : 9.\n\nTask\n\nWrite code that accepts a value of kelvin, converts it to values of the three other scales, and prints the result.\n\nExample\n\n```\nK  21.00\n\nC  -252.15\n\nF  -421.87\n\nR  37.80\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\nmy %scale =\n    Celcius    => { factor => 1  , offset => -273.15 },\n    Rankine    => { factor => 1.8, offset =>    0    },\n    Fahrenheit => { factor => 1.8, offset => -459.67 },\n;\n \nmy $kelvin = +prompt \"Enter a temperature in Kelvin: \";\ndie \"No such temperature!\" if $kelvin < 0;\n \nfor %scale.sort {\n    printf \"%12s: %7.2f\\n\", .key, $kelvin * .value<factor> + .value<offset>;\n}\n\n```\n\nOutput:\n\n```\nEnter a temperature in Kelvin: 21\n     Celcius: -252.15\n  Fahrenheit: -421.87\n     Rankine:   37.80\n\n```\n\nAlternative version that accepts the input in any of the four scales:\n\n```\nwhile my $answer = prompt 'Temperature: ' {\n    my $k = do given $answer {\n        when s/:i C $// { $_ + 273.15 }\n        when s/:i F $// { ($_ + 459.67) / 1.8 }\n        when s/:i R $// { $_ / 1.8 }\n        when s/:i K $// { $_ }\n        default         { $_ }\n    }\n    say \"  { $k }K\";\n    say \"  { $k - 273.15 }℃\";\n    say \"  { $k * 1.8 - 459.67 }℉\";\n    say \"  { $k * 1.8 }R\";\n}\n\n```\n\nOutput:\n\n```\nTemperature: 0\n  0K\n  -273.15℃\n  -459.67℉\n  0R\nTemperature: 0c\n  273.15K\n  0℃\n  32℉\n  491.67R\nTemperature: 212f\n  373.15K\n  100℃\n  212℉\n  671.67R\nTemperature: -40c\n  233.15K\n  -40℃\n  -40℉\n  419.67R\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nClear the terminal window."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub clear { print qx[clear] }\nclear;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay a word in various colours on the terminal.\n\nThe system palette, or colours such as Red, Green, Blue, Magenta, Cyan, and Yellow can be used.\n\nOptionally demonstrate:\n\n* How the system should determine if the terminal supports colour\n* Setting of the background colour\n* How to cause blinking or flashing (if supported by the terminal)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nuse Terminal::ANSIColor;\n\nsay colored('RED ON WHITE', 'bold red on_white');\nsay colored('GREEN', 'bold green');\nsay colored('BLUE ON YELLOW', 'bold blue on_yellow');\nsay colored('MAGENTA', 'bold magenta');\nsay colored('CYAN ON RED', 'bold cyan on_red');\nsay colored('YELLOW', 'bold yellow');\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate how to achieve movement of the terminal cursor:\n\n:   * how to move the cursor one position to the left\n    * how to move the cursor one position to the right\n    * how to move the cursor up one line (without affecting its horizontal position)\n    * how to move the cursor down one line (without affecting its horizontal position)\n    * how to move the cursor to the beginning of the line\n    * how to move the cursor to the end of the line\n    * how to move the cursor to the top left corner of the screen\n    * how to move the cursor to the bottom right corner of the screen\n\nFor the purpose of this task, it is not permitted to overwrite any characters or attributes on any part of the screen (so outputting a space is not a suitable solution to achieve a movement to the right).\n\nHandling of out of bounds locomotion\n\nThis task has no specific requirements to trap or correct cursor movement beyond the terminal boundaries, so the implementer should decide what behavior fits best in terms of the chosen language.   Explanatory notes may be added to clarify how an out of bounds action would behave and the generation of error messages relating to an out of bounds cursor position is permitted."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nshell \"tput cub1\";                  # one position to the left\nshell \"tput cuf1\";                  # one position to the right\nshell \"tput cuu1\";                  # up one line\nshell \"tput cud1\";                  # down one line\nshell \"tput cr\";                    # beginning of line\nshell \"tput home\";                  # top left corner\n\n$_ = qx[stty -a </dev/tty 2>&1];\nmy $rows = +m/'rows '    <(\\d+)>/;\nmy $cols = +m/'columns ' <(\\d+)>/;\n\nshell \"tput hpa $cols\";             # end of line\nshell \"tput cup $rows $cols\";       # bottom right corner\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nMove the cursor to column   **3**,   row   **6**,   and display the word   \"Hello\"   (without the quotes),   so that the letter   **H**   is in column   **3**   on row   **6**."}, {"role": "assistant", "content": "(formerly Perl 6)\nAssuming an ANSI terminal:\n\n```\nprint \"\\e[6;3H\";\nprint 'Hello';\n\n```"}]}
{"messages": [{"role": "user", "content": "Determine the height and width of the terminal, and store this information into variables for subsequent use."}, {"role": "assistant", "content": "(formerly Perl 6)\nUsing *stty* just for the heck of it.\n\n```\nmy $stty = qx[stty -a];\nmy $lines = $stty.match(/ 'rows '    <( \\d+/);\nmy $cols  = $stty.match(/ 'columns ' <( \\d+/);\nsay \"$lines $cols\";\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay an extended (non ASCII) character onto the terminal.\n\nSpecifically, display a    £    (GBP currency sign)."}, {"role": "assistant", "content": "(formerly Perl 6)\nTo demonstrate we're not limited to Latin-1, we'll print the fullwidth variant.\n\n```\nsay '￡';\nsay \"\\x[FFE1]\";\nsay \"\\c[FULLWIDTH POUND SIGN]\";\n0xffe1.chr.say;\n\n```"}]}
{"messages": [{"role": "user", "content": "The task is to hide the cursor and show it again."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsay 'Hiding the cursor for 5 seconds...';\nrun 'tput', 'civis';\nsleep 5;\nrun 'tput', 'cvvis';\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDisplay a word in inverse video   (or reverse video)   followed by a word in normal video."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsay \"normal\";\nrun \"tput\", \"rev\";\nsay \"reversed\";\nrun \"tput\", \"sgr0\";\nsay \"normal\";\n\n```"}]}
{"messages": [{"role": "user", "content": "Determine the character displayed on the screen at column 3, row 6 and store that character in a variable. Note that it is permissible to utilize system or language provided methods or system provided facilities, system maintained records or available buffers or system maintained display records to achieve this task, rather than query the terminal directly, if those methods are more usual for the system type or language."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Python\n\n```\nuse NCurses;\n\n# Reference:\n# https://github.com/azawawi/perl6-ncurses\n\n# Initialize curses window\nmy $win = initscr() or die \"Failed to initialize ncurses\\n\";\n\n# Print random text in a 10x10 grid\n\nfor ^10 { mvaddstr($_ , 0, (for ^10 {(41 .. 90).roll.chr}).join )};\n\n# Read\n\nmy $icol = 3 - 1;\nmy $irow = 6 - 1;\n\nmy $ch = mvinch($irow,$icol);\n\n# Show result\n\nmvaddstr($irow, $icol+10, 'Character at column 3, row 6 = ' ~ $ch.chr);\n\nmvaddstr( LINES() - 2, 2, \"Press any key to exit...\" );\n\n# Refresh (this is needed)\nnc_refresh;\n\n# Wait for a keypress\ngetch;\n\n# Cleanup\nLEAVE {\n    delwin($win) if $win;\n    endwin;\n}\n\n```\n\nOutput:\n\n```\n+W18:5I<1N\nN-I.HG45SK\nBFJY8:AK)8\nJ+4U<H1++:\nRP>BX-/19Y\nURDESVX;HX  Character at column 3, row 6 = D\nJ7+X3@E<BG\nM;?2U<8+FI\n)@BG,:D)O1\n)>A-=LDY-.\n\n  Press any key to exit...\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nClear the screen, output something on the display, and then restore the screen to the preserved state that it was in before the task was carried out.\n\nThere is no requirement to change the font or kerning in this task, however character decorations and attributes are expected to be preserved.   If the implementer decides to change the font or kerning during the display of the temporary screen, then these settings need to be restored prior to exit."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nprint \"\\e[?1049h\\e[H\";\nsay \"Alternate buffer!\";\n\nfor 5,4...1 {\n    print \"\\rGoing back in: $_\";\n    sleep 1;\n}\n\nprint \"\\e[?1049l\";\n\n```"}]}
{"messages": [{"role": "user", "content": "Create a routine to obtain data entry using a specific place on the terminal screen. Data entry fields should be restricted to a specific length, and it should not be possible for the cursor to move beyond the input length.\n\nThe routine should accept parameters for row number, column number and input length, and should obtain a string\nvalue entered by the user.\n\nFor the purpose of this task, obtain input from the user, showing data entry at row 3, column 5, with input width restricted to a maximum of 8 characters.\n\nNote: In this task input wrapping is not allowed. (See Terminal control/Restricted width positional input/With wrapping) for input wrapping variant.\n\nFor a similar task using a graphical user interface, see Graphical User Interface/Restricted width positional input/No wrapping."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.10\n\nShould work with any termios compatible terminal.\n\nAll printable character keys work, as does backspace and enter. Ctrl-c to exit. All other keys / key-combos are ignored.\n\n```\nuse Term::termios;\n\nconstant $saved   = Term::termios.new(fd => 1).getattr;\nconstant $termios = Term::termios.new(fd => 1).getattr;\n# raw mode interferes with carriage returns, so\n# set flags needed to emulate it manually\n$termios.unset_iflags(<BRKINT ICRNL ISTRIP IXON>);\n$termios.unset_lflags(<ECHO ICANON IEXTEN ISIG>);\n$termios.setattr(:DRAIN);\n\n\nEND {\n    $saved.setattr(:NOW); # reset terminal to original settings\n    print \"\\e[?25h \\e[H\\e[J\"; # clear and reset screen\n}\n\nmy $row     = 3;\nmy $column  = 5;\nmy $field   = '';\nmy $spacer  = ' ' x 8;\nmy $pointer = 0;\n\nmy ($rows,$cols) = qx/stty size/.words; # get screen size\n\nmy @screen = \"\\e[41m{' ' x $cols}\\e[0m\" xx $rows;\n\nupdate($spacer);\n\nloop {\n    my $key = $*IN.read(4).decode;\n    given $key {\n        when ' '..'~' {\n            if $pointer < 8 {\n                $field ~= $_;\n                $spacer = ' ' x 8 - $field.chars;\n                $pointer +=1;\n                update($field~$spacer)\n            }\n        }\n        when \"\\c[127]\" { # backspace\n            if $pointer > 0 {\n                $field.=substr(0,*-1);\n                $spacer = ' ' x 8 - $field.chars;\n                $pointer -= 1;\n                update($field~$spacer)\n            }\n        }\n        when \"\\c[13]\" {\n            update('        ');\n            print \"\\e[10;6H\\e[1;33;41mYou entered: $field\\e[0m\\e[$row;{$column}H\";\n            $field = '';\n            $pointer = 0;\n        }\n        when \"\\c[0003]\" { exit } # Ctrl-c\n        default { }\n    }\n}\n\nsub update ($str) {\n    ($rows,$cols) = qx/stty size/.words;\n    @screen = \"\\e[41m{' ' x $cols}\\e[0m\" xx $rows;\n    print \"\\e[H\\e[J{@screen.join: \"\\n\"}\\e[$row;{$column}H$str\\e[$row;{$column + $pointer}H\";\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Create a routine to obtain data entry using a specific place on the terminal screen.\n\nData entry fields should be restricted to a specific length,   and the cursor should not move beyond the input length.\n\nThe routine should accept parameters for row number,   column number,   and input length,   and should obtain a string value entered by the user.\n\nFor the purpose of this task,   obtain input from the user,   showing data entry at   row   **3**,   column   **5**,   with input width restricted to a maximum of   **8**   characters.\n\nNote:   in this task input wrapping is allowed.   If the length of input exceeds the maximum width, the left hand side of the field should disappear, allowing additional input to be obtained.   However, the cursor must not move beyond the designated input length.\n\nIt is permissible to use navigation keys to see input field length.\n\n(See Terminal control/Restricted width positional input/No wrapping for similar input routine with no wrapping).\n\nFor a similar task using a graphical user interface,   see   Graphical User Interface/Restricted width positional input/With wrapping."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.10\n\nShould work with any termios compatible terminal.\n\nAll printable character keys (except Tab) work, as does backspace and enter. Ctrl-c to exit. All other keys / key-combos are ignored.\n\n```\nuse Term::termios;\n\nconstant $saved   = Term::termios.new(fd => 1).getattr;\nconstant $termios = Term::termios.new(fd => 1).getattr;\n# raw mode interferes with carriage returns, so\n# set flags needed to emulate it manually\n$termios.unset_iflags(<BRKINT ICRNL ISTRIP IXON>);\n$termios.unset_lflags(<ECHO ICANON IEXTEN ISIG>);\n$termios.setattr(:DRAIN);\n\nEND {\n    $saved.setattr(:NOW); # reset terminal to original settings\n    print \"\\e[?25h \\e[H\\e[J\"; # clear and reset screen\n}\n\nmy $row     = 3;\nmy $column  = 5;\nmy $field   = '';\nmy $spacer  = ' ' x 8;\nmy $pointer = 0;\n\nmy ($rows,$cols) = qx/stty size/.words; # get screen size\n\nmy @screen = \"\\e[41m{' ' x $cols}\\e[0m\" xx $rows;\n\nupdate($spacer);\n\nloop {\n    my $key = $*IN.read(4).decode;\n    given $key {\n        when ' '..'~' {\n            if $pointer < 8 {\n                $field ~= $_;\n                $spacer = ' ' x 8 - $field.chars;\n                $pointer +=1;\n                update($field~$spacer)\n            } elsif $pointer >= 8 {\n                $field ~= $_;\n                $spacer = '';\n                update($field.substr(*-8))\n            }\n        }\n        when \"\\c[127]\" { # backspace\n            if $pointer > 0 {\n                $field.=substr(0,*-1);\n                $spacer = ' ' x (8 - $field.chars max 0);\n                $pointer -= 1 if $field.chars < 8;\n                my $display = $field.chars < 8 ?? $field !! $field.substr(*-8);\n                update($display~$spacer)\n            }\n        }\n        when \"\\c[13]\" {\n            update('        ');\n            print \"\\e[10;6H\\e[1;33;41mYou entered: $field\\e[0m\\e[$row;{$column}H\";\n            $field = '';\n            $pointer = 0;\n        }\n        when \"\\c[0003]\" { exit } # Ctrl-c\n        default { }\n    }\n}\n\nsub update ($str) {\n    ($rows,$cols) = qx/stty size/.words;\n    @screen = \"\\e[41m{' ' x $cols}\\e[0m\" xx $rows;\n    print \"\\e[H\\e[J{@screen.join: \"\\n\"}\\e[$row;{$column}H$str\\e[$row;{$column + $pointer}H\";\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nMake the terminal running the program ring its \"bell\".\n\nOn modern terminal emulators, this may be done by playing some other sound which might or might not be configurable, or by flashing the title bar or inverting the colors of the screen, but was classically a physical bell within the terminal.   It is usually used to indicate a problem where a wrong character has been typed.\n\nIn most terminals, if the   Bell character   (ASCII code **7**,    `\\a`  in C)   is printed by the program, it will cause the terminal to ring its bell.   This is a function of the terminal, and is independent of the programming language of the program, other than the ability to print a particular character to standard out."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nprint 7.chr;\n\n```"}]}
{"messages": [{"role": "user", "content": "The task is to check that the terminal supports Unicode output, before outputting a Unicode character. If the terminal supports Unicode, then the terminal should output a Unicode delta (U+25b3). If the terminal does not support Unicode, then an appropriate error should be raised.\n\nNote that it is permissible to use system configuration data to determine terminal capabilities if the system provides such a facility."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\ndie \"Terminal can't handle UTF-8\"\n    unless first(*.defined, %*ENV<LC_ALL LC_CTYPE LANG>) ~~ /:i 'utf-8'/;\nsay \"△\";\n\n```\n\nOutput:\n\n```\n△\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Ternary logic. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn logic, a **three-valued logic** (also **trivalent**, **ternary**, or **trinary logic**, sometimes abbreviated **3VL**) is any of several many-valued logic systems in which there are three truth values indicating *true*, *false* and some indeterminate third value.\n\nThis is contrasted with the more commonly known bivalent logics (such as classical sentential or boolean logic) which provide only for *true* and *false*.\n\nConceptual form and basic ideas were initially created by Łukasiewicz, Lewis and Sulski.\n\nThese were then re-formulated by Grigore Moisil in an axiomatic algebraic form, and also extended to *n*-valued logics in 1945.\n\n**Example *Ternary Logic Operators* in *Truth Tables*:**\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| *not* a  | ¬ | | | --- | --- | | True | False | | Maybe | Maybe | | False | True | | a *and* b  |  |  |  |  | | --- | --- | --- | --- | | ∧ | True | Maybe | False | | True | True | Maybe | False | | Maybe | Maybe | Maybe | False | | False | False | False | False | | a *or* b  |  |  |  |  | | --- | --- | --- | --- | | ∨ | True | Maybe | False | | True | True | True | True | | Maybe | True | Maybe | Maybe | | False | True | Maybe | False | |\n| *if* a *then* b  |  |  |  |  | | --- | --- | --- | --- | | ⊃ | True | Maybe | False | | True | True | Maybe | False | | Maybe | True | Maybe | Maybe | | False | True | True | True | | a *is equivalent to* b  |  |  |  |  | | --- | --- | --- | --- | | ≡ | True | Maybe | False | | True | True | Maybe | False | | Maybe | Maybe | Maybe | Maybe | | False | False | Maybe | True | |\n\nTask\n\n* Define a new type that emulates *ternary logic* by storing data **trits**.\n* Given all the binary logic operators of the original programming language, reimplement these operators for the new *Ternary logic* type **trit**.\n* Generate a sampling of results using **trit** variables.\n* Kudos for actually thinking up a test case algorithm where *ternary logic* is intrinsically useful, optimises the test case algorithm and is preferable to binary logic.\n\nNote:   **Setun**   (Сетунь) was a   balanced ternary   computer developed in 1958 at   Moscow State University.   The device was built under the lead of   Sergei Sobolev   and   Nikolay Brusentsov.   It was the only modern   ternary computer,   using three-valued ternary logic"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\nThe precedence of each operator is specified as equivalent to an existing operator. We've taken the liberty of using a double arrow for implication, to avoid confusing it with ⊃, (U+2283 SUPERSET OF).\n\n```\n# Implementation:\nenum Trit <Foo Moo Too>;\n\nsub prefix:<¬> (Trit $a) { Trit(1-($a-1)) }\n\nsub infix:<∧> (Trit $a, Trit $b) is equiv(&infix:<*>) { $a min $b }\nsub infix:<∨> (Trit $a, Trit $b) is equiv(&infix:<+>) { $a max $b }\n\nsub infix:<⇒> (Trit $a, Trit $b) is equiv(&infix:<..>) { ¬$a max $b }\nsub infix:<≡> (Trit $a, Trit $b) is equiv(&infix:<eq>) { Trit(1 + ($a-1) * ($b-1)) }\n\n# Testing:\nsay '¬';\nsay \"Too {¬Too}\";\nsay \"Moo {¬Moo}\";\nsay \"Foo {¬Foo}\";\n\nsub tbl (&op,$name) {\n    say '';\n    say \"$name   Too Moo Foo\";\n    say \"   ╔═══════════\";\n    say \"Too║{op Too,Too} {op Too,Moo} {op Too,Foo}\";\n    say \"Moo║{op Moo,Too} {op Moo,Moo} {op Moo,Foo}\";\n    say \"Foo║{op Foo,Too} {op Foo,Moo} {op Foo,Foo}\";\n}\n\ntbl(&infix:<∧>, '∧');\ntbl(&infix:<∨>, '∨');\ntbl(&infix:<⇒>, '⇒');\ntbl(&infix:<≡>, '≡');\n\nsay '';\nsay 'Precedence tests should all print \"Too\":';\nsay ~(\n    Foo ∧ Too ∨ Too ≡ Too,\n    Foo ∧ (Too ∨ Too) ≡ Foo,\n    Too ∨ Too ∧ Foo ≡ Too,\n    (Too ∨ Too) ∧ Foo ≡ Foo,\n\n    ¬Too ∧ Too ∨ Too ≡ Too,\n    ¬Too ∧ (Too ∨ Too) ≡ ¬Too,\n    Too ∨ Too ∧ ¬Too ≡ Too,\n    (Too ∨ Too) ∧ ¬Too ≡ ¬Too,\n \n    Foo ∧ Too ∨ Foo ⇒ Foo ≡ Too,\n    Foo ∧ Too ∨ Too ⇒ Foo ≡ Foo,\n);\n\n```\n\nOutput:\n\n```\n¬\nToo Foo\nMoo Moo\nFoo Too\n\n∧   Too Moo Foo\n   ╔═══════════\nToo║Too Moo Foo\nMoo║Moo Moo Foo\nFoo║Foo Foo Foo\n\n∨   Too Moo Foo\n   ╔═══════════\nToo║Too Too Too\nMoo║Too Moo Moo\nFoo║Too Moo Foo\n\n⇒   Too Moo Foo\n   ╔═══════════\nToo║Too Moo Foo\nMoo║Too Moo Moo\nFoo║Too Too Too\n\n≡   Too Moo Foo\n   ╔═══════════\nToo║Too Moo Foo\nMoo║Moo Moo Moo\nFoo║Foo Moo Too\n\nPrecedence tests should all print \"Too\":\nToo Too Too Too Too Too Too Too Too Too\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nUsing a well-known testing-specific library/module/suite for your language, write some tests for your language's entry in Palindrome.\n\nIf your language does not have a testing specific library well known to the language's community then state this or omit the language."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nuse Test;\n\nsub palin( Str $string) { so $string.lc.comb(/\\w/) eq  $string.flip.lc.comb(/\\w/) }\n\nfor\n    'A man, a plan, a canal: Panama.'           => True,\n    'My dog has fleas'                          => False,\n    \"Madam, I'm Adam.\"                          => True,\n    '1 on 1'                                    => False,\n    'In girum imus nocte et consumimur igni'    => True,\n    ''                                          => True\n{\n  my ($test, $expected-result) = .kv;\n    is palin($test), $expected-result,\n        \"\\\"$test\\\" is {$expected-result??''!!'not '}a palindrome.\";\n}\n\ndone-testing;\n\n```\n\nOutput:\n\n```\n1..6\nok 1 - \"1 on 1\" is not a palindrome.\nok 2 - \"My dog has fleas\" is not a palindrome.\nok 3 - \"A man, a plan, a canal: Panama.\" is a palindrome.\nok 4 - \"\" is a palindrome.\nok 5 - \"Madam, I'm Adam.\" is a palindrome.\nok 6 - \"In girum imus nocte et consumimur igni\" is a palindrome.\n```"}]}
{"messages": [{"role": "user", "content": "Mathematically,\n\n* the integers **Z** are included in the rational numbers **Q**,\n* which are included in the real numbers **R**,\n* which can be generalized to the complex numbers **C**.\n\nThis means that each of those larger sets, and the data types used to represent them, include some integers.\n\nTask[edit]\n\nGiven a rational, real, or complex number of any type, test whether it is mathematically an integer.\n\nYour code should handle all numeric data types commonly used in your programming language.\n\nDiscuss any limitations of your code.\n\nDefinition\n\nFor the purposes of this task, integerness means that a number could theoretically be represented as an integer at no loss of precision *(given an infinitely wide integer type)*.  \nIn other words:\n\n| Set | Common representation | C++ type | Considered an integer... |\n| --- | --- | --- | --- |\n| rational numbers **Q** | fraction | `std::ratio` | ...if its denominator is 1 (in reduced form) |\n| real numbers **Z** *(approximated)* | fixed-point |  | ...if it has no non-zero digits after the decimal point |\n| floating-point | `float`, `double` | ...if the number of significant decimal places of its mantissa isn't greater than its exponent |\n| complex numbers **C** | pair of real numbers | `std::complex` | ...if its real part is considered an integer and its imaginary part is zero |\n\nExtra credit\n\nOptionally, make your code accept a `tolerance` parameter for fuzzy testing. The tolerance is the maximum amount by which the number may differ from the nearest integer, to still be considered an integer.\n\nThis is useful in practice, because when dealing with approximate numeric types (such as floating point), there may already be round-off errors from previous calculations. For example, a float value of `0.9999999998` might actually be intended to represent the integer `1`.\n\nTest cases\n\n| Input | | Output | | Comment |\n| --- | --- | --- | --- | --- |\n| Type | Value | exact | tolerance = 0.00001 |\n| decimal | `25.000000` | true | |  |\n| `24.999999` | false | true |  |\n| `25.000100` | false | |  |\n| floating-point | `-2.1e120` | true | | This one is tricky, because in most languages it is too large to fit into a native integer type. It is, nonetheless, mathematically an integer, and your code should identify it as such. |\n| `-5e-2` | false | |  |\n| `NaN` | false | |  |\n| `Inf` | false | | This one is debatable. If your code considers it an integer, that's okay too. |\n| complex | `5.0+0.0i` | true | |  |\n| `5-5i` | false | |  |\n\n(The types and notations shown in these tables are merely examples – you should use the native data types and number literals of your programming language and standard library. Use a different set of test-cases, if this one doesn't demonstrate all relevant behavior.)\n\n---"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nIn Raku, all numeric types have a method called narrow, which returns an object with the same value but of the most appropriate type. So we can just check if *that* object is an Int. This works even with floats with large exponents, because the Int type supports arbitrarily large integers.\n\nFor the extra credit task, we can add another multi candidate that checks the distance between the number and it's nearest integer, but then we'll have to handle complex numbers specially.\n\n```\nmulti is-int ($n) { $n.narrow ~~ Int }\n\nmulti is-int ($n, :$tolerance!) {\n    abs($n.round - $n) <= $tolerance\n}\n\nmulti is-int (Complex $n, :$tolerance!) {\n    is-int($n.re, :$tolerance) && abs($n.im) < $tolerance\n}\n\n# Testing:\n\nfor 25.000000, 24.999999, 25.000100, -2.1e120, -5e-2, Inf, NaN, 5.0+0.0i, 5-5i {\n    printf \"%-7s  %-9s  %-5s  %-5s\\n\", .^name, $_,\n        is-int($_),\n        is-int($_, :tolerance<0.00001>);\n}\n\n```\n\nOutput:\n\n```\nRat      25         True   True \nRat      24.999999  False  True \nRat      25.0001    False  False\nNum      -2.1e+120  True   True \nNum      -0.05      False  False\nNum      Inf        False  False\nNum      NaN        False  False\nComplex  5+0i       True   True \nComplex  5-5i       False  False\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGet the text in a string that occurs between a start and end delimiter.\nPrograms will be given a search string, a start delimiter string, and an end delimiter string. The delimiters will not be unset, and will not be the empty string.\n\nThe value returned should be the text in the search string that occurs between the **first** occurrence of the start delimiter (starting after the text of the start delimiter) and the **first** occurrence of the end delimiter after that.\n\nIf the start delimiter is not present in the search string, a blank string should be returned.\n\nIf the end delimiter is not present after the end of the first occurrence of the start delimiter in the search string, the remainder of the search string after that point should be returned.\n\nThere are two special values for the delimiters. If the value of the start delimiter is \"start\", the beginning of the search string will be matched. If the value of the end delimiter is \"end\", the end of the search string will be matched.\n\nExample 1. Both delimiters set\n\n```\n           Text: \"Hello Rosetta Code world\"\n           Start delimiter: \"Hello \"\n           End delimiter: \" world\"\n           Output: \"Rosetta Code\"\n\n```\n\nExample 2. Start delimiter is the start of the string\n\n```\n           Text: \"Hello Rosetta Code world\"\n           Start delimiter: \"start\"\n           End delimiter: \" world\"\n           Output: \"Hello Rosetta Code\"\n\n```\n\nExample 3. End delimiter is the end of the string\n\n```\n           Text: \"Hello Rosetta Code world\"\n           Start delimiter: \"Hello\"\n           End delimiter: \"end\"\n           Output: \"Rosetta Code world\"\n\n```\n\nExample 4. End delimiter appears before and after start delimiter\n\n```\n           Text: \"</div><div style=\\\"chinese\\\">你好嗎</div>\"\n           Start delimiter: \"<div style=\\\"chinese\\\">\"\n           End delimiter: \"</div>\"\n           Output: \"你好嗎\"\n\n```\n\nExample 5. End delimiter not present\n\n```\n           Text: \"<text>Hello <span>Rosetta Code</span> world</text><table style=\\\"myTable\\\">\"\n           Start delimiter: \"<text>\"\n           End delimiter: \"<table>\"\n           Output: \"Hello <span>Rosetta Code</span> world</text><table style=\\\"myTable\\\">\"\n\n```\n\nExample 6. Start delimiter not present\n\n```\n           Text: \"<table style=\\\"myTable\\\"><tr><td>hello world</td></tr></table>\"\n           Start delimiter: \"<table>\"\n           End delimiter: \"</table>\"\n           Output: \"\"\n\n```\n\nExample 7. Multiple instances of end delimiter after start delimiter (match until the first one)\n\n```\n           Text: \"The quick brown fox jumps over the lazy other fox\"\n           Start delimiter: \"quick \"\n           End delimiter: \" fox\"\n           Output: \"brown\"\n\n```\n\nExample 8. Multiple instances of the start delimiter (start matching at the first one)\n\n```\n           Text: \"One fish two fish red fish blue fish\"\n           Start delimiter: \"fish \"\n           End delimiter: \" red\"\n           Output: \"two fish\"\n\n```\n\nExample 9. Start delimiter is end delimiter\n\n```\n           Text: \"FooBarBazFooBuxQuux\"\n           Start delimiter: \"Foo\"\n           End delimiter: \"Foo\"\n           Output: \"BarBaz\"\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.12\n\nIt seems somewhat pointless to write a special purpose routine to do text matching as built-in primitives can do so more flexibly and concisely, but whatever.\n\nThis version doesn't use strings for meta indexes ('start' and 'end'), rather it accepts regex assertions which are parsed differently from strings. This allows much more robust and fine grained control over what does and doesn't match. (and allows delimiter strings of 'start' and 'end' incidentally.) See the 11th example below which will confound nearly all of the current string-only based implementations.\n\n```\nsub text-between ( $text, $start, $end ) {\n    return $/»[0]».Str if $text ~~ m:g/ $start (.*?) $end /;\n    []\n}\n\n# Testing\nmy $text = 'Hello Rosetta Code world';\n\n# String start and end delimiter\nput '1> ', $text.&text-between( 'Hello ', ' world' );\n\n# Regex string start delimiter\nput '2> ', $text.&text-between( rx/^/, ' world' );\n\n# Regex string end delimiter\nput '3> ', $text.&text-between( 'Hello ',  rx/$/ );\n\n# End delimiter only valid after start delimiter\nput '4> ', '</div><div style=\"chinese\">你好嗎</div>'\\\n    .&text-between( '<div style=\"chinese\">', '</div>' );\n\n# End delimiter not found, default to string end\nput '5> ', '<text>Hello <span>Rosetta Code</span> world</text><table style=\"myTable\">'\\\n    .&text-between( '<text>', rx/'<table>' | $/ );\n\n# Start delimiter not found, return blank string\nput '6> ', '<table style=\"myTable\"><tr><td>hello world</td></tr></table>'\\\n    .&text-between( '<table>', '</table>' );\n\n# Multiple end delimiters, match frugally\nput '7> ', 'The quick brown fox jumps over the lazy other fox'\\\n    .&text-between( 'quick ', ' fox' );\n\n# Multiple start delimiters, match frugally\nput '8> ', 'One fish two fish red fish blue fish'\\\n    .&text-between( 'fish ', ' red' );\n\n# Start delimiter is end delimiter\nput '9> ', 'FooBarBazFooBuxQuux'\\\n    .&text-between( 'Foo', 'Foo' );\n\n# Return all matching strings when multiple matches are possible\nput '10> ', join ',', $text.&text-between( 'e', 'o' );\n\n# Ignore start and end delimiter string embedded in longer words\nput '11> ', 'Soothe a guilty conscience today, string wrangling is not the best tool to use for this job.'\\\n    .&text-between( rx/«'the '/, rx/' to'»/ );\n\n```\n\nOutput:\n\n```\n1> Rosetta Code\n2> Hello Rosetta Code\n3> Rosetta Code world\n4> 你好嗎\n5> Hello <span>Rosetta Code</span> world</text><table style=\"myTable\">\n6> \n7> brown\n8> two fish\n9> BarBaz\n10> ll,tta C, w\n11> best tool\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program that takes in a user inputted word and prints out possible words that are valid in the English dictionary.\nPlease state any dictionaries or files/binaries/dependencies used in your program. Do show the similarity of the inputted word and outcome as a percentage. Any algorithm can be used to accomplish this task.\n\nResources\n\nGithub Repo  \nRaw Text, Save as .txt file  \nHamming Distance  \nJaro-Winkler Distance  \nSoundEx Algorithm  \nSoundEx Algorithm Wiki  \nDice's Coefficient  \nDice Coefficient Wiki\n\nPossible Output\n\n```\nInput word: \ncomplition\n\ncompaction : 80.00% similar.\ncompletion : 90.00% similar.\ncompletions : 81.82% similar.\ncomplexion : 80.00% similar.\n\n```\n\nExtension\n\n1. How can you make the accuracy of your program higher?"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Hamming distance\n\n**Translation of**: Java\n\n```\nsub MAIN ( Str $user_word = 'complition', Str $filename = 'words.txt' ) {\n    my @s1 = $user_word.comb;\n    my @listed = gather for $filename.IO.lines -> $line {\n        my @s2 = $line.comb;\n\n        my $correct = 100 * sum( @s1 Zeq @s2)\n                          / max(+@s1,   +@s2);\n\n        my $score = ( $correct >= 100            and @s1[0] eq @s2[0] ) ?? 100\n                 !! ( $correct >=  80            and @s1[0] eq @s2[0] ) ?? $correct\n                 !! ( $line.contains($user_word) and @s1 * 2 > @s2    ) ?? 80\n                 !!                                                        0;\n        take [$score, $line] if $score;\n    }\n\n    @listed = @listed[$_] with @listed.first: :k, { .[0] == 100 };\n\n    say \"{.[0].fmt('%.2f')}% {.[1]}\" for @listed;\n}\n\n```\n\nOutput:\n\n```\n80.00% compaction\n90.00% completion\n81.82% completions\n80.00% complexion\n\n```\n\n### Sorenson-Dice\n\nSorenson-Dice tends to return relatively low percentages even for small differences, especially for short words. We need to \"lower the bar\" to get any results at all. Different variations of the algorithm do or don't regularize case. This one does, though it doesn't much matter for the tested words.\n\nUsing unixdict.txt from www.puzzlers.org\n\n```\nsub sorenson ($phrase, %hash) {\n    my $match = bigram $phrase;\n    %hash.race.map: { [(2 * ($match ∩ .value) / ($match + .value)).round(.001), .key] }\n}\n\nsub bigram (\\these) { Bag.new( flat these.fc.words.map: { .comb.rotor(2 => -1)».join } ) }\n\n# Load the dictionary\nmy %hash = './unixdict.txt'.IO.slurp.words.race.map: { $_ => .&bigram };\n\n# Testing\nfor <complition inconsqual Sørenson> -> $w {\n    say \"\\n$w:\";\n    .say for sorenson($w, %hash).grep(*.[0] >= .55).sort({-.[0],~.[1]}).head(10);\n}\n\n```\n\nOutput:\n\n```\ncomplition:\n[0.778 completion]\n[0.737 competition]\n[0.737 composition]\n[0.706 coalition]\n[0.7 incompletion]\n[0.667 complexion]\n[0.667 complicity]\n[0.667 decomposition]\n[0.632 compilation]\n[0.632 compunction]\n\ninconsqual:\n[0.609 inconsequential]\n[0.588 continual]\n[0.571 squall]\n[0.556 conceptual]\n[0.556 inconstant]\n\nSørenson:\n[0.714 sorenson]\n[0.667 benson]\n[0.615 swenson]\n[0.571 evensong]\n[0.571 sorensen]\n```"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nOften data is produced by one program, in the wrong format for later use by another program or person. In these situations another program can be written to parse and transform the original data into a format useful to the other. The term \"Data Munging\" is often used in programming circles for this task.\n\nA request on the comp.lang.awk newsgroup led to a typical data munging task:\n\n```\nI have to analyse data files that have the following format:\nEach row corresponds to 1 day and the field logic is: $1 is the date,\nfollowed by 24 value/flag pairs, representing measurements at 01:00,\n02:00 ... 24:00 of the respective day. In short:\n\n<date> <val1> <flag1> <val2> <flag2> ...  <val24> <flag24>\n\nSome test data is available at: \n... (nolonger available at original location)\n\nI have to sum up the values (per day and only valid data, i.e. with\nflag>0) in order to calculate the mean. That's not too difficult.\nHowever, I also need to know what the \"maximum data gap\" is, i.e. the\nlongest period with successive invalid measurements (i.e values with\nflag<=0)\n```\n\nThe data is free to download and use and is of this format:\n\nData is no longer available at that link. Zipped mirror available here (offsite mirror).\n\n```\n1991-03-30\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\n1991-03-31\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t20.000\t1\t20.000\t1\t20.000\t1\t35.000\t1\t50.000\t1\t60.000\t1\t40.000\t1\t30.000\t1\t30.000\t1\t30.000\t1\t25.000\t1\t20.000\t1\t20.000\t1\t20.000\t1\t20.000\t1\t20.000\t1\t35.000\t1\n1991-03-31\t40.000\t1\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\n1991-04-01\t0.000\t-2\t13.000\t1\t16.000\t1\t21.000\t1\t24.000\t1\t22.000\t1\t20.000\t1\t18.000\t1\t29.000\t1\t44.000\t1\t50.000\t1\t43.000\t1\t38.000\t1\t27.000\t1\t27.000\t1\t24.000\t1\t23.000\t1\t18.000\t1\t12.000\t1\t13.000\t1\t14.000\t1\t15.000\t1\t13.000\t1\t10.000\t1\n1991-04-02\t8.000\t1\t9.000\t1\t11.000\t1\t12.000\t1\t12.000\t1\t12.000\t1\t27.000\t1\t26.000\t1\t27.000\t1\t33.000\t1\t32.000\t1\t31.000\t1\t29.000\t1\t31.000\t1\t25.000\t1\t25.000\t1\t24.000\t1\t21.000\t1\t17.000\t1\t14.000\t1\t15.000\t1\t12.000\t1\t12.000\t1\t10.000\t1\n1991-04-03\t10.000\t1\t9.000\t1\t10.000\t1\t10.000\t1\t9.000\t1\t10.000\t1\t15.000\t1\t24.000\t1\t28.000\t1\t24.000\t1\t18.000\t1\t14.000\t1\t12.000\t1\t13.000\t1\t14.000\t1\t15.000\t1\t14.000\t1\t15.000\t1\t13.000\t1\t13.000\t1\t13.000\t1\t12.000\t1\t10.000\t1\t10.000\t1\n\n```\n\nOnly a sample of the data showing its format is given above. The full example file may be downloaded here.\n\nStructure your program to show statistics for each line of the file, (similar to the original Python, Perl, and AWK examples below), followed by summary statistics for the file. When showing example output just show a few line statistics and the full end summary."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @gaps;\nmy $previous = 'valid';\n\nfor $*IN.lines -> $line { \n    my ($date, @readings) = split /\\s+/, $line;\n    my @valid;\n    my $hour = 0;\n    for @readings -> $reading, $flag {\n        if $flag > 0 {    \n            @valid.push($reading);\n            if $previous eq 'invalid' {\n                @gaps[*-1]{'end'} = \"$date $hour:00\";\n                $previous = 'valid';\n            }\n        } \n        else\n        {\n            if $previous eq 'valid' {\n                @gaps.push( {start => \"$date $hour:00\"} );\n            }\n            @gaps[*-1]{'count'}++;\n            $previous = 'invalid';\n        }\n        $hour++;\n    }\n    say \"$date: { ( +@valid ?? ( ( [+] @valid ) / +@valid ).fmt(\"%.3f\") !! 0 ).fmt(\"%8s\") }\",\n        \" mean from { (+@valid).fmt(\"%2s\") } valid.\"; \n};\n\nmy $longest = @gaps.sort({-$^a<count>})[0];\n\nsay \"Longest period of invalid readings was {$longest<count>} hours,\\n\",\n    \"from {$longest<start>} till {$longest<end>}.\"\n\n```\n\nOutput:\n\n```\n1990-01-01:   26.818 mean from 22 valid.\n1990-01-02:   17.083 mean from 24 valid.\n1990-01-03:   58.958 mean from 24 valid.\n1990-01-04:   75.000 mean from 24 valid.\n1990-01-05:   47.083 mean from 24 valid.\n...\n(many lines omitted)\n...\n2004-12-27:    2.483 mean from 23 valid.\n2004-12-28:    3.383 mean from 23 valid.\n2004-12-29:    2.448 mean from 23 valid.\n2004-12-30:    2.839 mean from 23 valid.\n2004-12-31:    2.057 mean from 23 valid.\nLongest period of invalid readings was 589 hours,\nfrom 1993-02-09 1:00 till 1993-03-05 14:00.\n\n```"}]}
{"messages": [{"role": "user", "content": "The following task concerns data that came from a pollution monitoring station with twenty-four instruments monitoring twenty-four aspects of pollution in the air. Periodically a record is added to the file, each record being a line of 49 fields separated by white-space, which can be one or more space or tab characters.\n\nThe fields (from the left) are:\n\n```\n DATESTAMP [ VALUEn FLAGn ] * 24\n\n```\n\ni.e. a datestamp followed by twenty-four repetitions of a floating-point instrument value and that instrument's associated integer flag. Flag values are >= 1 if the instrument is working and < 1 if there is some problem with it, in which case that instrument's value should be ignored.\n\nA sample from the full data file readings.txt, which is also used in the Text processing/1 task, follows:\n\nData is no longer available at that link. Zipped mirror available here\n\n```\n1991-03-30\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\n1991-03-31\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t10.000\t1\t20.000\t1\t20.000\t1\t20.000\t1\t35.000\t1\t50.000\t1\t60.000\t1\t40.000\t1\t30.000\t1\t30.000\t1\t30.000\t1\t25.000\t1\t20.000\t1\t20.000\t1\t20.000\t1\t20.000\t1\t20.000\t1\t35.000\t1\n1991-03-31\t40.000\t1\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\t0.000\t-2\n1991-04-01\t0.000\t-2\t13.000\t1\t16.000\t1\t21.000\t1\t24.000\t1\t22.000\t1\t20.000\t1\t18.000\t1\t29.000\t1\t44.000\t1\t50.000\t1\t43.000\t1\t38.000\t1\t27.000\t1\t27.000\t1\t24.000\t1\t23.000\t1\t18.000\t1\t12.000\t1\t13.000\t1\t14.000\t1\t15.000\t1\t13.000\t1\t10.000\t1\n1991-04-02\t8.000\t1\t9.000\t1\t11.000\t1\t12.000\t1\t12.000\t1\t12.000\t1\t27.000\t1\t26.000\t1\t27.000\t1\t33.000\t1\t32.000\t1\t31.000\t1\t29.000\t1\t31.000\t1\t25.000\t1\t25.000\t1\t24.000\t1\t21.000\t1\t17.000\t1\t14.000\t1\t15.000\t1\t12.000\t1\t12.000\t1\t10.000\t1\n1991-04-03\t10.000\t1\t9.000\t1\t10.000\t1\t10.000\t1\t9.000\t1\t10.000\t1\t15.000\t1\t24.000\t1\t28.000\t1\t24.000\t1\t18.000\t1\t14.000\t1\t12.000\t1\t13.000\t1\t14.000\t1\t15.000\t1\t14.000\t1\t15.000\t1\t13.000\t1\t13.000\t1\t13.000\t1\t12.000\t1\t10.000\t1\t10.000\t1\n\n```\n\nTask\n\n1. Confirm the general field format of the file.\n2. Identify any DATESTAMPs that are duplicated.\n3. Report the number of records that have good readings for all instruments."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n**Works with**: Rakudo version 2018.03\n\nThis version does validation with a single Raku regex that is much more readable than the typical regex, and arguably expresses the data structure more straightforwardly.\nHere we use normal quotes for literals, and \\h for horizontal whitespace.\n\nVariables like $good-record that are going to be autoincremented do not need to be initialized.\n\nThe .push method on a hash is magical and loses no information; if a duplicate key is found in the pushed pair, an array of values is automatically created of the old value and the new value pushed. Hence we can easily track all the lines that a particular duplicate occurred at.\n\nThe .all method does \"junctional\" logic: it autothreads through comparators as any English speaker would expect. Junctions can also short-circuit as soon as they find a value that doesn't match, and the evaluation order is up to the computer, so it can be optimized or parallelized.\n\nThe final line simply greps out the pairs from the hash whose value is an array with more than 1 element. (Those values that are not arrays nevertheless have a .elems method that always reports 1.) The .pairs is merely there for clarity; grepping a hash directly has the same effect.\nNote that we sort the pairs after we've grepped them, not before; this works fine in Raku, sorting on the key and value as primary and secondary keys. Finally, pairs and arrays provide a default print format that is sufficient without additional formatting in this case.\n\n```\nmy $good-records;\nmy $line;\nmy %dates;\n\nfor lines() {\n    $line++;\n    / ^\n    (\\d ** 4 '-' \\d\\d '-' \\d\\d)\n    [ \\h+ \\d+'.'\\d+ \\h+ ('-'?\\d+) ] ** 24\n    $ /\n        or note \"Bad format at line $line\" and next;\n    %dates.push: $0 => $line;\n    $good-records++ if $1.all >= 1;\n}\n\nsay \"$good-records good records out of $line total\";\n\nsay 'Repeated timestamps (with line numbers):';\n.say for sort %dates.pairs.grep: *.value.elems > 1;\n\n```\n\nOutput:\n\n```\n5017 good records out of 5471 total\nRepeated timestamps (with line numbers):\n1990-03-25 => [84 85]\n1991-03-31 => [455 456]\n1992-03-29 => [819 820]\n1993-03-28 => [1183 1184]\n1995-03-26 => [1910 1911]\n```"}]}
{"messages": [{"role": "user", "content": "A company currently pays a fixed sum for the use of a particular licensed software package.   In determining if it has a good deal it decides to calculate its maximum use of the software from its license management log file.\n\nAssume the software's licensing daemon faithfully records a checkout event when a copy of the software starts and a checkin event when the software finishes to its log file.\n\nAn example of checkout and checkin events are:\n\n```\n License OUT @ 2008/10/03_23:51:05 for job 4974\n ...\n License IN  @ 2008/10/04_00:18:22 for job 4974\n\n```\n\nTask\n\nSave the 10,000 line log file from   here   into a local file, then write a program to scan the file extracting both the maximum licenses that were out at any time, and the time(s) at which this occurs.\n\nMirror of log file available as a zip here (offsite mirror)."}, {"role": "assistant", "content": "(formerly Perl 6)\nAdd some error trapping as recommended by Dijkstra. Not particularly necessary for this specific example but it doesn't hurt to be proactive.\n\nRedirecting the mlijobs.txt file to STDIN:\n\n```\nmy %licenses;\n\n%licenses<count max> = 0,0;\n\nfor $*IN.lines -> $line {\n    my ( $license, $date_time );\n    ( *, $license, *, $date_time ) = split /\\s+/, $line;\n    if $license eq 'OUT' {\n        %licenses<count>++;\n        if %licenses<count> > %licenses<max> {\n            %licenses<max>   = %licenses<count>;\n            %licenses<times> = [$date_time];\n        }\n        elsif %licenses<count> == %licenses<max> {\n            %licenses<times>.push($date_time);\n        }\n    }\n    elsif $license eq 'IN' {\n        if %licenses<count> == %licenses<max> {\n            %licenses<times>[*-1] ~= \" through \" ~ $date_time;\n        }\n        %licenses<count>--;\n    }\n    else {\n        # Not a licence OUT or IN event, do nothing\n    }\n};\n\nmy $plural = %licenses<times>.elems == 1 ?? '' !! 's';\n\nsay \"Maximum concurrent licenses in use: {%licenses<max>}, in the time period{$plural}:\";\nsay join \",\\n\", %licenses<times>.list;\n\n```\n\nExample output:\n\n```\nMaximum concurrent licenses in use: 99, in the time periods:\n2008/10/03_08:39:34 through 2008/10/03_08:39:45,\n2008/10/03_08:40:40 through 2008/10/03_08:40:47\n\n```"}]}
{"messages": [{"role": "user", "content": "When developing a Website it is occasionally necessary to handle text that is received without formatting, and present it in a pleasing manner. to achieve this the text needs to be converted to HTML.\n\nWrite a converter from plain text to HTML.\n\nThe plain text has no formatting information.\n\nIt may have centered headlines, numbered sections, paragraphs, lists, and URIs. It could even have tables.\n\nSimple converters restrict themselves at identifying paragraphs, but i believe more can be done if the text is analyzed.\n\nYou are not requested to copy the algorithm from the existing solutions but use whatever faculties available in your language to best solve the problem.\n\nThe only requirement is to ensure that the result is valid xhtml."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\nThe task specs are essentially non-existent. \"Make a best guess at how to render mark-up free text\"? Anything that could be trusted at all would either be extremely trivial or insanely complex. And it shows by the the task example writers staying away in droves. Five examples after seven years!?\n\nRather than waste time on that noise, I'll demonstrate POD6 to HTML conversion. POD6 is a simple, text-only mark-up used for Raku documentation. (It's Plain Old Documentation for Raku) It uses pretty simple textual markup and has multiple tools to convert the POD6 document in to many other formats, HTML among them.\n\nIt is **not** markup free, but it is actually usable in production.\n\n```\nuse Pod::To::HTML;\nuse HTML::Escape;\n\nmy $pod6 = q:to/POD6/;\n=begin pod\n\nA very simple Pod6 document.\n\nThis is a very high-level, hand-wavey overview. There are I<lots> of other\noptions available.\n\n=head1 Section headings\n\n=head1 A top level heading\n\n=head2 A second level heading\n\n=head3 A third level heading\n\n=head4 A fourth level heading\n\n=head1 Text\n\nOrdinary paragraphs do not require an explicit marker or delimiters.\n\nAlternatively, there is also an explicit =para marker that can be used to\nexplicitly mark a paragraph.\n\n=para\nThis is an ordinary paragraph.\nIts text  will   be     squeezed     and\nshort lines filled.\n\n=head1 Code\n\nEnclose code in a =code block (or V<C< >> markup for short, inline samples)\n\n=begin code\n    my $name = 'Rakudo';\n    say $name;\n=end code\n\n=head1 Lists\n\n=head3 Unordered lists\n\n=item  Grumpy\n=item  Dopey\n=item  Doc\n=item  Happy\n=item  Bashful\n=item  Sneezy\n=item  Sleepy\n\n=head3 Multi-level lists\n\n=item1  Animal\n=item2  Vertebrate\n=item2  Invertebrate\n\n=item1  Phase\n=item2  Solid\n=item2  Liquid\n=item2  Gas\n\n=head1 Formatting codes\n\nFormatting codes provide a way to add inline mark-up to a piece of text.\n\nAll Pod6 formatting codes consist of a single capital letter followed\nimmediately by a set of single or double angle brackets; Unicode double angle\nbrackets may be used.\n\nFormatting codes may nest other formatting codes.\n\nThere are many formatting codes available, some of the more common ones:\n\n=item1 V<B< >> Bold\n=item1 V<I< >> Italic\n=item1 V<U< >> Underline\n=item1 V<C< >> Code\n=item1 V<L< >> Hyperlink\n=item1 V<V< >> Verbatim (Don't interpret anything inside as POD markup)\n\n=head1 Tables\n\nThere is quite extensive markup to allow rendering tables.\n\nA simple example:\n\n=begin table :caption<Mystery Men>\n        The Shoveller   Eddie Stevens     King Arthur's singing shovel\n        Blue Raja       Geoffrey Smith    Master of cutlery\n        Mr Furious      Roy Orson         Ticking time bomb of fury\n        The Bowler      Carol Pinnsler    Haunted bowling ball\n=end table\n\n=end pod\nPOD6\n\n# for display on Rosettacode\nsay escape-html render($pod6);\n\n# normally\n#say render($pod6);\n\n```\n\nReturns something like:\n\n```\n<!doctype html>\n<html lang=\"en\">\n    <head>\n        <title></title>\n        <meta charset=\"UTF-8\" />\n        <style>\n        kbd { font-family: \"Droid Sans Mono\", \"Luxi Mono\", \"Inconsolata\", monospace }\n        samp { font-family: \"Terminus\", \"Courier\", \"Lucida Console\", monospace }\n        u { text-decoration: none }\n        .nested {\n            margin-left: 3em;\n        }\n        aside, u { opacity: 0.7 }\n        a[id^=\"fn-\"]:target { background: #ff0 }\n        </style>\n        <link rel=\"stylesheet\" href=\"//design.raku.org/perl.css\">\n\n    </head>\n    <body class=\"pod\">\n    <div id=\"___top\"></div>\n\n    <nav class=\"indexgroup\">\n<table id=\"TOC\">\n<caption><h2 id=\"TOC_Title\">Table of Contents</h2></caption>\n    <tr class=\"toc-level-1\"><td class=\"toc-number\">1</td><td class=\"toc-text\"><a href=\"#Section_headings\">Section headings</a></td></tr>\n <tr class=\"toc-level-1\"><td class=\"toc-number\">2</td><td class=\"toc-text\"><a href=\"#A_top_level_heading\">A top level heading</a></td></tr>\n <tr class=\"toc-level-2\"><td class=\"toc-number\">2.1</td><td class=\"toc-text\"><a href=\"#A_second_level_heading\">A second level heading</a></td></tr>\n <tr class=\"toc-level-3\"><td class=\"toc-number\">2.1.1</td><td class=\"toc-text\"><a href=\"#A_third_level_heading\">A third level heading</a></td></tr>\n <tr class=\"toc-level-4\"><td class=\"toc-number\">2.1.1.1</td><td class=\"toc-text\"><a href=\"#A_fourth_level_heading\">A fourth level heading</a></td></tr>\n <tr class=\"toc-level-1\"><td class=\"toc-number\">3</td><td class=\"toc-text\"><a href=\"#Text\">Text</a></td></tr>\n    <tr class=\"toc-level-1\"><td class=\"toc-number\">4</td><td class=\"toc-text\"><a href=\"#Code\">Code</a></td></tr>\n      <tr class=\"toc-level-1\"><td class=\"toc-number\">5</td><td class=\"toc-text\"><a href=\"#Lists\">Lists</a></td></tr>\n <tr class=\"toc-level-3\"><td class=\"toc-number\">5.0.1</td><td class=\"toc-text\"><a href=\"#Unordered_lists\">Unordered lists</a></td></tr>\n        <tr class=\"toc-level-3\"><td class=\"toc-number\">5.0.2</td><td class=\"toc-text\"><a href=\"#Multi-level_lists\">Multi-level lists</a></td></tr>\n        <tr class=\"toc-level-1\"><td class=\"toc-number\">6</td><td class=\"toc-text\"><a href=\"#Formatting_codes\">Formatting codes</a></td></tr>\n           <tr class=\"toc-level-1\"><td class=\"toc-number\">7</td><td class=\"toc-text\"><a href=\"#Tables\">Tables</a></td></tr>\n              \n</table>\n</nav>\n\n    <div class=\"pod-body\">\n    <p>A very simple Pod6 document.</p>\n<p>This is a very high-level, hand-wavey overview. There are <em>lots</em> of other options available.</p>\n<h1 id=\"Section_headings\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">Section headings</a></h1>\n<h1 id=\"A_top_level_heading\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">A top level heading</a></h1>\n<h2 id=\"A_second_level_heading\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">A second level heading</a></h2>\n<h3 id=\"A_third_level_heading\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">A third level heading</a></h3>\n<h4 id=\"A_fourth_level_heading\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">A fourth level heading</a></h4>\n<h1 id=\"Text\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">Text</a></h1>\n<p>Ordinary paragraphs do not require an explicit marker or delimiters.</p>\n<p>Alternatively, there is also an explicit =para marker that can be used to explicitly mark a paragraph.</p>\n<p>This is an ordinary paragraph. Its text will be squeezed and short lines filled.</p>\n<h1 id=\"Code\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">Code</a></h1>\n<p>Enclose code in a =code block (or C&lt; &gt; markup for short, inline samples)</p>\n<pre class=\"pod-block-code\">    my $name = &#39;Rakudo&#39;;\n    say $name;\n</pre>\n<h1 id=\"Lists\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">Lists</a></h1>\n<h3 id=\"Unordered_lists\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">Unordered lists</a></h3>\n<ul><li><p>Grumpy</p>\n</li>\n<li><p>Dopey</p>\n</li>\n<li><p>Doc</p>\n</li>\n<li><p>Happy</p>\n</li>\n<li><p>Bashful</p>\n</li>\n<li><p>Sneezy</p>\n</li>\n<li><p>Sleepy</p>\n</li>\n</ul>\n<h3 id=\"Multi-level_lists\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">Multi-level lists</a></h3>\n<ul><li><p>Animal</p>\n</li>\n<ul><li><p>Vertebrate</p>\n</li>\n<li><p>Invertebrate</p>\n</li>\n</ul>\n<li><p>Phase</p>\n</li>\n<ul><li><p>Solid</p>\n</li>\n<li><p>Liquid</p>\n</li>\n<li><p>Gas</p>\n</li>\n</ul>\n</ul>\n<h1 id=\"Formatting_codes\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">Formatting codes</a></h1>\n<p>Formatting codes provide a way to add inline mark-up to a piece of text.</p>\n<p>All Pod6 formatting codes consist of a single capital letter followed immediately by a set of single or double angle brackets; Unicode double angle brackets may be used.</p>\n<p>Formatting codes may nest other formatting codes.</p>\n<p>There are many formatting codes available, some of the more common ones:</p>\n<ul><li><p>B&lt; &gt; Bold</p>\n</li>\n<li><p>I&lt; &gt; Italic</p>\n</li>\n<li><p>U&lt; &gt; Underline</p>\n</li>\n<li><p>C&lt; &gt; Code</p>\n</li>\n<li><p>L&lt; &gt; Hyperlink</p>\n</li>\n<li><p>V&lt; &gt; Verbatim (Don&#39;t interpret anything inside as POD markup)</p>\n</li>\n</ul>\n<h1 id=\"Tables\"><a class=\"u\" href=\"#___top\" title=\"go to top of document\">Tables</a></h1>\n<p>There is quite extensive markup to allow rendering tables.</p>\n<p>A simple example:</p>\n<table class=\"pod-table\">\n<caption>Mystery Men</caption>\n<tbody>\n<tr> <td>The Shoveller</td> <td>Eddie Stevens</td> <td>King Arthur&#39;s singing shovel</td> </tr> <tr> <td>Blue Raja</td> <td>Geoffrey Smith</td> <td>Master of cutlery</td> </tr> <tr> <td>Mr Furious</td> <td>Roy Orson</td> <td>Ticking time bomb of fury</td> </tr> <tr> <td>The Bowler</td> <td>Carol Pinnsler</td> <td>Haunted bowling ball</td> </tr>\n</tbody>\n</table>\n    </div>\n\n    </body>\n</html>\n```"}]}
{"messages": [{"role": "user", "content": "When entering text on a phone's digital pad it is possible that a particular combination of digits corresponds to more than one word. Such are called textonyms.\n\nAssuming the digit keys are mapped to letters as follows:\n\n```\n    2 -> ABC\n    3 -> DEF\n    4 -> GHI\n    5 -> JKL\n    6 -> MNO\n    7 -> PQRS\n    8 -> TUV\n    9 -> WXYZ  \n\n```\n\nTask\n\nWrite a program that finds textonyms in a list of words such as  \nTextonyms/wordlist   or  \nunixdict.txt.\n\nThe task should produce a report:\n\n```\nThere are #{0} words in #{1} which can be represented by the digit key mapping.\nThey require #{2} digit combinations to represent them.\n#{3} digit combinations represent Textonyms.\n\n```\n\nWhere:\n\n```\n#{0} is the number of words in the list which can be represented by the digit key mapping.\n#{1} is the URL of the wordlist being used.\n#{2} is the number of digit combinations required to represent the words in #{0}.\n#{3} is the number of #{2} which represent more than one word.\n\n```\n\nAt your discretion show a couple of examples of your solution displaying Textonyms.\n\nE.G.:\n\n```\n 2748424767 -> \"Briticisms\", \"criticisms\"\n\n```\n\nExtra credit\n\nUse a word list and keypad mapping other than English.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $src = 'unixdict.txt';\n\nmy @words = slurp($src).lines.grep(/ ^ <alpha>+ $ /);\n\nmy @dials = @words.classify: {\n    .trans('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'\n        => '2223334445556667777888999922233344455566677778889999');\n}\n\nmy @textonyms = @dials.grep(*.value > 1);\n\nsay qq:to 'END';\n    There are {+@words} words in $src which can be represented by the digit key mapping.\n    They require {+@dials} digit combinations to represent them.\n    {+@textonyms} digit combinations represent Textonyms.\n    END\n\nsay \"Top 5 in ambiguity:\";\nsay \"    \",$_ for @textonyms.sort(-*.value)[^5];\n\nsay \"\\nTop 5 in length:\";\nsay \"    \",$_ for @textonyms.sort(-*.key.chars)[^5];\n\n```\n\nOutput:\n\n```\nThere are 24978 words in unixdict.txt which can be represented by the digit key mapping.\nThey require 22903 digit combinations to represent them.\n1473 digit combinations represent Textonyms.\n\nTop 5 in ambiguity:\n    269 => amy any bmw bow box boy cow cox coy\n    729 => paw pax pay paz raw ray saw sax say\n    2273 => acre bard bare base cape card care case\n    726 => pam pan ram ran sam san sao scm\n    426 => gam gao ham han ian ibm ibn\n\nTop 5 in length:\n    25287876746242 => claustrophobia claustrophobic\n    7244967473642 => schizophrenia schizophrenic\n    666628676342 => onomatopoeia onomatopoeic\n    49376746242 => hydrophobia hydrophobic\n    2668368466 => contention convention\n```"}]}
{"messages": [{"role": "user", "content": "ISAAC is a cryptographically secure pseudo-random number generator (CSPRNG) and stream cipher. It was developed by Bob Jenkins from 1993 (http://burtleburtle.net/bob/rand/isaac.html) and placed in the Public Domain. ISAAC is fast - especially when optimised - and portable to most architectures in nearly all programming and scripting languages.\nIt is also simple and succinct, using as it does just two 256-word arrays for its state.\n\nISAAC stands for \"Indirection, Shift, Accumulate, Add, and Count\" which are the principal bitwise operations employed.\nTo date - and that's after more than 20 years of existence - ISAAC has not been broken (unless GCHQ or NSA did it, but they wouldn't be telling).\nISAAC thus deserves a lot more attention than it has hitherto received and it would be salutary to see it more universally implemented.\n\nTask\n\nTranslate ISAAC's reference C or Pascal code into your language of choice.\n\nThe RNG should then be seeded with the string \"this is my secret key\" and\nfinally the message \"a Top Secret secret\" should be encrypted on that key.\nYour program's output cipher-text will be a string of hexadecimal digits.\n\nOptional: Include a decryption check by re-initializing ISAAC and performing\nthe same encryption pass on the cipher-text.\n\nPlease use the C or Pascal as a reference guide to these operations.\n\nTwo encryption schemes are possible:\n(1) XOR (Vernam) or\n(2) Caesar-shift mod 95 (Vigenère).\nXOR is the simplest; C-shifting offers greater security.\n\nYou may choose either scheme, or both, but please specify which you used.\nHere are the alternative sample outputs for checking purposes:\n\n```\nMessage: a Top Secret secret\nKey    : this is my secret key\nXOR    : 1C0636190B1260233B35125F1E1D0E2F4C5422\nMOD    : 734270227D36772A783B4F2A5F206266236978\nXOR dcr: a Top Secret secret\nMOD dcr: a Top Secret secret\n\n```\n\nNo official seeding method for ISAAC has been published, but for this task\nwe may as well just inject the bytes of our key into the randrsl array,\npadding with zeroes before mixing, like so:\n\n```\n// zeroise mm array\nFOR i:= 0 TO 255 DO mm[i]:=0;\n// check seed's highest array element\nm := High(seed);\n// inject the seed\nFOR i:= 0 TO 255 DO BEGIN\n\t// in case seed[] has less than 256 elements.\n\tIF i>m THEN randrsl[i]:=0  \n\t\tELSE randrsl[i]:=seed[i];\nEND;\n// initialize ISAAC with seed\nRandInit(true);\n\n```\n\nISAAC can of course also be initialized with a single 32-bit unsigned integer in the manner of traditional RNGs, and indeed used as such for research and gaming purposes.\nBut building a strong and simple ISAAC-based stream cipher - replacing the irreparably broken RC4 - is our goal here: ISAAC's intended purpose."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy uint32 (@mm, @randrsl, $randcnt, $aa, $bb, $cc);\nmy \\ϕ := 2654435769; constant MOD = 95; constant START = 32;\n\nconstant MAXINT = uint.Range.max;\nenum CipherMode < ENCIPHER DECIPHER NONE >;\n\nsub mix (\\n) {\n   sub mix1 (\\i, \\v) { \n      n[i] +^= v;  \n      n[(i+3)%8] += n[i];\n      n[(i+1)%8] += n[(i+2)%8];\n   } \n   mix1 0, n[1]+<11; mix1 1, n[2]+>2; mix1 2, n[3]+<8; mix1 3, n[4]+>16;\n   mix1 4, n[5]+<10; mix1 5, n[6]+>4; mix1 6, n[7]+<8; mix1 7, n[0]+>9 ;\n}\n\nsub randinit(\\flag) {\n   $aa = $bb = $cc = 0;\n   my uint32 @n = [^8].map({ ϕ });\n   for ^4 { mix @n };    \n   for 0,8 … 255 -> $i { \n      { for (0..7) { @n[$^j] += @randrsl[$i + $^j] } } if flag; \n      mix @n;\n      for (0..7) { @mm[$i + $^j] = @n[$^j] }\n   }   \n   if flag {\n      for 0,8 … 255 -> $i {\n         for ^8 { @n[$^j] += @mm[$i + $^j] };\n         mix @n;\n         for ^8 { @mm[$i + $^j] = @n[$^j] };\n      }\n   }\n   isaac;       \n   $randcnt = 0;  \n}\n\nsub isaac() {\n   $cc++;      \n   $bb += $cc;  \n   for ^256 -> $i {\n      my $x = @mm[$i];\n      given ($i % 4) {\n         when 0 { $aa +^= ($aa +< 13) }\n         when 1 { $aa +^= (($aa +& MAXINT) +>  6) }\n         when 2 { $aa +^= ($aa +<  2) }\n         when 3 { $aa +^= (($aa +& MAXINT) +> 16) }\n      }\n      $aa += @mm[($i + 128) % 256];\n      my $y = @mm[(($x +& MAXINT) +> 2) % 256] + $aa + $bb;\n      @mm[$i] = $y;\n      $bb = @mm[(($y +& MAXINT) +> 10) % 256] + $x;\n      @randrsl[$i] = $bb;\n   }\n   $randcnt = 0;\n}\n\nsub iRandom {\n   my $result = @randrsl[$randcnt++];\n   if ($randcnt > 255) {\n      isaac;\n      $randcnt = 0;\n   }\n   return $result;\n}\n\nsub iSeed(\\seed, \\flag) {\n    @mm = [^256].race.map({0});\n    my \\m = seed.chars;\n    @randrsl = [^256].hyper.map({ $^i ≥ m ?? 0 !! seed.substr($^i,1).ord });\n    randinit(flag);\n}\n\nsub iRandA { return iRandom() % MOD + START };\n\nsub vernam(\\M) { ( map { (iRandA() +^ .ord ).chr }, M.comb ).join };\n \nsub caesar(CipherMode \\m, \\ch, $shift is copy, \\Modulo, \\Start) {\n    $shift = -$shift if m == DECIPHER; \n    my $n = (ch.ord - Start) + $shift; \n    $n %= Modulo;\n    $n += Modulo if $n < 0;\n    return (Start + $n).chr;\n}\n\nsub caesarStr(CipherMode \\m, \\msg, \\Modulo, \\Start) {\n   my $sb = '';\n   for msg.comb {\n        $sb ~= caesar m, $^c, iRandA(), Modulo, Start;\n   }\n   return $sb;\n}\n \nmulti MAIN () {    \n   my \\msg = \"a Top Secret secret\";\n   my \\key = \"this is my secret key\";\n \n   iSeed key, True ;\n   my $vctx = vernam msg;\n   my $cctx = caesarStr ENCIPHER, msg,  MOD, START;\n\n   iSeed key, True ;\n   my $vptx = vernam $vctx;\n   my $cptx = caesarStr DECIPHER, $cctx, MOD, START;\n\n   my $vctx2hex = ( map { .ord.fmt('%02X') }, $vctx.comb ).join('');  \n   my $cctx2hex = ( map { .ord.fmt('%02X') }, $cctx.comb ).join('');\n\n   say \"Message : \", msg;\n   say \"Key     : \", key;\n   say \"XOR     : \", $vctx2hex;\n   say \"XOR dcr : \", $vptx;\n   say \"MOD     : \", $cctx2hex;\n   say \"MOD dcr : \", $cptx;\n}\n\n```\n\nOutput:\n\n```\nMessage : a Top Secret secret\nKey     : this is my secret key\nXOR     : 1C0636190B1260233B35125F1E1D0E2F4C5422\nXOR dcr : a Top Secret secret\nMOD     : 734270227D36772A783B4F2A5F206266236978\nMOD dcr : a Top Secret secret\n\n```"}]}
{"messages": [{"role": "user", "content": "Write a program that accepts a name as input and outputs the lyrics to the Shirley Ellis song \"The Name Game\".\n\nThe regular verse\n\nUnless your name begins with a vowel (A, E, I, O, U), 'B', 'F' or 'M' you don't have to care about special rules.\nThe verse for the name 'Gary' would be like this:\n\n```\n   Gary, Gary, bo-bary\n   Banana-fana fo-fary\n   Fee-fi-mo-mary\n   Gary! \n\n```\n\nAt the end of every line, the name gets repeated without the first letter: Gary becomes ary\nIf we take (X) as the full name (Gary) and (Y) as the name without the first letter (ary) the verse would look like this:\n\n```\n   (X), (X), bo-b(Y)\n   Banana-fana fo-f(Y)\n   Fee-fi-mo-m(Y)\n   (X)! \n\n```\n\nVowel as first letter of the name\n\nIf you have a vowel as the first letter of your name (e.g. Earl) you do not truncate the name.\nThe verse looks like this:\n\n```\n   Earl, Earl, bo-bearl\n   Banana-fana fo-fearl\n   Fee-fi-mo-mearl\n   Earl! \n\n```\n\n'B', 'F' or 'M' as first letter of the name\n\nIn case of a 'B', an 'F' or an 'M' (e.g. Billy, Felix, Mary) there is a special rule.\nThe line which would 'rebuild' the name (e.g. bo-billy) is sung without the first letter of the name.\nThe verse for the name Billy looks like this:\n\n```\n   Billy, Billy, bo-illy\n   Banana-fana fo-filly\n   Fee-fi-mo-milly\n   Billy! \n\n```\n\nFor the name 'Felix', this would be right:\n\n```\n   Felix, Felix, bo-belix\n   Banana-fana fo-elix\n   Fee-fi-mo-melix\n   Felix!\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nMeh. The rules leave out some corner cases (see Steve) but what the heck, technically correct is the best kind of correct.\n\n```\nsub mangle ($name, $initial) {\n    my $fl = $name.lc.substr(0,1);\n    $fl ~~ /<[aeiou]>/\n    ?? $initial~$name.lc\n    !! $fl eq $initial\n    ?? $name.substr(1)\n    !! $initial~$name.substr(1)\n}\n\nsub name-game (Str $name) {\n    qq:to/NAME-GAME/;\n    $name, $name, bo-{ mangle $name, 'b' }\n    Banana-fana fo-{ mangle $name, 'f' }\n    Fee-fi-mo-{ mangle $name, 'm' }\n    $name!\n    NAME-GAME\n}\n\nsay .&name-game for <Gary Earl Billy Felix Mike Steve>\n\n```\n\nOutput:\n\n```\nGary, Gary, bo-bary\nBanana-fana fo-fary\nFee-fi-mo-mary\nGary!\n\nEarl, Earl, bo-bearl\nBanana-fana fo-fearl\nFee-fi-mo-mearl\nEarl!\n\nBilly, Billy, bo-illy\nBanana-fana fo-filly\nFee-fi-mo-milly\nBilly!\n\nFelix, Felix, bo-belix\nBanana-fana fo-elix\nFee-fi-mo-melix\nFelix!\n\nMike, Mike, bo-bike\nBanana-fana fo-fike\nFee-fi-mo-ike\nMike!\n\nSteve, Steve, bo-bteve\nBanana-fana fo-fteve\nFee-fi-mo-mteve\nSteve!\n\n```"}]}
{"messages": [{"role": "user", "content": "The sieve of Eratosthenes: you've been there; done that; have the T-shirt. The sieve of Eratosthenes was ancient history when Euclid was a schoolboy. You are ready for something less than 3000 years old. You are ready for The sieve of Sundaram.\n\nStarting with the ordered set of +ve integers, mark every third starting at 4 (4;7;10...).\n\nStep through the set and if the value is not marked output 2\\*n+1. So from 1 to 4 output 3 5 7.\n\n4 is marked so skip for 5 and 6 output 11 and 13.\n\n7 is marked, so no output but now also mark every fifth starting at 12 (12;17;22...)\n\nas per to 10 and now mark every seventh starting at 17 (17;24;31....)\n\nas per for every further third element (13;16;19...) mark every (9th;11th;13th;...) element.\n\nThe output will be the ordered set of odd primes.\n\nUsing your function find and output the first 100 and the millionth Sundaram prime.\n\nThe faithless amongst you may compare the results with those generated by The sieve of Eratosthenes.\n\nReferences\n\n* The article on Wikipedia.\n\n**Comment on the Sundaram Sieve**\n\nIn case casual readers and programmers read the above blurb and get the impression that something several thousand years newer must needs be better than the \"old\" Sieve of Eratosthenes (SoE), do note the only difference between the Sieve of Sundaram (SoS) and the odds-only SoE is that the SoS marks as composite/\"culls\" according to **all odd \"base\" numbers** as is quite clear in the above description of how to implement it and the above linked Wikipedia article (updated), and the SoE marks as composite/\"culls\" according to only the previously determined unmarked primes (which are all odd except for two, which is not used for the \"odds-only\" algorithm); the time complexity (which relates to the execution time) is therefore O(n log n) for the SoS and O(n log log n) for the SoE, which difference can make a huge difference to the time it takes to sieve as the ranges get larger. It takes about a billion \"culls\" to sieve odds-only to a billion for the SoE, whereas it takes about 2.28 billion \"culls\" to cull to the same range for the SoS, which implies that the SoS must be about this ratio slower for this range with the memory usage identical. Why would one choose the SoS over the SoE to save a single line of code at the cost of this much extra time? The Wren comparison at the bottom of this page makes that clear, as would implementing the same in any language."}, {"role": "assistant", "content": "```\nmy $nth = 1_000_000;\n\nmy $k = Int.new: 2.4 * $nth * log($nth) / 2;\n\nmy int @sieve;\n\n@sieve[$k] = 0;\n\nrace for (1 .. $k).batch(1000) -> @i {\n  for @i -> int $i {\n    my int $j = $i;\n    while (my int $l = $i + $j + 2 * $i * $j++) < $k {\n        @sieve[$l] = 1;\n    }\n  }\n}\n\n@sieve[0] = 1;\n\nsay \"First 100 Sundaram primes:\";\nsay @sieve.kv.map( { next if $^v; $^k * 2 + 1 } )[^100]».fmt(\"%4d\").batch(10).join: \"\\n\";\n\nsay \"\\nOne millionth:\";\nmy ($count, $index);\nfor @sieve {\n    $count += !$_;\n    say $index * 2 + 1 and last if $count == $nth;\n    ++$index;\n}\n\n```\n\nOutput:\n\n```\nFirst 100 Sundaram primes:\n   3    5    7   11   13   17   19   23   29   31\n  37   41   43   47   53   59   61   67   71   73\n  79   83   89   97  101  103  107  109  113  127\n 131  137  139  149  151  157  163  167  173  179\n 181  191  193  197  199  211  223  227  229  233\n 239  241  251  257  263  269  271  277  281  283\n 293  307  311  313  317  331  337  347  349  353\n 359  367  373  379  383  389  397  401  409  419\n 421  431  433  439  443  449  457  461  463  467\n 479  487  491  499  503  509  521  523  541  547\n\nOne millionth:\n15485867\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program that outputs the lyrics of the Christmas carol *The Twelve Days of Christmas*.\nThe lyrics can be found here.\n\n(You must reproduce the words in the correct order, but case, format, and punctuation are left to your discretion.)\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @days = <first second third fourth fifth sixth seventh eighth ninth tenth eleventh twelfth>;\n\nmy @gifts = lines q:to/END/;\n  And a partridge in a pear tree.\n  Two turtle doves,\n  Three french hens,\n  Four calling birds,\n  Five golden rings,\n  Six geese a-laying,\n  Seven swans a-swimming,\n  Eight maids a-milking,\n  Nine ladies dancing,\n  Ten lords a-leaping,\n  Eleven pipers piping,\n  Twelve drummers drumming,\nEND\n\nsub nth($n) { say \"On the @days[$n] day of Christmas, my true love gave to me:\" }\n\nnth(0);\nsay @gifts[0].subst('And a','A');\n\nfor 1 ... 11 -> $d {\n    say '';\n    nth($d);\n    say @gifts[$_] for $d ... 0;\n}\n\n```\n\nOutput:\n\n```\nOn the first day of Christmas, my true love gave to me:\n  A partridge in a pear tree.\n\nOn the second day of Christmas, my true love gave to me:\n  Two turtle doves,\n  And a partridge in a pear tree.\n\nOn the third day of Christmas, my true love gave to me:\n  Three french hens,\n  Two turtle doves,\n  And a partridge in a pear tree.\n\nOn the fourth day of Christmas, my true love gave to me:\n  Four calling birds,\n  Three french hens,\n  Two turtle doves,\n  And a partridge in a pear tree.\n.\n.\n.\nOn the twelfth day of Christmas, my true love gave to me:\n  Twelve drummers drumming,\n  Eleven pipers piping,\n  Ten lords a-leaping,\n  Nine ladies dancing,\n  Eight maids a-milking,\n  Seven swans a-swimming,\n  Six geese a-laying,\n  Five golden rings,\n  Four calling birds,\n  Three french hens,\n  Two turtle doves,\n  And a partridge in a pear tree.\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Thiele's interpolation formula. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\n**Thiele's interpolation formula** is an interpolation formula for a function *f*(•) of a single variable.   It is expressed as a continued fraction:\n\n:   :   f\n        (\n        x\n        )\n        =\n        f\n        (\n\n        x\n\n        1\n        )\n        +\n\n        x\n        −\n\n        x\n\n        1\n\n        ρ\n\n        1\n        (\n\n        x\n\n        1\n        ,\n\n        x\n\n        2\n        )\n        +\n\n        x\n        −\n\n        x\n\n        2\n\n        ρ\n\n        2\n        (\n\n        x\n\n        1\n        ,\n\n        x\n\n        2\n        ,\n\n        x\n\n        3\n        )\n        −\n        f\n        (\n\n        x\n\n        1\n        )\n        +\n\n        x\n        −\n\n        x\n\n        3\n\n        ρ\n\n        3\n        (\n\n        x\n\n        1\n        ,\n\n        x\n\n        2\n        ,\n\n        x\n\n        3\n        ,\n\n        x\n\n        4\n        )\n        −\n\n        ρ\n\n        1\n        (\n\n        x\n\n        1\n        ,\n\n        x\n\n        2\n        )\n        +\n        ⋯\n        {\\displaystyle {\\displaystyle f(x)=f(x\\_{1})+{\\cfrac {x-x\\_{1}}{\\rho \\_{1}(x\\_{1},x\\_{2})+{\\cfrac {x-x\\_{2}}{\\rho \\_{2}(x\\_{1},x\\_{2},x\\_{3})-f(x\\_{1})+{\\cfrac {x-x\\_{3}}{\\rho \\_{3}(x\\_{1},x\\_{2},x\\_{3},x\\_{4})-\\rho \\_{1}(x\\_{1},x\\_{2})+\\cdots }}}}}}}}\n\nρ\n{\\displaystyle {\\displaystyle \\rho }}\n   represents the   reciprocal difference,   demonstrated here for reference:\n\n:   :   ρ\n\n        1\n        (\n\n        x\n\n        0\n        ,\n\n        x\n\n        1\n        )\n        =\n\n        x\n\n        0\n        −\n\n        x\n\n        1\n\n        f\n        (\n\n        x\n\n        0\n        )\n        −\n        f\n        (\n\n        x\n\n        1\n        )\n        {\\displaystyle {\\displaystyle \\rho \\_{1}(x\\_{0},x\\_{1})={\\frac {x\\_{0}-x\\_{1}}{f(x\\_{0})-f(x\\_{1})}}}}\n\n:   :   ρ\n\n        2\n        (\n\n        x\n\n        0\n        ,\n\n        x\n\n        1\n        ,\n\n        x\n\n        2\n        )\n        =\n\n        x\n\n        0\n        −\n\n        x\n\n        2\n\n\n        ρ\n\n        1\n        (\n\n        x\n\n        0\n        ,\n\n        x\n\n        1\n        )\n        −\n\n        ρ\n\n        1\n        (\n\n        x\n\n        1\n        ,\n\n        x\n\n        2\n        )\n        +\n        f\n        (\n\n        x\n\n        1\n        )\n        {\\displaystyle {\\displaystyle \\rho \\_{2}(x\\_{0},x\\_{1},x\\_{2})={\\frac {x\\_{0}-x\\_{2}}{\\rho \\_{1}(x\\_{0},x\\_{1})-\\rho \\_{1}(x\\_{1},x\\_{2})}}+f(x\\_{1})}}\n\n:   :   ρ\n\n        n\n        (\n\n        x\n\n        0\n        ,\n\n        x\n\n        1\n        ,\n        …\n        ,\n\n        x\n\n        n\n        )\n        =\n\n        x\n\n        0\n        −\n\n        x\n\n        n\n\n\n        ρ\n\n        n\n        −\n        1\n        (\n\n        x\n\n        0\n        ,\n\n        x\n\n        1\n        ,\n        …\n        ,\n\n        x\n\n        n\n        −\n        1\n        )\n        −\n\n        ρ\n\n        n\n        −\n        1\n        (\n\n        x\n\n        1\n        ,\n\n        x\n\n        2\n        ,\n        …\n        ,\n\n        x\n\n        n\n        )\n        +\n\n        ρ\n\n        n\n        −\n        2\n        (\n\n        x\n\n        1\n        ,\n        …\n        ,\n\n        x\n\n        n\n        −\n        1\n        )\n        {\\displaystyle {\\displaystyle \\rho \\_{n}(x\\_{0},x\\_{1},\\ldots ,x\\_{n})={\\frac {x\\_{0}-x\\_{n}}{\\rho \\_{n-1}(x\\_{0},x\\_{1},\\ldots ,x\\_{n-1})-\\rho \\_{n-1}(x\\_{1},x\\_{2},\\ldots ,x\\_{n})}}+\\rho \\_{n-2}(x\\_{1},\\ldots ,x\\_{n-1})}}\n\nDemonstrate Thiele's interpolation function by:\n\n1. Building a   **32**   row *trig table* of values   for   \n\n   x\n   {\\displaystyle {\\displaystyle x}}\n      from   **0**   by   **0.05**   to   **1.55**   of the trig functions:\n   * **sin**\n   * **cos**\n   * **tan**\n2. Using columns from this table define an inverse - using Thiele's interpolation - for each trig function;\n3. Finally: demonstrate the following well known trigonometric identities:\n   * 6 × sin-1 ½ = \n\n     π\n     {\\displaystyle {\\displaystyle \\pi }}\n   * 3 × cos-1 ½ = \n\n     π\n     {\\displaystyle {\\displaystyle \\pi }}\n   * 4 × tan-1 1 = \n\n     π\n     {\\displaystyle {\\displaystyle \\pi }}"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.09\n\nImplemented to parallel the generalized formula, making for clearer, but slower, code. Offsetting that, the use of `Promise` allows concurrent calculations, so running all three types of interpolation should not take any longer than running just one (presuming available cores).\n\n```\n# reciprocal difference:\nmulti sub ρ(&f, @x where * < 1) { 0 } # Identity\nmulti sub ρ(&f, @x where * == 1) { &f(@x[0]) }\nmulti sub ρ(&f, @x where * > 1) {\n    ( @x[0] - @x[* - 1] )       # ( x - x[n] )\n    / (ρ(&f, @x[^(@x - 1)])     # / ( ρ[n-1](x[0], ..., x[n-1])\n    - ρ(&f, @x[1..^@x]) )       # - ρ[n-1](x[1], ..., x[n]) )\n    + ρ(&f, @x[1..^(@x - 1)]);  # + ρ[n-2](x[1], ..., x[n-1])\n}\n \n# Thiele:\nmulti sub thiele($x, %f, $ord where { $ord == +%f }) { 1 } # Identity\nmulti sub thiele($x, %f, $ord) {\n  my &f = {%f{$^a}};                # f(x) as a table lookup\n \n  # must sort hash keys to maintain order between invocations\n  my $a = ρ(&f, %f.keys.sort[^($ord +1)]);\n  my $b = ρ(&f, %f.keys.sort[^($ord -1)]);\n \n  my $num = $x - %f.keys.sort[$ord];\n  my $cont = thiele($x, %f, $ord +1);\n \n  # Thiele always takes this form:\n  return $a - $b + ( $num / $cont );\n}\n \n## Demo\nsub mk-inv(&fn, $d, $lim) {\n  my %h;\n  for 0..$lim { %h{ &fn($_ * $d) } = $_ * $d }\n  return %h;\n}\n \nsub MAIN($tblsz = 12) {\n\n  my ($sin_pi, $cos_pi, $tan_pi);\n  my $p1 = Promise.start( { my %invsin = mk-inv(&sin, 0.05, $tblsz); $sin_pi = 6 * thiele(0.5, %invsin, 0) } );\n  my $p2 = Promise.start( { my %invcos = mk-inv(&cos, 0.05, $tblsz); $cos_pi = 3 * thiele(0.5, %invcos, 0) } );\n  my $p3 = Promise.start( { my %invtan = mk-inv(&tan, 0.05, $tblsz); $tan_pi = 4 * thiele(1.0, %invtan, 0) } );\n  await $p1, $p2, $p3;\n \n  say \"pi = {pi}\";\n  say \"estimations using a table of $tblsz elements:\";\n  say \"sin interpolation: $sin_pi\";\n  say \"cos interpolation: $cos_pi\";\n  say \"tan interpolation: $tan_pi\";\n}\n\n```\n\nOutput:\n\n```\npi = 3.14159265358979\nestimations using a table of 12 elements:\nsin interpolation: 3.14159265358961\ncos interpolation: 3.1387286696692\ntan interpolation: 3.14159090545243\n```"}]}
{"messages": [{"role": "user", "content": "If one were to enter the words: 'softly affiliate activation' at the what3words.com site, the response would be a location in Walt Disney World. The latitude and longitude for that spot is 28.3852 -81.5638. Using that service enables anyone to specify any place on the Earth with three words.\n\nTask: Provide a similar solution - Display a location on the Earth with three words derived from a latitude longitude pair.\n\nFor: latitude = 28.3852 longitude = -81.5638 Display: W18497 W11324 W01322\n\nImplementation:\n\nBuild an array of 28126, 6 character words in the form W00000 thru W28125.\n\nConvert latitude and longitude into positive integers.\n\nBuild a 43 bit integer containing latitude (21 bits) and longitude (22 bits).\n\nIsolate most significant 15 bits for word 1 index.\n\nIsolate next 14 bits for word 2 index.\n\nIsolate next 14 bits for word 3 index.\n\nFetch each word from the word array.\n\nDisplay the words.\n\nReverse the procedure and display the original latitude and longitude.\n\nExtra credit: Find a way to populate the word array with actual words."}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.07\n\n### The task\n\nIn large part due to the complete lack of specification, reference implementation, or guidance from the task creator, came up with my own bespoke synthetic word list.\n\nWords always consist of a series of consonant/vowel pairs. Uses a cut down alphabet to reduce possible confusion from overlapping pronunciation.\n\nSome letters with overlapping pronunciation are removed: c: confusable with k or s, g: overlaps with j, x: overlaps with z, q: just because, v: similar to w and we have way more than enough characters anyway.\n\nAs it is, with this alphabet we can form 512000 different 6 character \"words\"; 28126 is a drop in the bucket. To spread out the the words a bit, add a bit of randomness. 28126 fits into 512000 18 and a bit times. Add a random multiple of 28126 to the encoder then modulus it back out on decode. Will get different results on different runs.\n\nWe don't bother to pre-calculate and store the words, just generate them on the fly.\n\nOfficial pronunciation guide:\n\n* a - long a (say may day)\n* e - long e (he me see)\n* i - long i (hi sigh die)\n* o - long o (go so low)\n* u - long u (due boo moo)\n\n```\n# SYNTHETICS HANDLING\nmy @synth = flat < b d f h j k l m n p r s t w y z > X~ < a e i o u >;\nmy %htnys = @synth.antipairs;\nmy $exp   = @synth.elems;\n\nsub synth (Int $v) { @synth[($v + (^18).pick * 28126).polymod($exp xx *).reverse || 0].join }\n\nsub thnys (Str $v) { (sum %htnys{$v.comb(2).reverse} Z* 1, $exp, $exp**2) % 28126 }\n\n\n# ENCODE / DECODE\nsub w-encode ( Rat(Real) $lat, Rat(Real) $lon, :&f = &synth ) {\n    $_ = (($lat +  90) * 10000).round.fmt('%021b') ~ (($lon + 180) * 10000).round.fmt('%022b');\n    (:2(.substr(0,15)), :2(.substr(15,14)),:2(.substr(29)))».&f\n}\n\nsub w-decode ( *@words, :&f = &thnys ) {\n    my $bin = (@words».&f Z, <0 1 1>).map({.[0].fmt('%015b').substr(.[1])}).join;\n    (:2($bin.substr(0,21))/10000) - 90, (:2($bin.substr(21))/10000) - 180\n}\n\n\n# TESTING\nfor 51.4337,  -0.2141, # Wimbledon\n    21.2596,-157.8117, # Diamond Head crater\n   -55.9652, -67.2256, # Monumento Cabo De Hornos\n    59.3586,  24.7447, # Lake Raku\n    29.2021,  81.5324, # Village Raku\n    -7.1662,  53.9470, # The Indian ocean, south west of Seychelles\n    28.3852, -81.5638  # Walt Disney World\n  -> $lat, $lon {\n    my @words = w-encode $lat, $lon;\n    my @index = w-encode $lat, $lon, :f( { $_ } );\n    printf \"Coordinates: %s, %s\\n   To Index: %s\\n  To 3-word: %s\\nFrom 3-word: %s, %s\\n From Index: %s, %s\\n\\n\",\n      $lat, $lon, @index.Str, @words.Str, w-decode(@words), w-decode @index, :f( { $_ } );\n}\n\n```\n\nOutput:\n\n```\nCoordinates: 51.4337, -0.2141\n   To Index: 22099 365 12003\n  To 3-word: zofobe fohujo habute\nFrom 3-word: 51.4337, -0.2141\n From Index: 51.4337, -0.2141\n\nCoordinates: 21.2596, -157.8117\n   To Index: 17384 5133 8891\n  To 3-word: nijemo zanaza fupawu\nFrom 3-word: 21.2596, -157.8117\n From Index: 21.2596, -157.8117\n\nCoordinates: -55.9652, -67.2256\n   To Index: 5317 15428 13632\n  To 3-word: zanohu julaso husese\nFrom 3-word: -55.9652, -67.2256\n From Index: -55.9652, -67.2256\n\nCoordinates: 59.3586, 24.7447\n   To Index: 23337 4732 15831\n  To 3-word: kapupi hokame supoku\nFrom 3-word: 59.3586, 24.7447\n From Index: 59.3586, 24.7447\n\nCoordinates: 29.2021, 81.5324\n   To Index: 18625 5535 10268\n  To 3-word: dijule nutuza nefini\nFrom 3-word: 29.2021, 81.5324\n From Index: 29.2021, 81.5324\n\nCoordinates: -7.1662, 53.947\n   To Index: 12942 12942 12942\n  To 3-word: rakudo rakudo rakudo\nFrom 3-word: -7.1662, 53.947\n From Index: -7.1662, 53.947\n\nCoordinates: 28.3852, -81.5638\n   To Index: 18497 11324 1322\n  To 3-word: tabesa nekaso bupodo\nFrom 3-word: 28.3852, -81.5638\n From Index: 28.3852, -81.5638\n```\n\n(Ok, I admit I manipulated that second to last one, but it **is** a correct and valid 3-word location in this implementation. There is less than 1 chance in 5000 that it will produce that specific word group though.)\n\n### A thought experiment\n\nA little thought experiment... Latitude, longitude to four decimal places is accurate to about 11.1 meters at the equator, smaller the further from the equator you get.\nWhat would it take to support five decimal places? (Accurate to 1.11 meters.)\n\n`360 * 100000 == 36000000;\nceiling 36000000.log(2) == 26;`\n\nSo we need 26 bits to cover 360.00000; half of that for 180.00000, or `26 bits + 25 bits == 51 bits`. `51 / 3 == 17`. `2**17 == 131072` indices. The previous synthetics routine provides much more than enough.\n\nHow many sylabics will we need to minimally cover it?\n\n`∛131072 == 50.7968...`\n\nSo at least 51. The synthetics routine provide sylabics in blocks of 5, so we would need\nat least 11 consonants.\n\nCapriciously and somewhat randomly cutting down the list we arrive at this.\n\n10 times better accuracy in the same three, 6-letter word space.\n\n```\n# SYNTHETICS HANDLING\nmy @synth = flat < b d f j k n p r s t w > X~ < a e i o u >;\nmy %htnys = @synth.antipairs;\nmy $exp   = @synth.elems;\nmy $prec  = 100_000;\n\n\nsub synth (Int $v) { @synth[$v.polymod($exp xx *).reverse || 0].join }\n\nsub thnys (Str $v) { sum %htnys{$v.comb(2).reverse} Z× 1, $exp, $exp² }\n\n\n# ENCODE / DECODE\nsub w-encode ( Rat(Real) $lat, Rat(Real) $lon, :&f = &synth ) {\n    $_ = (($lat +  90) × $prec).round.fmt('%025b') ~ (($lon + 180) × $prec).round.fmt('%026b');\n    (:2(.substr(0,17)), :2(.substr(17,17)), :2(.substr(34)))».&f\n}\n\nsub w-decode ( *@words, :&f = &thnys ) {\n    my $bin = @words».&f.map({.fmt('%017b')}).join;\n    (:2($bin.substr(0,25))/$prec) - 90, (:2($bin.substr(25))/$prec) - 180\n}\n\n\n# TESTING\nfor 51.43372,  -0.21412, # Wimbledon center court\n    21.25976,-157.81173, # Diamond Head summit\n   -55.96525, -67.22557, # Monumento Cabo De Hornos\n    28.3852,  -81.5638,  # Walt Disney World\n    89.99999, 179.99999, # test some\n   -89.99999,-179.99999  # extremes\n  -> $lat, $lon {\n    my @words = w-encode $lat, $lon;\n    printf \"Coordinates: %s, %s\\n   To Index: %s\\n  To 3-word: %s\\nFrom 3-word: %s, %s\\n\\n\",\n      $lat, $lon, w-encode($lat, $lon, :f({$_})).Str, @words.Str, w-decode(@words);\n}\n\n```\n\nOutput:\n\n```\nCoordinates: 51.43372, -0.21412\n   To Index: 55247 71817 21724\n  To 3-word: jofuni kosasi diduwu\nFrom 3-word: 51.43372, -0.21412\n\nCoordinates: 21.25976, -157.81173\n   To Index: 43460 110608 121675\n  To 3-word: fukafa repebo safija\nFrom 3-word: 21.25976, -157.81173\n\nCoordinates: -55.96525, -67.22557\n   To Index: 13294 108118 5251\n  To 3-word: bukeru rasaso besane\nFrom 3-word: -55.96525, -67.22557\n\nCoordinates: 28.3852, -81.5638\n   To Index: 46244 28747 13220\n  To 3-word: jajasu duniri bukaka\nFrom 3-word: 28.3852, -81.5638\n\nCoordinates: 89.99999, 179.99999\n   To Index: 70312 65298 86271\n  To 3-word: kofoki kepifo nonope\nFrom 3-word: 89.99999, 179.99999\n\nCoordinates: -89.99999, -179.99999\n   To Index: 0 512 1\n  To 3-word: ba duji be\nFrom 3-word: -89.99999, -179.99999\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a Thue-Morse sequence.\n\nSee also\n\n* YouTube entry: The Fairest Sharing Sequence Ever\n* YouTube entry: Math and OCD - My story with the Thue-Morse sequence\n* Task: Fairshare between two and more"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2018.03\n\nFirst 8 of an infinite sequence\n\n```\n.say for (0, { '0' ~ @_.join.trans( \"01\" => \"10\", :g) } ... *)[^8];\n\n```\n\nOutput:\n\n```\n0\n01\n0110\n01101001\n0110100110010110\n01101001100101101001011001101001\n0110100110010110100101100110100110010110011010010110100110010110\n01101001100101101001011001101001100101100110100101101001100101101001011001101001011010011001011001101001100101101001011001101001\n^C\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nPlay a game of tic-tac-toe.\n\nEnsure that legal moves are played and that a winning position is notified.\n\n*Tic-tac-toe*   is also known as:\n\n:   :   * *noughts and crosses*\n        * *tic tac toe*\n        * *tick tack toe*\n        * *three in a row*\n        * *tres en rayo*       and\n        * *Xs  and  Os*\n\nSee also\n\n* MathWorld™, Tic-Tac-Toe game.\n* Wikipedia tic-tac-toe."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\nThe computer plays a random game.\n\n```\nmy @board = 1..9;\nmy @winning-positions = [0..2], [3..5], [6..8], [0,3,6], [1,4,7], [2,5,8],\n\t[0,4,8], [6,4,2];\n\nsub get-winner() {\n\tfor @winning-positions {\n        return (@board[|$_][0], $_) if [eq] @board[|$_];\n\t}\n}\n\nsub free-indexes() {\n\t@board.keys.grep: { @board[$_] eq any(1..9) }\n}\n\nsub ai-move() {\n\tgiven free-indexes.pick {\n\t\t@board[$_] = 'o';\n\t\tsay \"I go at: { $_ + 1 }\\n\";\n\t}\n}\n\nsub print-board() {\n    print \"\\e[2J\";\n    say @board.map({ \"$^a | $^b | $^c\" }).join(\"\\n--+---+--\\n\"), \"\\n\";\n}\n\nsub human-move() {\n\tmy $pos = prompt \"Choose one of { (free-indexes() »+» 1).join(\",\") }: \";\n\tif $pos eq any(free-indexes() »+» 1) {\n\t\t@board[$pos - 1] = 'x';\n\t} else {\n\t\tsay \"Sorry, you want to put your 'x' where?\";\n\t\thuman-move();\n\t}\n}\n\nfor flat (&ai-move, &human-move) xx * {\n\tprint-board;\n    last if get-winner() or not free-indexes;\n    .();\n}\n\nif get-winner() -> ($player, $across) {\n\tsay \"$player wins across [\", ($across »+» 1).join(\", \"), \"].\";\n} else {\n\tsay \"How boring, a draw!\";\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program which uses a timer (with the least granularity available\non your system) to time how long a function takes to execute.\n\nWhenever possible, use methods which measure only the processing time used\nby the current process; instead of the difference in system time\nbetween start and finish, which could include time used by\nother processes on the computer.\n\nThis task is intended as a subtask for Measure relative performance of sorting algorithms implementations."}, {"role": "assistant", "content": "(formerly Perl 6)\nFollows modern trend toward measuring wall-clock time, since CPU time is becoming rather ill-defined in the age of multicore, and doesn't reflect IO overhead in any case.\n\n```\nmy $start = now;\n(^100000).pick(1000);\nsay now - $start;\n\n```\n\nOutput:\n\n```\n0.02301709\n```"}]}
{"messages": [{"role": "user", "content": "## Time Conventions and Conversions\n\n### Background\n\nThe accurate timing of events is an important measure in many areas of computing.\n\nComputer benchmarking or network timeouts may use the computer clock only to compute the difference in time between events. For other tasks, such as measuring the time of events in a way that is independent of individual computers or when logging an event as having occurred at a particular time for later evaluation, an external time system is necessary to allow software to \"tag\" an event in time with a **timestamp** that can establish its position within an event history in that time system.\n\nThere are many such **timestamp** standards in use, and sometimes data with one system's timestamp may need to be used with a system that contains other data using a different system's timestamp. To properly correlate such mixed data, conversion of dates and times between timestamps in different systems is required.\n\nThe current task is to create a function or functions to perform timestamp conversions between **time conventions**, systems established as social conventions for tracking events in time.\n\n### Time system epochs\n\nWhen converting between time conventions, the origin (time 0) of each convention needs to be considered, along with the historical times of past adjustment of the system if any. The time 0 (sometimes, time 1) of a system can be referred to as its **epoch**.\n\n#### UTC Time\n\nThe **ISO 8601 standard** created the time convention of **Coordinated Universal Time**, or **UTC**.\n\nThe ISO 8601 standard expresses dates and times in the format \"yyyy-mm-ddTHH:MM:SS.xxx\", where yyyy is 4-digit year, mm is 2-digit month, dd is 2-digit day of month, HH is 2-digit, 24-hour hour, MM is 2-digit minutes past the hour, SS is seconds past the minute, T is the letter T used to separate days from hours, and xxx is an optional decimal fraction of a second. In addition, the timestamp may have a timezone such as GMT appended to the UTC string (note however that time zones will not be covered in this task).\n\nUTC defines Day 1 of the year 1 Common Era (AD) as 0001-1-1T00:00:00. Exceptionally for a mostly continuous variable, there is no 0 year in the conventional AD/BC, CE/BCE calendar. Instead, the previous year is defined to start at 0000:1:1T00:00:00Z, so the years going backwards in the CE/BCE system are are ...3 CE, 2 CE, 1 CE, 1 BCE, 2 BCE... whereas in UTC these are ...3, 2, 1, 0, -1...\n\nThe actual day 0, the UTC epoch start, is then 1 BCE, and the Day 0 epoch is defined as at the last day of year 1 BCE, or December 31, 1 BCE (BC), which is 0000-12-31T00:00:00 in the ISO 8601 standard for UTC time stamps.\n\n#### UNIX Time\n\nThe Unix operating system time() function was the basis for the convention of **Unix system time**.\n\nThe Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of non-leap seconds that have elapsed since January 1, 1970 (midnight Coordinated Universal Time, or UTC, also GMT), not counting leap seconds. The time() function in Unix actually returns the number of (non-leap) milliseconds since the Unix epoch as a floating point number, which would be the Unix timestamp.\n\nThe Unix \"epoch\" is thus expressed in UTC 8601 terms as 1970-01-01T00:00:00.\n\n#### NTP Time\n\nThe Network Time Protocol (or **NTP**) defines the prime epoch as beginning at UTC 1900-01-01T00:00:00. NTP timestamps are defined as the number of non-leap seconds since the NTP epoch.\n\n### Leap seconds\n\nThe moon's tidal drag on Earth makes the Earth's rotation slow very slightly over the years, at a rate that is usually less than a second a year but varies from year to year. Because of a desire to keep the time of day in synchrony with the Earth's rotation, the exact duration of a year varies because of **leap seconds**. On certain years there have been **leap seconds** added at midnight mostly between 31 December and 1 January and occasionally at midnight between June 30 and July 1. These changes have been used to keep the **UTC** time of day in sync with the astronomical day. The **Unix**, **NTP**, and **UTC** time conventions essentially ignore leap seconds in their timekeeping. On the other hand, there other time conventions, including the **TAI** and **GPS** conventions, which advance their second clock even during leap seconds. This has caused **TAI time** and **GPS time** to progressively run ahead of **UTC time** by a slowly increasing number of seconds, even though the second measure itself is constant between conventions.\n\n#### The leap second table\n\nA file is kept current at the **NIST** ftp site, filed as **ftp.boulder.nist.gov/pub/time/leap-seconds.list**, which contains a history of each timestamp (in **NTP** time) in which the leap seconds were added and ignored in the counting of seconds in **NTP**, **Unix**, and **UTC** conventions.\n\nThe leap-seconds.list file currently contains data including the following:\n\n```\nTimestamp of last update of this file in NTP seconds:\n3929093563\n\nPlanned expiration date of the file in NTP timestamp seconds:\n3960057600\n\n2272060800      10      # 1 Jan 1972\n2287785600      11      # 1 Jul 1972\n2303683200      12      # 1 Jan 1973\n2335219200      13      # 1 Jan 1974\n2366755200      14      # 1 Jan 1975\n2398291200      15      # 1 Jan 1976\n2429913600      16      # 1 Jan 1977\n2461449600      17      # 1 Jan 1978\n2492985600      18      # 1 Jan 1979\n2524521600      19      # 1 Jan 1980\n2571782400      20      # 1 Jul 1981\n2603318400      21      # 1 Jul 1982\n2634854400      22      # 1 Jul 1983\n2698012800      23      # 1 Jul 1985\n2776982400      24      # 1 Jan 1988\n2840140800      25      # 1 Jan 1990\n2871676800      26      # 1 Jan 1991\n2918937600      27      # 1 Jul 1992\n2950473600      28      # 1 Jul 1993\n2982009600      29      # 1 Jul 1994\n3029443200      30      # 1 Jan 1996\n3076704000      31      # 1 Jul 1997\n3124137600      32      # 1 Jan 1999\n3345062400      33      # 1 Jan 2006\n3439756800      34      # 1 Jan 2009\n3550089600      35      # 1 Jul 2012\n3644697600      36      # 1 Jul 2015\n3692217600      37      # 1 Jan 2017\n\n```\n\nAccording to the **leap-seconds.list** file, then, an offset of 37 seconds started in 2017 and should be current through 2024. Lesser whole-second adjustments would be correct for dates from 1972 through 2016. So, for example, for the date of \"October 5, 1998\", or UTC \"1998-10-05\", falls after 1997, when the leap seconds last went up to 31, and before 1999, when the total leap seconds then went up to 32. So, the leap seconds value correction for that date is 31 seconds. This is the number of seconds a **UTC** timestamp would lag behind a **TAI** time timestamp (see below).\n\nThe leap-seconds.list file provided by NIST includes a series of NTP timestamps to indicate the date and time of each update to the leap seconds, as given in the table above.\n\n#### TAI Time\n\nThe above mentioned **TAI time**, or international atomic clock time, is defined as the number of seconds since **UTC** 1958-01-01T00:00:00, but with counting the leap seconds not counted by UTC.\n\n#### GPS Time\n\nSimilarly to **TAI** time, the **GPS** time, or **Global Positioning System** convention time, is defined as the number of seconds since **UTC** 1980-01-06T00:00:00. Since the **UTC** time in 1980 had already fallen behind **TAI** time by 19 seconds, **GPS** time's offset is always 19 less than the (positive) **TAI** offset used in conversion to **TAI** from any given **UTC** standard timestamp.\n\n## Task:\n\nIn your chosen programming language, write a function or functions to convert between timestamps in **UTC**, **Unix**, **NTP**, **TAI**, and **GPS** time conventions. Timestamps should be capable of 1 millisecond precision as a minimum, with microsecond or nanosecond precision optional. Negative values for a timestamp before its epoch can be used when necessary. Add or subtract the proper number of leap seconds as appropriate when converting between leap-second-ignoring (UTC, Unix, NTP) and leap-second-counting (TAI, GPS) timestamp standards.\n\nDemonstrate the use of the function or functions to output values to fill in blanks in the following table:\n\n```\n      UTC                      Unix           NTP            TAI              GPS \n__________________________________________________________________________________________\n0000-12-31T00:00:00\n1900-01-01T00:00:00\n1958-01-01T00:00:00\n1970-01-01T00:00:00\n1980-01-06T00:00:00\n1989-12-31T00:00:00\n1990-01-01T00:00:00\n2025-06-01T00:00:00\n2050-01-01T00:00:00\n                          1810753809.806\n                           154956295.688\n                           780673454.121   \n                                          2871676795\n                                          2335219189\n                                          3029443171\n                                                          996796823\n                                                          996796824\n                                                          996796825\n                                                          996796826\n                                                                          996796804.250\n                                                                          996796805.500\n                                                                          996796806.750\n                                                                          996796807.9999\n\n                         \n\n```\n\nReferences\n\n[1] Wikipedia reference\n\n[2] Non-paywalled version of the ISO 8601 standard for UTC\n\n[3] Discussion of the leap-seconds.list file\n\n[4] Comparisons of different time conventions and timestamps\n\n[5] Online time stamp converter"}, {"role": "assistant", "content": "When using the Instant class for leap second operations in Raku, the results may be version-dependent as it is preloaded with leap seconds adjustments at the then current point in time. Users should be aware of this and take it into consideration, as the knowledge of future leap seconds can vary between different Raku compiler versions.\n\n**Translation of**: Wren\n\n```\n# 20241023 Raku programming solution\n\nmy (\\UNIX_EPOCH, \\NTP_EPOCH, \\TAI_EPOCH, \\GPS_EPOCH) = map { DateTime.new: $_ },\n   < 1970-01-01  1900-01-01  1958-01-01  1980-01-06 >;\n\nmy %NTP_TO_LS = ( my @CHANGE_TIMES = < \n   2272060800 2287785600 2303683200 2335219200 2366755200 2398291200 2429913600\n   2461449600 2492985600 2524521600 2571782400 2603318400 2634854400 2698012800\n   2776982400 2840140800 2871676800 2918937600 2950473600 2982009600 3029443200\n   3076704000 3124137600 3345062400 3439756800 3550089600 3644697600 3692217600 \n> ) Z=> 10 .. * ;\n\n# The conversions without leap second adjustments\n\nmy &utc2unix = -> $utcStr { \n   do given DateTime.new($utcStr).posix { * < 0 ?? $_ !! $_ - UNIX_EPOCH }\n}\n\nmy &utc2ntp  = -> $utcStr   { utc2unix($utcStr) + UNIX_EPOCH - NTP_EPOCH }\n\nmy &ntp2unix = -> $ntpSecs  { $ntpSecs + NTP_EPOCH - UNIX_EPOCH }\n\nmy &unix2ntp = -> $unixSecs { $unixSecs + UNIX_EPOCH - NTP_EPOCH }\n\nmy &unix2utc = -> $unixSecs { Instant.from-posix($unixSecs).DateTime }\n\nmy &ntp2utc  = -> $ntpSecs  { unix2utc(ntp2unix($ntpSecs)) }\n\nmy &tai2gps  = -> $taiSecs  { $taiSecs + TAI_EPOCH - GPS_EPOCH - 10 }\n\nmy &gps2tai  = -> $gpsSecs  { $gpsSecs + GPS_EPOCH - TAI_EPOCH + 10 }\n\n# Conversions requiring leap-second adjustments\n\nmy &ntp2tai = sub ($ntpSecs) {\n   my $tai =  $ntpSecs + NTP_EPOCH - TAI_EPOCH;\n    \n   return $tai if $ntpSecs < @CHANGE_TIMES[0];\n\n   return $tai+%NTP_TO_LS{@CHANGE_TIMES[*-1]} if $ntpSecs >= @CHANGE_TIMES[*-1];\n\n   for 1 .. @CHANGE_TIMES.elems - 1 {\n      if $ntpSecs < @CHANGE_TIMES[$_] {\n         return $tai + %NTP_TO_LS{@CHANGE_TIMES[$_-1]}\n      }\n   }\n}\n\nmy &tai2ntp = sub ($taiSecs) {\n   my $ntp = $taiSecs + TAI_EPOCH - NTP_EPOCH;\n\n   return $ntp if $ntp < @CHANGE_TIMES[0];\n    \n   my ($idx, $delta) = (0, 0);\n   \n   if $ntp >= @CHANGE_TIMES[*-1] {\n      $delta = %NTP_TO_LS{@CHANGE_TIMES[*-1]}\n   } else {\n      for 1 .. @CHANGE_TIMES.elems - 1 {\n         if $ntp < @CHANGE_TIMES[$_] {\n            $delta = %NTP_TO_LS{@CHANGE_TIMES[$_-1]};\n            $idx = $_;\n            last;\n         }\n      }\n   }\n    \n   return do given $ntp - $delta {\n      when * < @CHANGE_TIMES[0]      { @CHANGE_TIMES[0] - 1 + $ntp.fraction }\n      when * < @CHANGE_TIMES[$idx-1] { $_ + 1 }\n      default                        { $_ } \n   }\n}\n\nmy &ntp2gps  = -> $ntpSecs  { tai2gps(ntp2tai($ntpSecs)) }\n\nmy &gps2ntp  = -> $gpsSecs  { tai2ntp(gps2tai($gpsSecs)) }\n\nmy &tai2unix = -> $taiSecs  { ntp2unix(tai2ntp($taiSecs)) }\n\nmy &unix2tai = -> $unixSecs { ntp2tai(unix2ntp($unixSecs)) }\n\nmy &tai2utc  = -> $taiSecs  { ntp2utc(tai2ntp($taiSecs)) }\n\nmy &utc2tai  = -> $utcStr   { ntp2tai(utc2ntp($utcStr)) }\n\nmy &gps2unix = -> $gpsSecs  { tai2unix(gps2tai($gpsSecs)) }\n\nmy &unix2gps = -> $unixSecs { tai2gps(unix2tai($unixSecs)) }\n\nmy &utc2gps  = -> $utcStr   { tai2gps(utc2tai($utcStr)) }\n\nmy &gps2utc  = -> $gpsSecs  { tai2utc(gps2tai($gpsSecs)) }\n\n# Output formatting\nsay \"      UTC                            Unix               NTP               TAI               GPS\";\nsay '_' x 100;\n\nmy $fmt = \"%-28s%18.4f%18.4f%18.4f%18.4f\\n\";\n\nfor < 0001-01-01T00:00:00 1900-01-01T00:00:00 1958-01-01T00:00:00\n      1970-01-01T00:00:00 1980-01-06T00:00:00 1989-12-31T00:00:00\n      1990-01-06T00:00:00 2025-06-01T00:00:00 2050-01-01T00:00:00 > {\n   printf $fmt, $_, .&utc2unix, .&utc2ntp, .&utc2tai, .&utc2gps\n}\n\nfor < 1810753809.806 154956295.688 780673454.121 > {\n   printf $fmt, .&unix2utc, $_, .&unix2ntp, .&unix2tai, .&unix2gps\n}\n\nfor < 2871676795 2335219189 3029443171 3124137599 3124137600 > {\n   printf $fmt, .&ntp2utc, .&ntp2unix, $_, .&ntp2tai, .&ntp2gps\n}\n\nfor <  996796823  996796824  996796825  996796826 \n      1293840030 1293840031 1293840032 1293840033 > {\n   printf $fmt, .&tai2utc, .&tai2unix, .&tai2ntp, $_, .&tai2gps  \n}\n\nfor < 996796804.250 996796805.5 996796806.750 996796807.9999 > {\n   printf $fmt, .&gps2utc, .&gps2unix, .&gps2ntp, .&gps2tai, $_\n}\n\n```\n\nYou may Attempt This Online!\n\nOutput:\n\n```\n      UTC                            Unix               NTP               TAI               GPS\n____________________________________________________________________________________________________\n0001-01-01T00:00:00          -62135596800.0000 -59926608000.0000 -61756905600.0000 -62451561619.0000\n1900-01-01T00:00:00           -2208988800.0000            0.0000  -1830297600.0000  -2524953619.0000\n1958-01-01T00:00:00            -378691200.0000   1830297600.0000            0.0000   -694656019.0000\n1970-01-01T00:00:00                     0.0000   2208988800.0000    378691200.0000   -315964819.0000\n1980-01-06T00:00:00             315964800.0000   2524953600.0000    694656019.0000            0.0000\n1989-12-31T00:00:00             631065600.0000   2840054400.0000   1009756824.0000    315100805.0000\n1990-01-06T00:00:00             631584000.0000   2840572800.0000   1010275225.0000    315619206.0000\n2025-06-01T00:00:00            1748736000.0000   3957724800.0000   2127427237.0000   1432771218.0000\n2050-01-01T00:00:00            2524608000.0000   4733596800.0000   2903299237.0000   2208643218.0000\n2027-05-19T19:10:09.806000Z    1810753809.8060   4019742609.8060   2189445046.8060   1494789027.8060\n1974-11-29T11:24:55.688000Z     154956295.6880   2363945095.6880    533647508.6880   -161008510.3120\n1994-09-27T13:44:14.121000Z     780673454.1210   2989662254.1210   1159364683.1210    464708664.1210\n1990-12-31T23:59:55Z            662687995.0000   2871676795.0000   1041379220.0000    346723201.0000\n1973-12-31T23:59:49Z            126230389.0000   2335219189.0000    504921601.0000   -189734418.0000\n1995-12-31T23:59:31Z            820454371.0000   3029443171.0000   1199145600.0000    504489581.0000\n1998-12-31T23:59:59Z            915148799.0000   3124137599.0000   1293840030.0000    599184011.0000\n1999-01-01T00:00:00Z            915148800.0000   3124137600.0000   1293840032.0000    599184013.0000\n1989-08-02T23:59:59Z            618105599.0000   2827094399.0000    996796823.0000    302140804.0000\n1989-08-03T00:00:00Z            618105600.0000   2827094400.0000    996796824.0000    302140805.0000\n1989-08-03T00:00:01Z            618105601.0000   2827094401.0000    996796825.0000    302140806.0000\n1989-08-03T00:00:02Z            618105602.0000   2827094402.0000    996796826.0000    302140807.0000\n1998-12-31T23:59:59Z            915148799.0000   3124137599.0000   1293840030.0000    599184011.0000\n1999-01-01T00:00:00Z            915148800.0000   3124137600.0000   1293840031.0000    599184012.0000\n1999-01-01T00:00:00Z            915148800.0000   3124137600.0000   1293840032.0000    599184013.0000\n1999-01-01T00:00:01Z            915148801.0000   3124137601.0000   1293840033.0000    599184014.0000\n2011-08-07T23:59:49.250000Z    1312761589.2500   3521750389.2500   1691452823.2500    996796804.2500\n2011-08-07T23:59:50.500000Z    1312761590.5000   3521750390.5000   1691452824.5000    996796805.5000\n2011-08-07T23:59:51.750000Z    1312761591.7500   3521750391.7500   1691452825.7500    996796806.7500\n2011-08-07T23:59:52.999900Z    1312761592.9999   3521750392.9999   1691452826.9999    996796807.9999\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Time-based one-time password algorithm. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nA Time-based One-time Password Algorithm (TOTP) is an algorithm that computes a one-time password from a shared secret key and the current time. It is the cornerstone of Initiative For Open Authentication (OATH) and is used in a number of two factor authentication systems.\n\nEssentially, both the server and the client compute the time-limited token, then the server checks if the token supplied by the client matches the locally generated token.\n\nTask\n\nImplement this algorithm using **HMAC-SHA1** and an optional step is to generate the random Base-32 string used as the secret key, but this is not a requirement.\n\nA reference implementation, based on JavaScript, can be found at the following location:\n\n:   :   :   http://blog.tinisles.com/2011/10/google-authenticator-one-time-password-algorithm-in-javascript\n\nAccording to RFC 6238, the reference implementation is as follows:\n\n* Generate a key, **K**, which is an arbitrary bytestring, and share it securely with the client.\n* Agree upon an epoch, T0, and an interval, TI, which will be used to calculate the value of the counter C (defaults are the Unix epoch as T0 and 30 seconds as TI)\n* Agree upon a cryptographic hash method (default is SHA-1)\n* Agree upon a token length, **N** (default is 6)\n\nAlthough RFC 6238 allows different parameters to be used, the Google implementation of the authenticator app does not support T0, TI values, hash methods and token lengths different from the default.   It also expects the **K** secret key to be entered (or supplied in a QR code) in base-32 encoding according to RFC 3548.\n\n* Google Authenticator App (Apple iOS)\n* Google Authenticator App (Google Android)\n* Microsoft Authenticator App (Windows Phone)"}, {"role": "assistant", "content": "(formerly Perl 6)\nThis is a minimal attempt that covers only the \"Time-based\" part of the requirement.\n\n```\n# Reference:\n# https://github.com/retupmoca/P6-Digest-HMAC\n\nuse v6.d;\nuse Digest::HMAC;\nuse Digest::SHA;\n\nsub totp (Str \\secret, DateTime \\counter, Int \\T0=0, Int \\T1=30 --> Str) {\n   my \\key = ( counter - DateTime.new(T0) ).Int div T1;   \n   return hmac-hex(key.Str, secret, &sha1).substr(0,6) # first 6 chars of sha1\n}\n\nmy $message = \"show me the monKey\";\n\nsay \"Deterministic output at \", DateTime.new(2177452800), \" with fixed checks,\";\nloop (my $t = 2177452800 ; $t < 2177452900 ; $t+= 17 ) { # Y2038 safe\n   say totp $message, DateTime.new($t);\n}\n\nsay \"Current time output at \", DateTime.new(now), \" with random checks,\";\nloop (my $n = 0 ; $n < 6 ; $n++, sleep (13..23).roll ) {\n   say totp $message, DateTime.new(now);\n}\n\n```\n\nOutput:\n\n```\nDeterministic output at 2039-01-01T00:00:00Z with fixed checks,\n34ca2a\nacfa3f\n950fc3\n950fc3\na2d4ea\na2d4ea\nCurrent time output at 2019-03-31T15:00:01.765312Z with random checks,\n4e36de\nd4e9f8\nd4e9f8\n077e2c\n63bbb5\n63bbb5\n```"}]}
{"messages": [{"role": "user", "content": "Separate the string \"Hello,How,Are,You,Today\" by commas into an array (or list) so that each element of it stores a different word.\n\nDisplay the words to the 'user', in the simplest manner possible, separated by a period.\n\nTo simplify, you may display a trailing period.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #22 \"Thousand Oaks\"\n\n```\n'Hello,How,Are,You,Today'.split(',').join('.').say;\n```\n\nOr with function calls:\n\n```\nsay join '.', split ',', 'Hello,How,Are,You,Today';\n```"}]}
{"messages": [{"role": "user", "content": "Task[edit]\n\nWrite a function or program that can split a string at each non-escaped occurrence of a separator character.\n\nIt should accept three input parameters:\n\n:   :   :   * The **string**\n            * The **separator character**\n            * The **escape character**\n\nIt should output a list of strings.\n\nDetails\n\nRules for splitting:\n\n* The fields that were separated by the separators, become the elements of the output list.\n* Empty fields should be preserved, even at the start and end.\n\nRules for escaping:\n\n* \"Escaped\" means preceded by an occurrence of the escape character that is not already escaped itself.\n* When the escape character precedes a character that has no special meaning, it still counts as an escape (but does not do anything special).\n* Each occurrence of the escape character that was used to escape something, should **not** become part of the output.\n\nTest case\n\nDemonstrate that your function satisfies the following test-case:\n\n| Input | Output |\n| --- | --- |\n| |  |  | | --- | --- | | string: | ``` one^|uno||three^^^^|four^^^|^cuatro| ``` | | separator character: | ``` | ``` | | escape character: | ``` ^ ``` | | |  | | --- | | ``` one|uno ``` | |  | | ``` three^^ ``` | | ``` four^|cuatro ``` | |  | |\n\n(Print the output list in any format you like, as long as it is it easy to see what the fields are.)\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub tokenize ($string, :$sep!, :$esc!) {\n    return $string.match(/([ <!before $sep | $esc> . | $esc . ]*)+ % $sep/)\\\n                  .[0].map(*.subst: /$esc )> ./, '', :g);\n}\n\nsay \"'$_'\" for tokenize 'one^|uno||three^^^^|four^^^|^cuatro|', sep => '|', esc => '^';\n\n```\n\nOutput:\n\n```\n'one|uno'\n''\n'three^^'\n'four^|cuatro'\n''\n\n```\n\nNotable Raku innovations that make this different from the equivalent #Perl solution:\n\n* string variables can be safely interpolated into regexes without having to 'quotemeta' them\n* regexes matches return a nested `Match` object which allows retrieving *all* results for a given capture group *(rather than just the last thing that it matched)*, thus getting rid of the need for repeated global matching\n* the `<field>+ % <delimiter>` regex construct allows handling the delimiters in a more idiomatic way\n* the `)>` regex construct can be used to exclude anything that follows it from the returned match result"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Tonelli-Shanks algorithm. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn computational number theory, the Tonelli–Shanks algorithm is a technique for solving for **x** in a congruence of the form:\n\n:   :   x2 ≡ n (mod p)\n\nwhere **n** is an integer which is a quadratic residue (mod p), **p** is an odd prime, and **x,n ∈ Fp** where Fp = {0, 1, ..., p - 1}.\n\nIt is used in cryptography techniques.\n\nTo apply the algorithm, we need the Legendre symbol:\n\nThe Legendre symbol **(a | p)** denotes the value of a(p-1)/2 (mod p).\n\n* **(a | p) ≡ 1**    if **a** is a square (mod p)\n* **(a | p) ≡ -1**    if **a** is not a square (mod p)\n* **(a | p) ≡ 0**    if **a** ≡ 0 (mod p)\n\nAlgorithm pseudo-code\n\nAll ≡ are taken to mean (mod p) unless stated otherwise.\n\n* Input: **p** an odd prime, and an integer **n** .\n* Step 0: Check that **n** is indeed a square: (n | p) must be ≡ 1 .\n* Step 1: By factoring out powers of 2 from p - 1, find **q** and **s** such that p - 1 = q2s with **q** odd .\n  + If p ≡ 3 (mod 4) (i.e. s = 1), output the two solutions r ≡ ± n(p+1)/4 .\n* Step 2: Select a non-square **z** such that (z | p) ≡ -1 and set c ≡ zq .\n* Step 3: Set r ≡ n(q+1)/2, t ≡ nq, m = s .\n* Step 4: Loop the following:\n  + If t ≡ 1, output **r** and **p - r** .\n  + Otherwise find, by repeated squaring, the lowest **i**, 0 < i < m , such that t2i ≡ 1 .\n  + Let b ≡ c2(m - i - 1), and set r ≡ rb, t ≡ tb2, c ≡ b2 and m = i .\n\nTask\n\nImplement the above algorithm.\n\nFind solutions (if any) for\n\n* n = 10 p = 13\n* n = 56 p = 101\n* n = 1030 p = 10009\n* n = 1032 p = 10009\n* n = 44402 p = 100049\n\nExtra credit\n\n* n = 665820697 p = 1000000009\n* n = 881398088036 p = 1000000000039\n* n = 41660815127637347468140745042827704103445750172002 p = 10^50 + 577\n\nSee also\n\n* Modular exponentiation\n* Cipolla's algorithm"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.04\n\nTranslation of the Wikipedia pseudocode, heavily influenced by Sidef and Python.\n\n```\n#  Legendre operator (𝑛│𝑝)\nsub infix:<│> (Int \\𝑛, Int \\𝑝 where 𝑝.is-prime && (𝑝 != 2)) {\n    given 𝑛.expmod( (𝑝-1) div 2, 𝑝 ) {\n        when 0  {  0 }\n        when 1  {  1 }\n        default { -1 }\n    }\n}\n\nsub tonelli-shanks ( \\𝑛, \\𝑝 where (𝑛│𝑝) > 0 ) {\n    my $𝑄 = 𝑝 - 1;\n    my $𝑆 = 0;\n    $𝑄 +>= 1 and $𝑆++ while $𝑄 %% 2;\n    return 𝑛.expmod((𝑝+1) div 4, 𝑝) if $𝑆 == 1;\n    my $𝑐 = ((2..𝑝).first: (*│𝑝) < 0).expmod($𝑄, 𝑝);\n    my $𝑅 = 𝑛.expmod( ($𝑄+1) +> 1, 𝑝 );\n    my $𝑡 = 𝑛.expmod( $𝑄, 𝑝 );\n    while ($𝑡-1) % 𝑝 {\n        my $b;\n        my $𝑡2 = $𝑡² % 𝑝;\n        for 1 .. $𝑆 {\n            if ($𝑡2-1) %% 𝑝 {\n                $b = $𝑐.expmod(1 +< ($𝑆-1-$_), 𝑝);\n                $𝑆 = $_;\n                last;\n            }\n            $𝑡2 = $𝑡2² % 𝑝;\n        }\n        $𝑅 = ($𝑅 * $b) % 𝑝;\n        $𝑐 = $b² % 𝑝;\n        $𝑡 = ($𝑡 * $𝑐) % 𝑝;\n    }\n    $𝑅;\n}\n\nmy @tests = (\n    (10, 13),\n    (56, 101),\n    (1030, 10009),\n    (1032, 10009),\n    (44402, 100049),\n    (665820697, 1000000009),\n    (881398088036, 1000000000039),\n    (41660815127637347468140745042827704103445750172002,\n      100000000000000000000000000000000000000000000000577)\n);\n\n for @tests -> ($n, $p) {\n    try my $t = tonelli-shanks($n, $p);\n    say \"No solution for ({$n}, {$p}).\" and next if !$t or ($t² - $n) % $p;\n    say \"Roots of $n are ($t, {$p-$t}) mod $p\";\n}\n\n```\n\nOutput:\n\n```\nRoots of 10 are (7, 6) mod 13\nRoots of 56 are (37, 64) mod 101\nRoots of 1030 are (1632, 8377) mod 10009\nNo solution for (1032, 10009).\nRoots of 44402 are (30468, 69581) mod 100049\nRoots of 665820697 are (378633312, 621366697) mod 1000000009\nRoots of 881398088036 are (791399408049, 208600591990) mod 1000000000039\nRoots of 41660815127637347468140745042827704103445750172002 are (32102985369940620849741983987300038903725266634508, 67897014630059379150258016012699961096274733366069) mod 100000000000000000000000000000000000000000000000577\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nFind the top   *N*   salaries in each department,   where   *N*   is provided as a parameter.\n\nUse this data as a formatted internal data structure (adapt it to your language-native idioms, rather than parse at runtime), or identify your external data source:\n\n```\nEmployee Name,Employee ID,Salary,Department\nTyler Bennett,E10297,32000,D101\nJohn Rappl,E21437,47000,D050\nGeorge Woltman,E00127,53500,D101\nAdam Smith,E63535,18000,D202\nClaire Buckman,E39876,27800,D202\nDavid McClellan,E04242,41500,D101\nRich Holcomb,E01234,49500,D202\nNathan Adams,E41298,21900,D050\nRichard Potter,E43128,15900,D101\nDavid Motsinger,E27002,19250,D202\nTim Sampair,E03033,27000,D101\nKim Arlich,E10001,57000,D190\nTimothy Grove,E16398,29900,D190\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\nWe use whitespace-separated fields here from a heredoc; q:to/---/ begins the heredoc. The Z=> operator zips two lists into a list of pairs.\nIn MAIN, the classify method generates pairs where each key is a different department, and each value all the entries in that department. We then sort the pairs and process each department separately. Within each department, we sort on salary (negated to reverse the order). The last statement is essentially a list comprehension that uses a slice subscript with the ^ \"up to\" operator to take the first N elements of the sorted employee list. The :v modifier returns only valid values. The .<Name> form is a slice hash subscript with literals strings. That in turn is just the subscript form of the <...> (\"quote words\") form, which is more familar to Perl 5 programmers as\nqw/.../. We used that form earlier to label the initial data set.\n\nThis program also makes heavy use of method calls that start with dot. In Raku this means a method call on the current topic, $\\_, which is automatically set by any for or map construct that doesn't declare an explicit formal parameter on its closure.\n\n```\nmy @data = do for q:to/---/.lines -> $line {\n        E10297  32000   D101    Tyler Bennett\n        E21437  47000   D050    John Rappl\n        E00127  53500   D101    George Woltman\n        E63535  18000   D202    Adam Smith\n        E39876  27800   D202    Claire Buckman\n        E04242  41500   D101    David McClellan\n        E01234  49500   D202    Rich Holcomb\n        E41298  21900   D050    Nathan Adams\n        E43128  15900   D101    Richard Potter\n        E27002  19250   D202    David Motsinger\n        E03033  27000   D101    Tim Sampair\n        E10001  57000   D190    Kim Arlich\n        E16398  29900   D190    Timothy Grove\n        ---\n\n  $%( < Id      Salary  Dept    Name >\n      Z=>\n      $line.split(/ \\s\\s+ /)\n    )\n}\n\nsub MAIN(Int $N = 3) {\n    for @data.classify({ .<Dept> }).sort».value {\n        my @es = .sort: { -.<Salary> }\n        say '' if (state $bline)++;\n        say .< Dept Id Salary Name > for @es[^$N]:v;\n    }\n}\n\n```\n\nOutput:\n\n```\nD050 E21437 47000 John Rappl\nD050 E41298 21900 Nathan Adams\n\nD101 E00127 53500 George Woltman\nD101 E04242 41500 David McClellan\nD101 E10297 32000 Tyler Bennett\n\nD190 E10001 57000 Kim Arlich\nD190 E16398 29900 Timothy Grove\n\nD202 E01234 49500 Rich Holcomb\nD202 E39876 27800 Claire Buckman\nD202 E27002 19250 David Motsinger\n```"}]}
{"messages": [{"role": "user", "content": "Several programming languages offer syntax shortcuts to deal with the notion of \"current\" or \"topic\" variable.\n\nA topic variable is a special variable with a very short name which can also often be omitted.\n\nDemonstrate the utilization and behaviour of the topic variable within the language and explain or demonstrate how the topic variable behaves under different levels of nesting or scope, if this applies, within the language.\n\nFor instance you can (but you don't have to) show how the topic variable can be used by assigning the number \n\n3\n{\\displaystyle {\\displaystyle 3}}\n to it and then computing its square and square root."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nAs in Perl, in Raku the topic variable is $\\_. In addition to a direct assigment, it can be set with the 'given' or 'with' keywords, or by some iteration operator ('for', 'map' etc). A method can be called from it with an implicit call:\n\n```\n$_ = 'Outside';\nfor <3 5 7 10> {\n    print $_;\n    .³.map: { say join \"\\t\", '', $_, .², .sqrt, .log(2), OUTER::<$_>, UNIT::<$_>  }\n}\n\n```\n\nOutput:\n\n```\n3\t27\t729\t5.196152422706632\t4.754887502163469\t3\tOutside\n5\t125\t15625\t11.180339887498949\t6.965784284662088\t5\tOutside\n7\t343\t117649\t18.520259177452136\t8.422064766172811\t7\tOutside\n10\t1000\t1000000\t31.622776601683793\t9.965784284662087\t10\tOutside\n```\n\nNote: that the $\\_ inside the 'map' block is different than the $\\_ set in the 'for' block. The scope of the $\\_ variable is always lexical in Raku, though a function can access topics in other scopes by specifying the scope: `CALLER::<$_>` from within a subroutine, `OUTER::<$_>` for the next enclosing block, `UNIT::<$_>` for the outermost block in a compilation unit, etc. The scope modifiers may be stacked: `CALLER::OUTER::<$_>` would be the topic variable of the next outer block of the current subroutines caller block.\n\nThe scope modifiers can only flow outward. There is no way to access the topic of a block enclosed within the current scope or in a separate scope 'branch'.\n\nAlso note: **Any** variable in other scopes can be accessed this way. This is just pointing out that the default (topic) variable also has this property."}]}
{"messages": [{"role": "user", "content": "Given a mapping between items, and items they depend on, a topological sort orders items so that no item precedes an item it depends upon.\n\nThe compiling of a library in the VHDL language has the constraint that a library must be compiled after any library it depends on.\n\nA tool exists that extracts library dependencies.\n\nTask\n\nWrite a function that will return a valid compile order of VHDL libraries from their dependencies.\n\n* Assume library names are single words.\n* Items mentioned as only dependents, (sic), have no dependents of their own, but their order of compiling must be given.\n* Any self dependencies should be ignored.\n* Any un-orderable dependencies should be flagged.\n\nUse the following data as an example:\n\n```\nLIBRARY          LIBRARY DEPENDENCIES\n=======          ====================\ndes_system_lib   std synopsys std_cell_lib des_system_lib dw02 dw01 ramlib ieee\ndw01             ieee dw01 dware gtech\ndw02             ieee dw02 dware\ndw03             std synopsys dware dw03 dw02 dw01 ieee gtech\ndw04             dw04 ieee dw01 dware gtech\ndw05             dw05 ieee dware\ndw06             dw06 ieee dware\ndw07             ieee dware\ndware            ieee dware\ngtech            ieee gtech\nramlib           std ieee\nstd_cell_lib     ieee std_cell_lib\nsynopsys\n\n```\n\nNote: the above data would be un-orderable if, for example, `dw04` is added to the list of dependencies of `dw01`.\n\nC.f.\n:   * Topological sort/Extracted top item.\n\nThere are two popular algorithms for topological sorting:\n\n:   * Kahn's 1962 topological sort [1]\n    * depth-first search [2] [3]"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n**Works with**: rakudo version 2016.01\n\n```\nsub print_topo_sort ( %deps ) {\n    my %ba;\n    for %deps.kv -> $before, @afters {\n        for @afters -> $after {\n            %ba{$before}{$after} = 1 if $before ne $after;\n            %ba{$after} //= {};\n        }\n    }\n\n    while %ba.grep( not *.value )».key -> @afters {\n        say ~@afters.sort;\n        %ba{@afters}:delete;\n        for %ba.values { .{@afters}:delete }\n    }\n\n    say %ba ?? \"Cycle found! {%ba.keys.sort}\" !! '---';\n}\n\nmy %deps =\n    des_system_lib => < std synopsys std_cell_lib des_system_lib dw02\n                                                     dw01 ramlib ieee >,\n    dw01           => < ieee dw01 dware gtech                         >,\n    dw02           => < ieee dw02 dware                               >,\n    dw03           => < std synopsys dware dw03 dw02 dw01 ieee gtech  >,\n    dw04           => < dw04 ieee dw01 dware gtech                    >,\n    dw05           => < dw05 ieee dware                               >,\n    dw06           => < dw06 ieee dware                               >,\n    dw07           => < ieee dware                                    >,\n    dware          => < ieee dware                                    >,\n    gtech          => < ieee gtech                                    >,\n    ramlib         => < std ieee                                      >,\n    std_cell_lib   => < ieee std_cell_lib                             >,\n    synopsys       => <                                               >;\n\nprint_topo_sort(%deps);\n%deps<dw01> = <ieee dw01 dware gtech dw04>; # Add unresolvable dependency\nprint_topo_sort(%deps);\n\n```\n\nOutput:\n\n```\nieee std synopsys\ndware gtech ramlib std_cell_lib\ndw01 dw02 dw05 dw06 dw07\ndes_system_lib dw03 dw04\n---\nieee std synopsys\ndware gtech ramlib std_cell_lib\ndw02 dw05 dw06 dw07\nCycle found! des_system_lib dw01 dw03 dw04\n```\n\nSome differences from the Perl 5 version include use of\nformal parameters; use of » as a \"hyper\" operator, that is, a parallelizable implicit loop; and use of normal lambda-like notation to bind loop parameters, so we can have multiple loop parameters bound on each iteration. Also,\nsince => is now a real pair composer rather than a synonym for comma, the data can be represented with real pair notation that points to quoted word lists delimited by angle brackets rather than [qw(...)]."}]}
{"messages": [{"role": "user", "content": "Given a mapping between items, and items they depend on, a topological sort orders items so that no item precedes an item it depends upon.\n\nThe compiling of a design in the VHDL language has the constraint that a file must be compiled after any file containing definitions it depends on. A tool exists that extracts file dependencies.\n\n* Assume the file names are single words, given without their file extensions.\n* Files mentioned as only dependants, have no dependants of their own, but their order of compiling must be given.\n* Any self dependencies should be ignored.\n\nA top level file is defined as a file that:\n\n1. Has dependents.\n2. Is not itself the dependent of another file\n\n**Task Description**\n\nGiven the following file dependencies as an example:\n\n```\nFILE    FILE DEPENDENCIES\n====    =================\ntop1    des1 ip1 ip2\ntop2    des1 ip2 ip3\nip1     extra1 ip1a ipcommon\nip2     ip2a ip2b ip2c ipcommon\ndes1    des1a des1b des1c\ndes1a   des1a1 des1a2\ndes1c   des1c1 extra1\n```\n\nThe task is to create a program that given a graph of the dependency:\n\n1. Determines the top levels from the dependencies and show them.\n2. Extracts a compile order of files to compile any given (usually top level) file.\n3. Give a compile order for file top1.\n4. Give a compile order for file top2.\n\nYou may show how to compile multiple top levels as a stretch goal\n\nNote: this task differs from task Topological sort in that the order for compiling any file might not include all files; and that checks for dependency cycles are not mandated.\n\nRelated task\n\n* Topological sort"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub top_topos ( %deps, *@top ) {\n    my %ba;\n    for %deps.kv -> $after, @befores {\n        for @befores -> $before {\n            %ba{$after}{$before} = 0 if $before ne $after;\n            %ba{$before} //= {};\n        }\n    }\n\n    if @top {\n\tmy @want = @top;\n\tmy %care;\n\t%care{@want} = 1 xx *;\n\trepeat while @want {\n\t    my @newwant;\n\t    for @want -> $before {\n\t\tif %ba{$before} {\n\t\t    for %ba{$before}.keys -> $after {\n\t\t\tif not %ba{$before}{$after} {\n\t\t\t    %ba{$before}{$after}++;\n\t\t\t    push @newwant, $after;\n\t\t\t}\n\t\t    }\n\t\t}\n\t    }\n\t    @want = @newwant;\n\t    %care{@want} = 1 xx *;\n\t}\n\n\tfor %ba.keys -> $before {\n\t    %ba{$before}:delete unless %care{$before};\n\t}\n    }\n \n    my @levels;\n    while %ba.grep( not *.value )».key -> @befores {\n\tpush @levels, ~@befores.sort;\n        %ba{@befores}:delete;\n        for %ba.values { .{@befores}:delete }\n    }\n    if @top {\n\tsay \"For top-level-modules: \", @top;\n\tsay \"  $_\" for @levels;\n    }\n    else {\n\tsay \"Top levels are: @levels[*-1]\";\n    }\n \n    say \"Cycle found! {%ba.keys.sort}\" if %ba;\n    say ''; \n}\n\nmy %deps =\n    top1  =>  <des1 ip1 ip2>,\n    top2  =>  <des1 ip2 ip3>,\n    ip1   =>  <extra1 ip1a ipcommon>,\n    ip2   =>  <ip2a ip2b ip2c ipcommon>,\n    des1  =>  <des1a des1b des1c>,\n    des1a =>  <des1a1 des1a2>,\n    des1c =>  <des1c1 extra1>;\n     \ntop_topos(%deps);\ntop_topos(%deps, 'top1');\ntop_topos(%deps, 'top2');\ntop_topos(%deps, 'ip1');\ntop_topos(%deps, 'top1', 'top2');\n\n```\n\nOutput:\n\n```\nTop levels are: top1 top2\n\nFor top-level-modules: top1\n  des1a1 des1a2 des1b des1c1 extra1 ip1a ip2a ip2b ip2c ipcommon\n  des1a des1c ip1 ip2\n  des1\n  top1\n\nFor top-level-modules: top2\n  des1a1 des1a2 des1b des1c1 extra1 ip2a ip2b ip2c ip3 ipcommon\n  des1a des1c ip2\n  des1\n  top2\n\nFor top-level-modules: ip1\n  extra1 ip1a ipcommon\n  ip1\n\nFor top-level-modules: top1 top2\n  des1a1 des1a2 des1b des1c1 extra1 ip1a ip2a ip2b ip2c ip3 ipcommon\n  des1a des1c ip1 ip2\n  des1\n  top1 top2\n\n```"}]}
{"messages": [{"role": "user", "content": "Topswops is a card game created by John Conway in the 1970's.\n\nAssume you have a particular permutation of a set of   n   cards numbered   1..n   on both of their faces, for example the arrangement of four cards given by   [2, 4, 1, 3]   where the leftmost card is on top.\n\nA round is composed of reversing the first   m   cards where   m   is the value of the topmost card.\n\nRounds are repeated until the topmost card is the number   1   and the number of swaps is recorded.\n\nFor our example the swaps produce:\n\n```\n    \n    [2, 4, 1, 3]    # Initial shuffle\n    [4, 2, 1, 3]\n    [3, 1, 2, 4]\n    [2, 1, 3, 4]\n    [1, 2, 3, 4]\n\n```\n\nFor a total of four swaps from the initial ordering to produce the terminating case where   1   is on top.\n\nFor a particular number    `n`    of cards,    `topswops(n)`    is the maximum swaps needed for any starting permutation of the   `n`   cards.\n\nTask\n\nThe task is to generate and show here a table of    `n`    vs    `topswops(n)`    for    `n`    in the range   1..10   inclusive.\n\nNote\n\nTopswops   is also known as   Fannkuch   from the German word   *Pfannkuchen*   meaning   pancake.\n\nRelated tasks\n\n* Number reversal game\n* Sorting algorithms/Pancake sort"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub swops(@a is copy) {\n    my int $count = 0;\n    until @a[0] == 1 {\n        @a[ ^@a[0] ] .= reverse;\n        ++$count;\n    }\n    $count\n}\n\nsub topswops($n) { max (1..$n).permutations.race.map: &swops }\n\nsay \"$_ {topswops $_}\" for 1 .. 10;\n\n```\n\nOutput:\n\n```\n1 0\n2 1\n3 2\n4 4\n5 7\n6 10\n7 16\n8 22\n9 30\n10 38\n```\n\nAlternately, using string manipulation instead. Much faster, though honestly, still not very fast.\n\n```\nsub swops($a is copy) {\n    my int $count = 0;\n    while (my \\l = $a.ord) > 1 {\n        $a = $a.substr(0, l).flip ~ $a.substr(l);\n        ++$count;\n    }\n    $count\n}\n\nsub topswops($n) { max (1..$n).permutations.map: { .chrs.join.&swops } }\n\nsay \"$_ {topswops $_}\" for 1 .. 10;\n\n```\n\nSame output"}]}
{"messages": [{"role": "user", "content": "Example circles\n\nExample circles filtered\n\nGiven some partially overlapping circles on the plane, compute and show the total area covered by them, with four or six (or a little more) decimal digits of precision. The area covered by two or more disks needs to be counted only once.\n\nOne point of this Task is also to compare and discuss the relative merits of various solution strategies, their performance, precision and simplicity. This means keeping both slower and faster solutions for a language (like C) is welcome.\n\nTo allow a better comparison of the different implementations, solve the problem with this standard dataset, each line contains the **x** and **y** coordinates of the centers of the disks and their radii   (11 disks are fully contained inside other disks):\n\n```\n         xc              yc          radius\n     1.6417233788   1.6121789534   0.0848270516\n    -1.4944608174   1.2077959613   1.1039549836\n     0.6110294452  -0.6907087527   0.9089162485\n     0.3844862411   0.2923344616   0.2375743054\n    -0.2495892950  -0.3832854473   1.0845181219\n     1.7813504266   1.6178237031   0.8162655711\n    -0.1985249206  -0.8343333301   0.0538864941\n    -1.7011985145  -0.1263820964   0.4776976918\n    -0.4319462812   1.4104420482   0.7886291537\n     0.2178372997  -0.9499557344   0.0357871187\n    -0.6294854565  -1.3078893852   0.7653357688\n     1.7952608455   0.6281269104   0.2727652452\n     1.4168575317   1.0683357171   1.1016025378\n     1.4637371396   0.9463877418   1.1846214562\n    -0.5263668798   1.7315156631   1.4428514068\n    -1.2197352481   0.9144146579   1.0727263474\n    -0.1389358881   0.1092805780   0.7350208828\n     1.5293954595   0.0030278255   1.2472867347\n    -0.5258728625   1.3782633069   1.3495508831\n    -0.1403562064   0.2437382535   1.3804956588\n     0.8055826339  -0.0482092025   0.3327165165\n    -0.6311979224   0.7184578971   0.2491045282\n     1.4685857879  -0.8347049536   1.3670667538\n    -0.6855727502   1.6465021616   1.0593087096\n     0.0152957411   0.0638919221   0.9771215985\n\n```\n\nThe result is   21.56503660... .\n\nRelated task\n\n* Circles of given radius through two points.\n\nSee also\n\n* http://www.reddit.com/r/dailyprogrammer/comments/zff9o/9062012\\_challenge\\_96\\_difficult\\_water\\_droplets/\n* http://stackoverflow.com/a/1667789/10562"}, {"role": "assistant", "content": "(formerly Perl 6)\nThis subdivides the outer rectangle repeatedly into subrectangles, and classifies them into wet, dry, or unknown. The knowns are summed to provide an inner bound and an outer bound, while the unknowns are further subdivided. The estimate is the average of the outer bound and the inner bound. Not the simplest algorithm, but converges fairly rapidly because it can treat large areas sparsely, saving the fine subdivisions for the circle boundaries. The number of unknown rectangles roughly doubles each pass, but the area of those unknowns is about half.\n\n```\nclass Point {\n    has Real $.x;\n    has Real $.y;\n    has Int $!cbits;\t# bitmap of circle membership\n\n    method cbits { $!cbits //= set_cbits(self) }\n    method gist { $!x ~ \"\\t\" ~ $!y }\n}\n\nmulti infix:<to>(Point $p1, Point $p2) {\n    sqrt ($p1.x - $p2.x) ** 2 + ($p1.y - $p2.y) ** 2;\n}\n\nmulti infix:<mid>(Point $p1, Point $p2) {\n    Point.new(x => ($p1.x + $p2.x) / 2, y => ($p1.y + $p2.y) / 2);\n}\n\nclass Circle {\n    has Point $.center;\n    has Real $.radius;\n\n    has Point $.north = Point.new(x => $!center.x, y => $!center.y + $!radius);\n    has Point $.west  = Point.new(x => $!center.x - $!radius, y => $!center.y);\n    has Point $.south = Point.new(x => $!center.x, y => $!center.y - $!radius);\n    has Point $.east  = Point.new(x => $!center.x + $!radius, y => $!center.y);\n\n    multi method contains(Circle $c) { $!center to $c.center <= $!radius - $c.radius }\n    multi method contains(Point $p) { $!center to $p <= $!radius }\n    method gist { $!center.gist ~ \"\\t\" ~ $.radius }\n}\n\nclass Rect {\n    has Point $.nw;\n    has Point $.ne;\n    has Point $.sw;\n    has Point $.se;\n\n    method diag { $!ne to $!se }\n    method area { ($!ne.x - $!nw.x) * ($!nw.y - $!sw.y) }\n    method contains(Point $p) {\n\t$!nw.x < $p.x < $!ne.x and\n\t$!sw.y < $p.y < $!nw.y;\n    }\n}\n\nmy @rawcircles = sort -*.radius,\n    map -> $x, $y, $radius { Circle.new(:center(Point.new(:$x, :$y)), :$radius) },\n    <\n\t 1.6417233788  1.6121789534 0.0848270516\n\t-1.4944608174  1.2077959613 1.1039549836\n\t 0.6110294452 -0.6907087527 0.9089162485\n\t 0.3844862411  0.2923344616 0.2375743054\n\t-0.2495892950 -0.3832854473 1.0845181219\n\t 1.7813504266  1.6178237031 0.8162655711\n\t-0.1985249206 -0.8343333301 0.0538864941\n\t-1.7011985145 -0.1263820964 0.4776976918\n\t-0.4319462812  1.4104420482 0.7886291537\n\t 0.2178372997 -0.9499557344 0.0357871187\n\t-0.6294854565 -1.3078893852 0.7653357688\n\t 1.7952608455  0.6281269104 0.2727652452\n\t 1.4168575317  1.0683357171 1.1016025378\n\t 1.4637371396  0.9463877418 1.1846214562\n\t-0.5263668798  1.7315156631 1.4428514068\n\t-1.2197352481  0.9144146579 1.0727263474\n\t-0.1389358881  0.1092805780 0.7350208828\n\t 1.5293954595  0.0030278255 1.2472867347\n\t-0.5258728625  1.3782633069 1.3495508831\n\t-0.1403562064  0.2437382535 1.3804956588\n\t 0.8055826339 -0.0482092025 0.3327165165\n\t-0.6311979224  0.7184578971 0.2491045282\n\t 1.4685857879 -0.8347049536 1.3670667538\n\t-0.6855727502  1.6465021616 1.0593087096\n\t 0.0152957411  0.0638919221 0.9771215985\n    >».Num;\n\n# remove redundant circles\nmy @circles;\nwhile @rawcircles {\n    my $c = @rawcircles.shift;\n    next if @circles.any.contains($c);\n    push @circles, $c;\n}\n\nsub set_cbits(Point $p) {\n    my $cbits = 0;\n    for @circles Z (1,2,4...*) -> ($c, $b) {\n\t$cbits += $b if $c.contains($p);\n    }\n    $cbits;\n}\n\nmy $xmin = min @circles.map: { .center.x - .radius }\nmy $xmax = max @circles.map: { .center.x + .radius }\nmy $ymin = min @circles.map: { .center.y - .radius }\nmy $ymax = max @circles.map: { .center.y + .radius }\n\nmy $min-radius = @circles[*-1].radius;\n\nmy $outer-rect = Rect.new:\n    nw => Point.new(x => $xmin, y => $ymax),\n    ne => Point.new(x => $xmax, y => $ymax),\n    sw => Point.new(x => $xmin, y => $ymin),\n    se => Point.new(x => $xmax, y => $ymin);\n\nmy $outer-area = $outer-rect.area;\n\nmy @unknowns = $outer-rect;\nmy $known-dry = 0e0;\nmy $known-wet = 0e0;\nmy $div = 1;\n\n# divide current rects each into four rects, analyze each\nsub divide(@old) {\n\n    $div *= 2;\n\n    # rects too small to hold circle?\n    my $smallish = @old[0].diag < $min-radius;\n\n    my @unk;\n    for @old {\n\tmy $center = .nw mid .se;\n\tmy $north = .nw mid .ne;\n\tmy $south = .sw mid .se;\n\tmy $west = .nw mid .sw;\n\tmy $east = .ne mid .se;\n\n\tfor Rect.new(nw => .nw, ne => $north, sw => $west, se => $center),\n\t    Rect.new(nw => $north, ne => .ne, sw => $center, se => $east),\n\t    Rect.new(nw => $west, ne => $center, sw => .sw, se => $south),\n\t    Rect.new(nw => $center, ne => $east, sw => $south, se => .se)\n\t{\n\t    my @bits = .nw.cbits, .ne.cbits, .sw.cbits, .se.cbits;\n\n\t    # if all 4 points wet by same circle, guaranteed wet\n\t    if [+&] @bits {\n\t\t$known-wet += .area;\n\t\tnext;\n\t    }\n\n\t    # if all 4 corners are dry, must check further\n\t    if not [+|] @bits and $smallish {\n\n\t\t# check that no circle bulges into this rect\n\t\tmy $ok = True;\n\t\tfor @circles -> $c {\n\t\t    if .contains($c.east) or .contains($c.west) or\n\t\t\t.contains($c.north) or .contains($c.south)\n\t\t    {\n\t\t\t$ok = False;\n\t\t\tlast;\n\t\t    }\n\t\t}\n\t\tif $ok {\n\t\t    $known-dry += .area;\n\t\t    next;\n\t\t}\n\t    }\n\t    push @unk, $_;\t# dunno yet\n\t}\n    }\n    @unk;\n}\n\nmy $delta = 0.001;\nrepeat until my $diff < $delta {\n    @unknowns = divide(@unknowns);\n\n    $diff = $outer-area - $known-dry - $known-wet;\n    say 'div: ', $div.fmt('%-5d'),\n\t' unk: ', (+@unknowns).fmt('%-6d'),\n\t' est: ', ($known-wet + $diff/2).fmt('%9.6f'),\n\t' wet: ', $known-wet.fmt('%9.6f'),\n\t' dry: ', ($outer-area - $known-dry).fmt('%9.6f'),\n\t' diff: ', $diff.fmt('%9.6f'),\n\t' error: ', ($diff - @unknowns * @unknowns[0].area).fmt('%e');\n}\n\n```\n\nOutput:\n\n```\ndiv: 2     unk: 4      est: 14.607153 wet:  0.000000 dry: 29.214306 diff: 29.214306 error: 0.000000e+000\ndiv: 4     unk: 15     est: 15.520100 wet:  1.825894 dry: 29.214306 diff: 27.388411 error: 0.000000e+000\ndiv: 8     unk: 39     est: 20.313072 wet: 11.411838 dry: 29.214306 diff: 17.802467 error: 7.105427e-015\ndiv: 16    unk: 107    est: 23.108972 wet: 17.003639 dry: 29.214306 diff: 12.210667 error: -1.065814e-014\ndiv: 32    unk: 142    est: 21.368667 wet: 19.343066 dry: 23.394268 diff:  4.051203 error: 8.881784e-014\ndiv: 64    unk: 290    est: 21.504182 wet: 20.469985 dry: 22.538380 diff:  2.068396 error: 1.771916e-013\ndiv: 128   unk: 582    est: 21.534495 wet: 21.015613 dry: 22.053377 diff:  1.037764 error: -3.175238e-013\ndiv: 256   unk: 1169   est: 21.557898 wet: 21.297343 dry: 21.818454 diff:  0.521111 error: -2.501332e-013\ndiv: 512   unk: 2347   est: 21.563415 wet: 21.432636 dry: 21.694194 diff:  0.261558 error: -1.046996e-012\ndiv: 1024  unk: 4700   est: 21.564111 wet: 21.498638 dry: 21.629584 diff:  0.130946 error: 1.481315e-013\ndiv: 2048  unk: 9407   est: 21.564804 wet: 21.532043 dry: 21.597565 diff:  0.065522 error: 1.781700e-012\ndiv: 4096  unk: 18818  est: 21.564876 wet: 21.548492 dry: 21.581260 diff:  0.032768 error: 1.098372e-011\ndiv: 8192  unk: 37648  est: 21.564992 wet: 21.556797 dry: 21.573187 diff:  0.016389 error: -1.413968e-011\ndiv: 16384 unk: 75301  est: 21.565017 wet: 21.560920 dry: 21.569115 diff:  0.008195 error: -7.683898e-011\ndiv: 32768 unk: 150599 est: 21.565031 wet: 21.562982 dry: 21.567080 diff:  0.004097 error: -1.247991e-010\ndiv: 65536 unk: 301203 est: 21.565035 wet: 21.564010 dry: 21.566059 diff:  0.002049 error: -2.830591e-010\ndiv: 131072 unk: 602411 est: 21.565036 wet: 21.564524 dry: 21.565548 diff:  0.001024 error: -1.607121e-010\n```\n\nHere the \"diff\" is calculated by subtracting the known wet and dry areas from the total area, and the \"error\" is the difference between that and the sum of the areas of the unknown blocks, to give a rough idea of how much floating point roundoff error we've accumulated."}]}
{"messages": [{"role": "user", "content": "The   **totient**   function is also known as:\n\n:   :   * Euler's totient function\n        * Euler's phi totient function\n        * phi totient function\n        * Φ    function   (uppercase Greek phi)\n        * φ     function   (lowercase Greek phi)\n\nDefinitions   (as per number theory)\n\nThe totient function:\n\n:   :   * counts the integers up to a given positive integer   **n**   that are relatively prime to   **n**\n        * counts the integers   **k**   in the range   **1 ≤ k ≤ n**   for which the greatest common divisor   **gcd(n,k)**   is equal to   **1**\n        * counts numbers   **≤ n**   and   prime to   **n**\n\nIf the totient number   (for **N**)   is one less than   **N**,   then   **N**   is prime.\n\nTask\n\nCreate a   **totient**   function and:\n\n:   :   * Find and display   (1 per line)   for the 1st   **25**   integers:\n\n        :   :   * the integer   (the index)\n                * the totient number for that integer\n                * indicate if that integer is prime\n\n        * Find and display the   *count*   of the primes up to          100\n        * Find and display the   *count*   of the primes up to       1,000\n        * Find and display the   *count*   of the primes up to     10,000\n        * Find and display the   *count*   of the primes up to   100,000     (optional)\n\nShow all output here.\n\nRelated task\n:   :   * Perfect totient numbers\n\nAlso see\n:   :   * Wikipedia: Euler's totient function.\n        * MathWorld: totient function.\n        * OEIS: Euler totient function phi(n)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.11\n\nThis is an *incredibly* inefficient way of finding prime numbers.\n\n```\nuse Prime::Factor;\n\nmy \\𝜑 = 0, |(1..*).hyper.map: -> \\t { t * [*] t.&prime-factors.squish.map: { 1 - 1/$_ } }\n\nprintf \"𝜑(%2d) = %3d %s\\n\", $_, 𝜑[$_], $_ - 𝜑[$_] - 1 ?? '' !! 'Prime' for 1 .. 25;\n\n(1e2, 1e3, 1e4, 1e5).map: -> $limit {\n    say \"\\nCount of primes <= $limit: \" ~ +(^$limit).grep: {$_ == 𝜑[$_] + 1}\n}\n\n```\n\nOutput:\n\n```\n𝜑( 1) =   1\n𝜑( 2) =   1 Prime\n𝜑( 3) =   2 Prime\n𝜑( 4) =   2\n𝜑( 5) =   4 Prime\n𝜑( 6) =   2\n𝜑( 7) =   6 Prime\n𝜑( 8) =   4\n𝜑( 9) =   6\n𝜑(10) =   4\n𝜑(11) =  10 Prime\n𝜑(12) =   4\n𝜑(13) =  12 Prime\n𝜑(14) =   6\n𝜑(15) =   8\n𝜑(16) =   8\n𝜑(17) =  16 Prime\n𝜑(18) =   6\n𝜑(19) =  18 Prime\n𝜑(20) =   8\n𝜑(21) =  12\n𝜑(22) =  10\n𝜑(23) =  22 Prime\n𝜑(24) =   8\n𝜑(25) =  20\n\nCount of primes <= 100: 25\n\nCount of primes <= 1000: 168\n\nCount of primes <= 10000: 1229\n\nCount of primes <= 100000: 9592\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nSolve the   Towers of Hanoi   problem with recursion."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsubset Peg of Int where 1|2|3;\n\nmulti hanoi (0,      Peg $a,     Peg $b,     Peg $c)     { }\nmulti hanoi (Int $n, Peg $a = 1, Peg $b = 2, Peg $c = 3) {\n    hanoi $n - 1, $a, $c, $b;\n    say \"Move $a to $b.\";\n    hanoi $n - 1, $c, $b, $a;\n}\n```"}]}
{"messages": [{"role": "user", "content": "The TPK algorithm is an early example of a programming chrestomathy.\nIt was used in Donald Knuth and Luis Trabb Pardo's Stanford tech report The Early Development of Programming Languages.\nThe report traces the early history of work in developing computer languages in the 1940s and 1950s, giving several translations of the algorithm.\n\nFrom the wikipedia entry:\n\n```\nask for 11 numbers to be read into a sequence S\nreverse sequence S\nfor each item in sequence S\n    result := call a function to do an operation\n    if result overflows\n        alert user\n    else\n        print result\n\n```\n\nThe task is to implement the algorithm:\n\n1. Use the function:     \n\n   f\n   (\n   x\n   )\n   =\n\n   |\n   x\n\n\n   |\n\n   0.5\n   +\n   5\n\n   x\n\n   3\n   {\\displaystyle {\\displaystyle f(x)=|x|^{0.5}+5x^{3}}}\n2. The overflow condition is an answer of greater than 400.\n3. The 'user alert' should not stop processing of other items of the sequence.\n4. Print a prompt before accepting **eleven**, textual, numeric inputs.\n5. You may optionally print the item as well as its associated result, but the results must be in reverse order of input.\n6. The sequence    ***S***    may be 'implied' and so not shown explicitly.\n7. *Print and show the program in action from a typical run here*. (If the output is graphical rather than text then either add a screendump or describe textually what is displayed)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @nums = prompt(\"Please type 11 space-separated numbers: \").words\n    until @nums == 11;\nfor @nums.reverse -> $n {\n    my $r = $n.abs.sqrt + 5 * $n ** 3;\n    say \"$n\\t{ $r > 400 ?? 'Urk!' !! $r }\";\n}\n\n```\n\nOutput:\n\n```\nPlease type 11 space-separated numbers: 10 -1 1 2 3 4 4.3 4.305 4.303 4.302 4.301\n4.301\t399.88629974772681\n4.302\tUrk!\n4.303\tUrk!\n4.305\tUrk!\n4.3\t399.60864413533278\n4\t322\n3\t136.73205080756887\n2\t41.414213562373092\n1\t6\n-1\t-4\n10\tUrk!\n```"}]}
{"messages": [{"role": "user", "content": "Rules\n\nA rather silly little task intended as a bit of fun as well as a simple exercise in text substitution. So, if you're a Greek speaker or an expert in ancient Greek, please don't take it too seriously!\n\nAs there isn't a one-to-one correspondence between the English and Greek alphabets, we need some rules:\n\n| Greek letter | Corresponding English letter(s) |\n| --- | --- |\n| alpha | a |\n| beta | b or v |\n| gamma | g |\n| delta | d |\n| epsilon | e (but not ee) |\n| zeta | z |\n| eta | h or ee (but not ch, kh, ph, rh or th) |\n| theta | th |\n| iota | i or j |\n| kappa | c, k, q or ck (but not ch and kh) |\n| lambda | l |\n| mu | m |\n| nu | n |\n| xi | x |\n| omicron | o (but not oo) |\n| pi | p (but not ph or ps) |\n| rho | r or rh |\n| sigma | s (but not ps) |\n| tau | t (but not th) |\n| upsilon | u or y |\n| phi | f or ph |\n| chi | ch or kh |\n| psi | ps |\n| omega | w or oo |\n\nIn the case of lower-case sigma, use **ς** when **s** is the final letter of an English word or **σ** otherwise.\n\nIgnore Greek diacritics (accents and breathings) but use the same capitalization, spacing and punctuation as in the English text.\n\nExample\n\nEnglish: The quick brown fox jumped over the lazy dog.\n\nGreek: Θε κυικ βροων φοξ ιυμπεδ οβερ θε λαζυ δογ.\n\nTask\n\nTransliterate the following English text into Greek using the above rules:\n\n```\nI was looking at some rhododendrons in my back garden,\ndressed in my khaki shorts, when the telephone rang.\n\nAs I answered it, I cheerfully glimpsed that the July sun\ncaused a fragment of black pine wax to ooze on the velvet quilt\nlaying in my patio.\n\n```\n\nIf your language does not support the printing of non-ascii characters, then you can instead transliterate the following lower-case pangram:\n\n```\nsphinx of black quartz, judge my vow.\n\n```\n\nJust represent the Greek letters by their names in angle brackets. For example:\n\n```\nthe dog => <theta><epsilon> <delta><omicron><gamma>\n```\n\nReference\n\n* Wikipedia: Greek alphabet\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nsub to-Greek (Str $string is copy) {\n    my %pre =  :Ph<F>, :ck<k>, :ee<h>, :J<I>, :rh<r>,:oo<w>, :ph<f>, :ch<χ>,\n               :th<θ>, :ps<ψ>, :Ch<Χ>, :Th<Θ>, :Ps<Ψ>, :kh<χ>, 's ' => 'ς ';\n    my %post = :a<α>, :b<β>, :d<δ>, :e<ε>, :f<φ>, :g<γ>, :h<η>, :i<ι>, :j<ι>,\n               :k<κ>, :l<λ>, :m<μ>, :n<ν>, :o<ο>, :p<π>, :q<κ>, :r<ρ>, :s<σ>,\n               :t<τ>, :u<υ>, :v<β>, :w<ω>, :x<ξ>, :y<υ>, :z<ζ>, :A<Α>, :B<Β>,\n               :D<Δ>, :E<Ε>, :F<Φ>, :G<Γ>, :H<Η>, :I<Ι>, :L<Λ>, :M<Μ>, :N<Ν>,\n               :O<Ο>, :P<Π>, :Q<Κ>, :R<Ρ>, :S<Σ>, :T<Τ>, :U<Υ>, :W<Ω>, :X<Ξ>,\n               :Z<Ζ>;\n\n    $string.=subst(:g, .key, .value ) for flat %pre, %post;\n    $string\n}\n\nmy $text = chomp q:to/ENGLISH/;\n    The quick brown fox jumped over the lazy dog.\n\n    I was looking at some rhododendrons in my back garden,\n    dressed in my khaki shorts, when the telephone rang.\n\n    As I answered it, I cheerfully glimpsed that the July sun\n    caused a fragment of black pine wax to ooze on the velvet quilt\n    laying in my patio.\n\n    sphinx of black quartz, judge my vow.\n    ENGLISH\n\nsay \"English:\\n\\n\" ~ $text ~ \"\\n\" ~ '=' x 80;\n\nsay \"\\\"Greek\\\":\\n\\n\" ~ $text.&to-Greek ~ \"\\n\" ~ '=' x 80;\n\nsay \"Or, to named characters:\\n\\n$_\\n\" ~\n  .&to-Greek.comb.map({ .match(/\\W/) ?? $_ !!\n      '<' ~ .uniname.subst( /.+<?after LETTER\\s>/).lc ~ '>'\n  }).join\n  given 'sphinx of black quartz, judge my vow.';\n\n```\n\nOutput:\n\n```\nEnglish:\n\nThe quick brown fox jumped over the lazy dog.\n\nI was looking at some rhododendrons in my back garden,\ndressed in my khaki shorts, when the telephone rang.\n\nAs I answered it, I cheerfully glimpsed that the July sun\ncaused a fragment of black pine wax to ooze on the velvet quilt\nlaying in my patio.\n\nsphinx of black quartz, judge my vow.\n================================================================================\n\"Greek\":\n\nΘε κυικ βροων φοξ ιυμπεδ οβερ θε λαζυ δογ.\n\nΙ ωας λωκινγ ατ σομε ροδοδενδρονς ιν μυ βακ γαρδεν,\nδρεσσεδ ιν μυ χακι σηορτσ, ωηεν θε τελεφονε ρανγ.\n\nΑς Ι ανσωερεδ ιτ, Ι χηρφυλλυ γλιμψεδ θατ θε Ιυλυ συν\ncαυσεδ α φραγμεντ οφ βλακ πινε ωαξ το ωζε ον θε βελβετ κυιλτ\nλαυινγ ιν μυ πατιο.\n\nσφινξ οφ βλακ κυαρτζ, ιυδγε μυ βοω.\n================================================================================\nOr, to named characters:\n\nsphinx of black quartz, judge my vow.\n<sigma><phi><iota><nu><xi> <omicron><phi> <beta><lamda><alpha><kappa> <kappa><upsilon><alpha><rho><tau><zeta>, <iota><upsilon><delta><gamma><epsilon> <mu><upsilon> <beta><omicron><omega>.\n```"}]}
{"messages": [{"role": "user", "content": "The **transportation problem** in linear programming is to find the optimal transportation plan for certain volumes of resources from suppliers to consumers, taking into account the cost of transportation. The plan is a table (matrix), whose rows and columns correspond to the suppliers and consumers, the cells are placed in cargo volume.\n\nExample of the transportation problem:\n\n:   :   :   :   :   :   |  | *Consumer 1*,  need 20 kg | *Consumer 2*,  need 30 kg | *Consumer 3*,  need 10 kg |\n                        | --- | --- | --- | --- |\n                        | *Supplier 1*,  supply 25 kg | $3 per kg | $5 per kg | $7 per kg |\n                        | *Supplier 2*,  supply 35 kg | $3 per kg | $2 per kg | $5 per kg |\n\nThe object is to solve the classical transport problem using the method of potentials (with redistributive cycle) with the preparation of the initial transportation plan by the north-west corner of the features to be implemented in this task. The input is the number of suppliers and customers, inventory levels, needs and cost matrix transport cargo. The output of the program is the optimal plan. If necessary, enter a fictitious vendor or customer.\n\nThe solution for the above example would be the plan:\n\n:   :   :   :   :   :   |  | *Consumer 1* | *Consumer 2* | *Consumer 3* |\n                        | --- | --- | --- | --- |\n                        | *Supplier 1* | 20 kg | - | 5 kg |\n                        | *Supplier 2* | - | 30 kg | 5 kg |\n\nSee also\n\n* The Transportation Problem\n* Transportation model - Concepts (youtube)\n\nRelated tasks\n\n* Vogel's approximation method"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03.1\n\nUsing Vogel's approximation method:\n\n```\nmy  %costs = :S1{:3C1, :5C2, :7C3}, :S2{:3C1, :2C2, :5C3};\nmy %demand = :20C1, :30C2, :10C3;\nmy %supply = :25S1, :35S2;\n\nmy @cols = %demand.keys.sort;\n\nmy %res;\nmy %g = (|%supply.keys.map: -> $x { $x => [%costs{$x}.sort(*.value)».key]}),\n   (|%demand.keys.map: -> $x { $x => [%costs.keys.sort({%costs{$_}{$x}})]});\n\nwhile (+%g) {\n    my @d = %demand.keys.map: -> $x\n      {[$x, my $z = %costs{%g{$x}[0]}{$x},%g{$x}[1] ?? %costs{%g{$x}[1]}{$x} - $z !! $z]}\n\n    my @s = %supply.keys.map: -> $x\n      {[$x, my $z = %costs{$x}{%g{$x}[0]},%g{$x}[1] ?? %costs{$x}{%g{$x}[1]} - $z !! $z]}\n\n    @d = |@d.grep({ (.[2] == max @d».[2]) }).&min: :by(*.[1]);\n    @s = |@s.grep({ (.[2] == max @s».[2]) }).&min: :by(*.[1]);\n\n    my ($t, $f) = @d[2] == @s[2] ?? (@s[1],@d[1]) !! (@d[2],@s[2]);\n    my ($d, $s) = $t > $f ?? (@d[0],%g{@d[0]}[0]) !! (%g{@s[0]}[0], @s[0]);\n\n    my $v = %supply{$s} min %demand{$d};\n\n    %res{$s}{$d} += $v;\n    %demand{$d} -= $v;\n\n    if (%demand{$d} == 0) {\n        %supply.grep( *.value != 0 )».key.map: -> $v\n          { %g{$v}.splice((%g{$v}.first: * eq $d, :k),1) };\n        %g{$d}:delete;\n        %demand{$d}:delete;\n    }\n\n    %supply{$s} -= $v;\n\n    if (%supply{$s} == 0) {\n        %demand.grep( *.value != 0 )».key.map: -> $v\n          { %g{$v}.splice((%g{$v}.first: * eq $s, :k),1) };\n        %g{$s}:delete;\n        %supply{$s}:delete;\n    }\n}\n\nsay join \"\\t\", flat '', @cols;\nmy $total;\nfor %costs.keys.sort -> $g {\n    print \"$g\\t\";\n    for @cols -> $col {\n        print %res{$g}{$col} // '-', \"\\t\";\n        $total += (%res{$g}{$col} // 0) * %costs{$g}{$col};\n    }\n    print \"\\n\";\n}\nsay \"\\nTotal cost: $total\";\n\n```\n\nOutput:\n\n```\n\tC1\tC2\tC3\nS1\t20\t-\t5\t\nS2\t-\t30\t5\t\n```"}]}
{"messages": [{"role": "user", "content": "The following shows a tree of data with nesting denoted by visual levels of indentation:\n\n```\nRosettaCode\n    rocks\n        code\n        comparison\n        wiki\n    mocks\n        trolling\n```\n\nA common datastructure for trees is to define node structures having a name and a, (possibly empty), list of child nodes. The nesting of nodes captures the indentation of the tree. Lets call this **the nest form**.\n\n```\n# E.g. if child nodes are surrounded by brackets\n#      and separated by commas then:\nRosettaCode(rocks(code, ...), ...)\n# But only an _example_\n```\n\nAnother datastructure for trees is to construct from the root an ordered list of the nodes level of indentation and the name of that node. The indentation for the root node is zero; node 'rocks is indented by one level from the left, and so on. Lets call this **the indent form**.\n\n```\n0 RosettaCode\n1 rocks\n2 code\n...\n```\n\nTask\n\n1. Create/use a nest datastructure format and textual representation for arbitrary trees.\n2. Create/use an indent datastructure format and textual representation for arbitrary trees.\n3. Create methods/classes/proceedures/routines etc to:\n   1. Change from a nest tree datastructure to an indent one.\n   2. Change from an indent tree datastructure to a nest one\n4. Use the above to encode the example at the start into the nest format, and show it.\n5. transform the initial nest format to indent format and show it.\n6. transform the indent format to final nest format and show it.\n7. Compare initial and final nest formats which should be the same.\n\nNote\n\n* It's all about showing aspects of the contrasting datastructures as they hold the tree.\n* Comparing nested datastructures is secondary - saving formatted output as a string then a string compare would suffice for this task, if its easier.\n\nShow all output on this page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\nCode golf is a entertaining passtime, even if it isn't appropriate for this site. To a large extent, I agree with Hout, I am not really on board with mocking anybody, especially espousing it as an official RosettaCode position. So, feel free to mark this incorrect.\n\n```\n#`(\nSort of vague as to what we are trying to accomplish here. If we are just\ntrying to transform from one format to another, probably easiest to just\nperform string manipulations.\n)\n\nmy $level = '  ';\n\nmy $trees = q:to/END/;\n    RosettaCode\n      encourages\n        code\n          diversity\n          comparison\n      discourages\n        golfing\n        trolling\n        emphasising execution speed\n    code-golf.io\n      encourages\n        golfing\n      discourages\n        comparison\n    END\n\nsub nested-to-indent { $^str.subst: / ^^ ($($level))* /, -> $/ { \"{+$0} \" }, :g }\nsub indent-to-nested { $^str.subst: / ^^ (\\d+) \\s* /, -> $/ { \"{$level x +$0}\" }, :g }\n\nsay $trees;\nsay my $indent = $trees.&nested-to-indent;\nsay my $nest = $indent.&indent-to-nested;\n\nuse Test;\nis($trees, $nest, 'Round-trip equals original');\n\n#`(\nIf, on the other hand, we want perform more complex transformations; better to\nload it into a native data structure which will then allow us to manipulate it\nhowever we like.\n)\n\n# Import outline paragraph into native data structure\nsub import (Str $trees, $level = '  ') {\n    my $forest;\n    my $last = -Inf;\n\n    for $trees.lines -> $branch {\n        $branch ~~ / ($($level))* /;\n        my $this = +$0;\n        $forest ~= do {\n            given $this cmp $last {\n                when More { \"\\['{esc $branch.trim}', \" }\n                when Same { \"'{esc $branch.trim}', \" }\n                when Less { \"{']' x $last - $this}, '{esc $branch.trim}', \" }\n            }\n        }\n        $last = $this;\n    }\n\n    sub esc { $^s.subst( /(<['\\\\]>)/, -> $/ { \"\\\\$0\" }, :g) }\n\n    $forest ~= ']' x 1 + $last;\n    $forest.EVAL;\n}\n\nmy $forest = import $trees;\n\nsay \"\\nNative data structure:\\n\", $forest.raku;\n\n{\n    use JSON::Fast;\n    say \"\\nJSON:\\n\", $forest.&to-json;\n}\n\n{\n    use YAML;\n    say \"\\nYAML:\\n\", $forest.&dump;\n}\n\n```\n\nOutput:\n\n```\nRosettaCode\n  encourages\n    code\n      diversity\n      comparison\n  discourages\n    golfing\n    trolling\n    emphasising execution speed\ncode-golf.io\n  encourages\n    golfing\n  discourages\n    comparison\n\n0 RosettaCode\n1 encourages\n2 code\n3 diversity\n3 comparison\n1 discourages\n2 golfing\n2 trolling\n2 emphasising execution speed\n0 code-golf.io\n1 encourages\n2 golfing\n1 discourages\n2 comparison\n\nRosettaCode\n  encourages\n    code\n      diversity\n      comparison\n  discourages\n    golfing\n    trolling\n    emphasising execution speed\ncode-golf.io\n  encourages\n    golfing\n  discourages\n    comparison\n\nok 1 - Round-trip equals original\n\nNative data structure:\n$[\"RosettaCode\", [\"encourages\", [\"code\", [\"diversity\", \"comparison\"]], \"discourages\", [\"golfing\", \"trolling\", \"emphasising execution speed\"]], \"code-golf.io\", [\"encourages\", [\"golfing\"], \"discourages\", [\"comparison\"]]]\n\nJSON:\n[\n  \"RosettaCode\",\n  [\n    \"encourages\",\n    [\n      \"code\",\n      [\n        \"diversity\",\n        \"comparison\"\n      ]\n    ],\n    \"discourages\",\n    [\n      \"golfing\",\n      \"trolling\",\n      \"emphasising execution speed\"\n    ]\n  ],\n  \"code-golf.io\",\n  [\n    \"encourages\",\n    [\n      \"golfing\"\n    ],\n    \"discourages\",\n    [\n      \"comparison\"\n    ]\n  ]\n]\n\nYAML:\n---\n- RosettaCode\n- - encourages\n  - - code\n    - - diversity\n      - comparison\n  - discourages\n  - - golfing\n    - trolling\n    - emphasising execution speed\n- code-golf.io\n- - encourages\n  - - golfing\n  - discourages\n  - - comparison\n...\n```"}]}
{"messages": [{"role": "user", "content": "Given a flat list of integers greater than zero, representing object nesting\nlevels, e.g. `[1, 2, 4]`,\ngenerate a tree formed from nested lists of those nesting level integers where:\n\n* Every int appears, in order, at its depth of nesting.\n* If the next level int is greater than the previous then it appears in a sub-list of the list containing the previous item\n\nThe generated tree data structure should ideally be in a languages nested list format that can\nbe used for further calculations rather than something just calculated for printing.\n\nAn input of `[1, 2, 4]` should produce the equivalent of: `[1, [2, [[4]]]]`\nwhere 1 is at depth1, 2 is two deep and 4 is nested 4 deep.\n\n`[1, 2, 4, 2, 2, 1]` should produce `[1, [2, [[4]], 2, 2], 1]`.   \nAll the nesting integers are in the same order but at the correct nesting\nlevels.\n\nSimilarly `[3, 1, 3, 1]` should generate `[[[3]], 1, [[3]], 1]`\n\nTask\n\nGenerate and show here the results for the following inputs:\n\n:   * `[]`\n    * `[1, 2, 4]`\n    * `[3, 1, 3, 1]`\n    * `[1, 2, 3, 1]`\n    * `[3, 2, 1, 3]`\n    * `[3, 3, 3, 1, 1, 3, 3, 3]`"}, {"role": "assistant", "content": "### Iterative\n\n**Translation of**: Python\n\n```\nsub new_level ( @stack --> Nil ) {\n    my $e = [];\n    push @stack.tail, $e;\n    push @stack,      $e;\n}\nsub to_tree_iterative ( @xs --> List ) {\n    my $nested = [];\n    my @stack  = $nested;\n\n    for @xs -> Int $x {\n        new_level(@stack) while $x > @stack;\n        pop       @stack  while $x < @stack;\n        push @stack.tail, $x;\n    }\n\n    return $nested;\n}\nmy @tests = (), (1, 2, 4), (3, 1, 3, 1), (1, 2, 3, 1), (3, 2, 1, 3), (3, 3, 3, 1, 1, 3, 3, 3);\nsay .Str.fmt( '%15s => ' ), .&to_tree_iterative for @tests;\n\n```\n\nOutput:\n\n```\n                => []\n          1 2 4 => [1 [2 [[4]]]]\n        3 1 3 1 => [[[3]] 1 [[3]] 1]\n        1 2 3 1 => [1 [2 [3]] 1]\n        3 2 1 3 => [[[3] 2] 1 [[3]]]\n3 3 3 1 1 3 3 3 => [[[3 3 3]] 1 1 [[3 3 3]]]\n\n```\n\n### Recursive\n\n**Translation of**: Python\n\n```\nsub to_tree_recursive ( @list, $index is copy, $depth ) {\n    my @so_far = gather while $index <= @list.end {\n        my $t = @list[$index];\n\n        given $t <=> $depth {\n            when Order::Same {\n                take $t;\n            }\n            when Order::More {\n                ( $index, my $n1 ) = to_tree_recursive( @list, $index, $depth+1 );\n                take $n1;\n            }\n            when Order::Less {\n                $index--;\n                last;\n            }\n        }\n        $index++;\n    }\n\n    my $i = ($depth > 1) ?? $index !! -1;\n    return $i, @so_far;\n}\nmy @tests = (), (1, 2, 4), (3, 1, 3, 1), (1, 2, 3, 1), (3, 2, 1, 3), (3, 3, 3, 1, 1, 3, 3, 3);\nsay .Str.fmt( '%15s => ' ), to_tree_recursive( $_, 0, 1 ).[1] for @tests;\n\n```\n\nOutput:\n\n```\n                => []\n          1 2 4 => [1 [2 [[4]]]]\n        3 1 3 1 => [[[3]] 1 [[3]] 1]\n        1 2 3 1 => [1 [2 [3]] 1]\n        3 2 1 3 => [[[3] 2] 1 [[3]]]\n3 3 3 1 1 3 3 3 => [[[3 3 3]] 1 1 [[3 3 3]]]\n\n```\n\n### String Eval\n\n**Translation of**: Perl\n\n```\nuse MONKEY-SEE-NO-EVAL;\nsub to_tree_string_eval ( @xs --> Array ) {\n    my @gap = [ |@xs, 0 ]  Z-  [ 0, |@xs ];\n\n    my @open  = @gap.map( '[' x  * );\n    my @close = @gap.map( ']' x -* );\n\n    my @wrapped = [Z~] @open, @xs, @close.skip;\n\n    return EVAL @wrapped.join(',').subst(:g, ']]', '],]') || '[]';\n}\nmy @tests = (), (1, 2, 4), (3, 1, 3, 1), (1, 2, 3, 1), (3, 2, 1, 3), (3, 3, 3, 1, 1, 3, 3, 3);\nsay .Str.fmt( '%15s => ' ), .&to_tree_string_eval for @tests;\n\n```\n\nOutput:\n\n```\n                => []\n          1 2 4 => [1 [2 [[4]]]]\n        3 1 3 1 => [[[3]] 1 [[3]] 1]\n        1 2 3 1 => [1 [2 [3]] 1]\n        3 2 1 3 => [[[3] 2] 1 [[3]]]\n3 3 3 1 1 3 3 3 => [[[3 3 3]] 1 1 [[3 3 3]]]\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a binary tree where each node carries an integer,   and implement:\n\n:   :   :   * pre-order,\n            * in-order,\n            * post-order,     and\n            * level-order   traversal.\n\nUse those traversals to output the following tree:\n\n```\n         1\n        / \\\n       /   \\\n      /     \\\n     2       3\n    / \\     /\n   4   5   6\n  /       / \\\n 7       8   9\n\n```\n\nThe correct output should look like this:\n\n```\npreorder:    1 2 4 7 5 3 6 8 9\ninorder:     7 4 2 5 1 8 6 9 3\npostorder:   7 4 5 2 8 9 6 3 1\nlevel-order: 1 2 3 4 5 6 7 8 9\n\n```\n\nSee also\n\n* Wikipedia article:   Tree traversal."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nclass TreeNode {\n    has TreeNode $.parent;\n    has TreeNode $.left;\n    has TreeNode $.right;\n    has $.value;\n\n    method pre-order {\n        flat gather {\n            take $.value;\n            take $.left.pre-order if $.left;\n            take $.right.pre-order if $.right\n        }\n    }\n\n    method in-order {\n        flat gather {\n            take $.left.in-order if $.left;\n            take $.value;\n            take $.right.in-order if $.right;\n        }\n    }\n\n    method post-order {\n        flat gather {\n            take $.left.post-order if $.left;\n            take $.right.post-order if $.right;\n            take $.value;\n        }\n    }\n\n    method level-order {\n        my TreeNode @queue = (self);\n        flat gather while @queue.elems {\n            my $n = @queue.shift;\n            take $n.value;\n            @queue.push($n.left) if $n.left;\n            @queue.push($n.right) if $n.right;\n        }\n    }\n}\n\nmy TreeNode $root .= new( value => 1,\n                    left => TreeNode.new( value => 2,\n                            left => TreeNode.new( value => 4, left => TreeNode.new(value => 7)),\n                            right => TreeNode.new( value => 5)\n                    ),\n                    right => TreeNode.new( value => 3, \n                             left => TreeNode.new( value => 6, \n                                     left => TreeNode.new(value => 8),\n                                     right => TreeNode.new(value => 9)\n                                     )\n                             )\n                    );\n\nsay \"preorder:  \",$root.pre-order.join(\" \");\nsay \"inorder:   \",$root.in-order.join(\" \");\nsay \"postorder: \",$root.post-order.join(\" \");\nsay \"levelorder:\",$root.level-order.join(\" \");\n\n```\n\nOutput:\n\n```\npreorder:  1 2 4 7 5 3 6 8 9\ninorder:   7 4 2 5 1 8 6 9 3\npostorder: 7 4 5 2 8 9 6 3 1\nlevelorder:1 2 3 4 5 6 7 8 9\n```"}]}
{"messages": [{"role": "user", "content": "A triangular number is a count of objects arranged into an equilateral triangle.\nMuch like how a square number is a count of objects arranged into a square.\n\nThe *nth* triangular number is the sum of the first **n** non-negative integers. \n\nT\n\nn\n=\n\n∑\n\nk\n=\n1\n\nn\nk\n=\n1\n+\n2\n+\n3\n+\n⋯\n+\nn\n{\\displaystyle {\\displaystyle T\\_{n}=\\sum \\_{k=1}^{n}k=1+2+3+\\dotsb +n}}\n\nTriangular numbers may be calculated by the explicit formulas: \n\nT\n\nn\n=\n\nn\n(\nn\n+\n1\n)\n2\n=\n\n(\n\n\nn\n+\n1\n2\n\n)\n{\\displaystyle {\\displaystyle T\\_{n}={\\frac {n(n+1)}{2}}={n+1 \\choose 2}}}\n\nwhere \n\n(\n\n\nn\n+\n1\n2\n\n)\n{\\displaystyle {\\displaystyle \\textstyle {n+1 \\choose 2}}}\n is the binomial coefficient \"n plus one choose two\".\n\nAnalogous to square roots, we may also calculate a triangular root. Numbers that have an integer triangular\nroot are triangular numbers.\n\nThe real triangular root of a number *x* may be found using: \n\nn\n=\n\n8\nx\n+\n1\n−\n1\n2\n{\\displaystyle {\\displaystyle n={\\frac {{\\sqrt {8x+1}}-1}{2}}}}\n\nSimilar to how cubic numbers are square numbers extended into a third dimension,\ntriangular numbers extended into a third dimension are known as tetrahedral numbers.\n\nThe *nth* tetrahedral number is the sum of the first **n** triangular numbers. \n\nT\n\ne\n\nn\n=\n\n∑\n\nk\n=\n1\n\nn\n\nT\n\nk\n{\\displaystyle {\\displaystyle Te\\_{n}=\\sum \\_{k=1}^{n}T\\_{k}}}\n\nOr, may be calculated directly: \n\nT\n\ne\n\nn\n=\n\nn\n(\nn\n+\n1\n)\n(\nn\n+\n2\n)\n6\n=\n\nn\n\n\n3\n¯\n\n3\n!\n=\n\n(\n\n\nn\n+\n2\n3\n\n)\n{\\displaystyle {\\displaystyle Te\\_{n}={\\frac {n(n+1)(n+2)}{6}}={\\frac {n^{\\overline {3}}}{3!}}={\\binom {n+2}{3}}}}\n (Binomial \"n plus two choose three\".)\n\nOne may find the real tetrahedral root of *x* using the formula: \n\nn\n=\n\n3\nx\n+\n\n\n9\n\n\nx\n\n2\n−\n\n\n1\n27\n\n3\n+\n\n3\nx\n−\n\n\n9\n\n\nx\n\n2\n−\n\n\n1\n27\n\n3\n−\n1\n{\\displaystyle {\\displaystyle n={\\sqrt[{3}]{3x+{\\sqrt {9{x^{2}}-{\\frac {1}{27}}}}}}+{\\sqrt[{3}]{3x-{\\sqrt {9{x^{2}}-{\\frac {1}{27}}}}}}-1}}\n  \n*Depending on the math precision of your particular language, may need to be rounded to the nearest 1e-16 or so.*\n\nExtending into a fourth dimension we get pentatopic numbers.\n\nAgain, the *nth* pentatope is the sum of the first **n** tetrahedral numbers, \n\nP\n\nn\n=\n\n∑\n\nk\n=\n1\n\nn\nT\n\ne\n\nk\n{\\displaystyle {\\displaystyle P\\_{n}=\\sum \\_{k=1}^{n}Te\\_{k}}}\n\nor explicitly: \n\nP\n\nn\n=\n\nn\n(\nn\n+\n1\n)\n(\nn\n+\n2\n)\n(\nn\n+\n3\n)\n24\n=\n\n(\n\n\nn\n+\n3\n4\n\n)\n{\\displaystyle {\\displaystyle P\\_{n}={\\frac {n(n+1)(n+2)(n+3)}{24}}={\\binom {n+3}{4}}}}\n (Binomial \"n plus three choose four\".)\n\nThe pentatopic real root of *x* may be found using: \n\nn\n=\n\n5\n+\n4\n\n\n24\nx\n+\n1\n−\n3\n2\n.\n{\\displaystyle {\\displaystyle n={\\frac {{\\sqrt {5+4{\\sqrt {24x+1}}}}-3}{2}}.}}\n\nIn general, these all belong to the class figurate numbers as they are\nbased on **r** dimensional geometric figures. Sometimes they are referred to as **r-simplex**\nnumbers. In geometry a simplex is the simplest possible **r-dimensional**\nobject.\n\nYou may easily extend to an arbitrary dimension **r** using binomials. Each term **n** in dimension **r** is \n\nr\n\nn\n=\n\n(\n\n\nn\n+\nr\n−\n1\nr\n\n)\n{\\displaystyle {\\displaystyle r\\_{n}={\\binom {n+r-1}{r}}}}\n\nThere is no known general formula to find higher r-simplex roots.\n\nTask\n\n* Find and display the first 30 triangular numbers (**r** = 2).\n* Find and display the first 30 tetrahedral numbers (**r** = 3).\n* Find and display the first 30 pentatopic numbers (**r** = 4).\n* Find and display the first 30 12-simplex numbers (**r** = 12).\n* Find and display the triangular root, the tetrahedral root, and the pentatopic root for the integers:\n  + 7140\n  + 21408696\n  + 26728085384\n  + 14545501785001\n\nSee also\n\n* Wikipedia: Triangular numbers * Wikipedia: Tetrahedral numbers * Wikipedia: Pentatopic numbers * Wikipedia: Figurate numbers * Wikipedia: Simplex(geometry) * OEIS:A000217 - Triangular numbers: a(n) = binomial(n+1,2) * OEIS:A000292 - Tetrahedral numbers: a(n) = binomial(n+2,3) * OEIS:A000332 - Pentatope numbers: a(n) = binomial(n+3,4) * Related task: Evaluate binomial coefficients * Related task: Pascal's triangle"}, {"role": "assistant", "content": "```\nuse Math::Root:ver<0.0.4>;\n\nsub binomial { [×] ($^n … 0) Z/ 1 .. $^p }\n\nsub polytopic (Int $r, @range) { @range.map: { binomial $_ + $r - 1, $r } }\n\nsub display (@values) {\n    my $c = @values.max.chars;\n    @values.batch(6)».fmt(\"%{$c}d\").join: \"\\n\";\n}\n\nfor 2, 'triangular', 3, 'tetrahedral', 4, 'pentatopic', 12, '12-simplex'\n  -> $r, $name { say \"\\nFirst 30 $name numbers:\\n\" ~ display polytopic $r, ^30 }\n\nsay '';\n\nmy \\ε = FatRat.new: 1, 10**24;\n\nfor 7140, 21408696, 26728085384, 14545501785001 {\n  say qq:to/R/;\n  Roots of $_:\n    triangular-root: {.&triangular-root.round:  ε}\n   tetrahedral-root: {.&tetrahedral-root.round: ε}\n    pentatopic-root: {.&pentatopic-root.round:  ε}\n  R\n}\n\n```\n\nOutput:\n\n```\nFirst 30 triangular numbers:\n  0   1   3   6  10  15\n 21  28  36  45  55  66\n 78  91 105 120 136 153\n171 190 210 231 253 276\n300 325 351 378 406 435\n\nFirst 30 tetrahedral numbers:\n   0    1    4   10   20   35\n  56   84  120  165  220  286\n 364  455  560  680  816  969\n1140 1330 1540 1771 2024 2300\n2600 2925 3276 3654 4060 4495\n\nFirst 30 pentatopic numbers:\n    0     1     5    15    35    70\n  126   210   330   495   715  1001\n 1365  1820  2380  3060  3876  4845\n 5985  7315  8855 10626 12650 14950\n17550 20475 23751 27405 31465 35960\n\nFirst 30 12-simplex numbers:\n         0          1         13         91        455       1820\n      6188      18564      50388     125970     293930     646646\n   1352078    2704156    5200300    9657700   17383860   30421755\n  51895935   86493225  141120525  225792840  354817320  548354040\n 834451800 1251677700 1852482996 2707475148 3910797436 5586853480\n\nRoots of 7140:\n  triangular-root: 119\n tetrahedral-root: 34\n  pentatopic-root: 18.876646615928006607901783\n\nRoots of 21408696:\n  triangular-root: 6543\n tetrahedral-root: 503.56182697463651404819613\n  pentatopic-root: 149.060947375265867484387575\n\nRoots of 26728085384:\n  triangular-root: 231205.405565255836957291031961\n tetrahedral-root: 5432\n  pentatopic-root: 893.442456751684869888466212\n\nRoots of 14545501785001:\n  triangular-root: 5393607.158145172316497304724655\n tetrahedral-root: 44355.777384073256052620916903\n  pentatopic-root: 4321\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nIf your language has a library or built-in functions for trigonometry, show examples of:\n\n:   :   * sine\n        * cosine\n        * tangent\n        * inverses   (of the above)\n\nusing the same angle in radians and degrees.\n\nFor the non-inverse functions,   each radian/degree pair should use arguments that evaluate to the same angle   (that is, it's not necessary to use the same angle for all three regular functions as long as the two sine calls use the same angle).\n\nFor the inverse functions,   use the same number and convert its answer to radians and degrees.\n\nIf your language does not have trigonometric functions available or only has some available,   write functions to calculate the functions based on any   known approximation or identity."}, {"role": "assistant", "content": "(formerly Perl 6) Borrow the degree to radian routine from here.\n\n**Works with**: Rakudo version 2020.12\n\n```\n# 20210212 Updated Raku programming solution\n\nsub postfix:<°>    (\\ᵒ) { ᵒ × τ / 360 }\n\nsub postfix:<㎭🡆°> (\\ᶜ) { ᶜ / π × 180 }\n\nsay sin π/3 ;\nsay sin 60° ;\n\nsay cos π/4 ;\nsay cos 45° ;\n\nsay tan π/6 ;\nsay tan 30° ;\n\n( asin(3.sqrt/2), acos(1/sqrt 2), atan(1/sqrt 3) )».&{ .say and .㎭🡆°.say }\n\n```\n\nOutput:\n\n```\n0.8660254037844386\n0.8660254037844386\n0.7071067811865476\n0.7071067811865476\n0.5773502691896257\n0.5773502691896257\n1.0471975511965976\n60\n0.7853981633974484\n45.00000000000001\n0.5235987755982989\n30.000000000000004\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nNumbers   **n**   such that the three numbers   **n-1**,   **n+3**,   and   **n+5**   are all prime,   where   **n < 6,000.**"}, {"role": "assistant", "content": "A weird combination of Cousin primes and Twin primes that are siblings, but known by their neighbor.... I shall dub these Alabama primes.\n\n```\nsay \"{.[0]+1}: \",$_ for grep *.all.is-prime, ^6000 .race.map: { $_-1, $_+3, $_+5 };\n\n```\n\nOutput:\n\n```\n8: (7 11 13)\n14: (13 17 19)\n38: (37 41 43)\n68: (67 71 73)\n98: (97 101 103)\n104: (103 107 109)\n194: (193 197 199)\n224: (223 227 229)\n278: (277 281 283)\n308: (307 311 313)\n458: (457 461 463)\n614: (613 617 619)\n824: (823 827 829)\n854: (853 857 859)\n878: (877 881 883)\n1088: (1087 1091 1093)\n1298: (1297 1301 1303)\n1424: (1423 1427 1429)\n1448: (1447 1451 1453)\n1484: (1483 1487 1489)\n1664: (1663 1667 1669)\n1694: (1693 1697 1699)\n1784: (1783 1787 1789)\n1868: (1867 1871 1873)\n1874: (1873 1877 1879)\n1994: (1993 1997 1999)\n2084: (2083 2087 2089)\n2138: (2137 2141 2143)\n2378: (2377 2381 2383)\n2684: (2683 2687 2689)\n2708: (2707 2711 2713)\n2798: (2797 2801 2803)\n3164: (3163 3167 3169)\n3254: (3253 3257 3259)\n3458: (3457 3461 3463)\n3464: (3463 3467 3469)\n3848: (3847 3851 3853)\n4154: (4153 4157 4159)\n4514: (4513 4517 4519)\n4784: (4783 4787 4789)\n5228: (5227 5231 5233)\n5414: (5413 5417 5419)\n5438: (5437 5441 5443)\n5648: (5647 5651 5653)\n5654: (5653 5657 5659)\n5738: (5737 5741 5743)\n```"}]}
{"messages": [{"role": "user", "content": "In algebra, a max tropical semiring (also called a max-plus algebra) is the semiring\n(ℝ ∪ -Inf, ⊕, ⊗) containing the ring of real numbers ℝ augmented by negative infinity,\nthe max function (returns the greater of two real numbers), and addition.\n\nIn max tropical algebra, x ⊕ y = max(x, y) and x ⊗ y = x + y. The identity for ⊕\nis -Inf (the max of any number with -infinity is that number), and the identity for ⊗ is 0.\n\nTask\n\n* Define functions or, if the language supports the symbols as operators, operators for ⊕ and ⊗ that fit the above description. If the language does not support ⊕ and ⊗ as operators but allows overloading operators for a new object type, you may instead overload + and \\* for a new min tropical albrbraic type. If you cannot overload operators in the language used, define ordinary functions for the purpose.\n\nShow that 2 ⊗ -2 is 0, -0.001 ⊕ -Inf is -0.001, 0 ⊗ -Inf is -Inf, 1.5 ⊕ -1 is 1.5, and -0.5 ⊗ 0 is -0.5.\n\n* Define exponentiation as serial ⊗, and in general that a to the power of b is a \\* b, where a is a real number and b must be a positive integer. Use either ↑ or similar up arrow or the carat ^, as an exponentiation operator if this can be used to overload such \"exponentiation\" in the language being used. Calculate 5 ↑ 7 using this definition.\n\n* Max tropical algebra is distributive, so that\n\n```\n  a ⊗ (b ⊕ c) equals a ⊗ b ⊕ b ⊗ c, \n\n```\n\nwhere ⊗ has precedence over ⊕. Demonstrate that 5 ⊗ (8 ⊕ 7) equals 5 ⊗ 8 ⊕ 5 ⊗ 7.\n\n* If the language used does not support operator overloading, you may use ordinary function names such as tropicalAdd(x, y) and tropicalMul(x, y).\n\nSee also\n:   * [Tropical algebra] * [Tropical geometry review article] * [Operator overloading]"}, {"role": "assistant", "content": "No need to overload, define our own operators with whatever precedence level we want. Here we're setting precedence equivalent to existing operators.\n\n```\nsub infix:<⊕> (Real $a, Real $b) is equiv(&[+]) { $a max $b }\nsub infix:<⊗> (Real $a, Real $b) is equiv(&[×]) { $a + $b }\nsub infix:<↑> (Real $a,  Int $b where * ≥ 0) is equiv(&[**]) { [⊗] $a xx $b }\n \nuse Test;\n \nis-deeply(      2 ⊗ -2,        0, '2 ⊗ -2 == 0' );\nis-deeply( -0.001 ⊕ -Inf, -0.001, '-0.001 ⊕ -Inf == -0.001' );\nis-deeply(      0 ⊗ -Inf,   -Inf, '0 ⊗ -Inf == -Inf' );\nis-deeply(    1.5 ⊕ -1,      1.5, '1.5 ⊕ -1 == 1.5' );\nis-deeply(   -0.5 ⊗ 0,      -0.5, '-0.5 ⊗ 0 == -0.5' );\nis-deeply(      5 ↑ 7,        35, '5 ↑ 7 == 35' );\nis-deeply( 5 ⊗ (8 ⊕ 7),  5 ⊗ 8 ⊕ 5 ⊗ 7, '5 ⊗ (8 ⊕ 7) == 5 ⊗ 8 ⊕ 5 ⊗ 7');\nis-deeply( 5 ↑ 7 ⊕ 6 ↑ 6,     36, '5 ↑ 7 ⊕ 6 ↑ 6 == 36');\n\n```\n\nOutput:\n\n```\nok 1 - 2 ⊗ -2 == 0\nok 2 - -0.001 ⊕ -Inf == -0.001\nok 3 - 0 ⊗ -Inf == -Inf\nok 4 - 1.5 ⊕ -1 == 1.5\nok 5 - -0.5 ⊗ 0 == -0.5\nok 6 - 5 ↑ 7 == 35\nok 7 - 5 ⊗ (8 ⊕ 7) == 5 ⊗ 8 ⊕ 5 ⊗ 7\nok 8 - 5 ↑ 7 ⊕ 6 ↑ 6 == 36\n```"}]}
{"messages": [{"role": "user", "content": "A truncatable prime is a prime number that when you successively remove digits from one end of the prime, you are left with a new prime number.\n\nExamples\n\nThe number **997** is called a *left-truncatable prime* as the numbers **997**, **97**, and **7** are all prime.\n\nThe number **7393** is a *right-truncatable prime* as the numbers **7393**, **739**, **73**, and **7** formed by removing digits from its right are also prime.\n\nNo zeroes are allowed in truncatable primes.\n\nTask\n\nThe task is to find the largest left-truncatable and right-truncatable primes less than one million (base 10 is implied).\n\nRelated tasks\n\n* Find largest left truncatable prime in a given base\n* Sieve of Eratosthenes\n\nSee also\n\n* Truncatable Prime from MathWorld.]"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2024.12\n\nYou May Attempt This Online.\n\n```\nconstant ltp = [2, 3, 5, 7], {\n    last if .not;\n    [ ((1..9) X~ @$_).grep: &is-prime ]\n} ... *;\n\nconstant rtp = [2, 3, 5, 7], {\n    last if .not;\n    [ (@$_ X~ (1,3,7,9)).grep: &is-prime ]\n} ... *;\n\nsay \"Largest ltp < 1e6 = \", ltp[5][*-1];\nsay \"Largest rtp < 1e6 = \", rtp[5][*-1];\nsay \"Largest possible ltp = \", ltp.eager.flat.tail;\nsay \"Largest possible rtp = \", rtp.eager.flat.tail;\n\n```\n\nOutput:\n\n```\nLargest ltp < 1e6 = 998443\nLargest rtp < 1e6 = 739399\nLargest possible ltp = 357686312646216567629137\nLargest possible rtp = 73939133\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nTruncate a file to a specific length.   This should be implemented as a routine that takes two parameters: the filename and the required file length (in bytes).\n\nTruncation can be achieved using system or library calls intended for such a task, if such methods exist, or by creating a temporary file of a reduced size and renaming it, after first deleting the original file, if no other method is available.   The file may contain non human readable binary data in an unspecified format, so the routine should be \"binary safe\", leaving the contents of the untruncated part of the file unchanged.\n\nIf the specified filename does not exist, or the provided length is not less than the current file length, then the routine should raise an appropriate error condition.\n\nOn some systems, the provided file truncation facilities might not change the file or may extend the file, if the specified length is greater than the current length of the file.\n\nThis task permits the use of such facilities.   However, such behaviour should be noted, or optionally a warning message relating to an non change or increase in file size may be implemented."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.07\n\n```\nuse NativeCall;\n\nsub truncate(Str, int32 --> int32) is native {*}\n\nsub MAIN (Str $file, Int $to) {\n    given $file.IO { \n        .e        or die \"$file doesn't exist\";\n        .w        or die \"$file isn't writable\";\n        .s >= $to or die \"$file is not big enough to truncate\";\n    }\n    truncate($file, $to) == 0 or die \"Truncation was unsuccessful\";\n}\n\n```\n\nThe external `truncate` routine could be replaced with the following line (in which case no need for `NativeCall`):\n\n```\nspurt $file, slurp($file).substr($to);\n\n```"}]}
{"messages": [{"role": "user", "content": "A truth table is a display of the inputs to, and the output of a Boolean function organized as a table where each row gives one combination of input values and the corresponding value of the function.\n\nTask\n\n1. Input a Boolean function from the user as a string then calculate and print a formatted truth table for the given function.  \n    (One can assume that the user input is correct).\n2. Print and show output for Boolean functions of two and three input variables, but any program should not be limited to that many variables in the function.\n3. Either reverse-polish or infix notation expressions are allowed.\n\nRelated tasks\n\n* Boolean values\n* Ternary logic\n\nSee also\n\n* Wolfram MathWorld entry on truth tables.\n* some \"truth table\" examples from Google."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2016.01\n\n```\nuse MONKEY-SEE-NO-EVAL;\n\nsub MAIN ($x) {\n    my @n = $x.comb(/<ident>/);\n    my &fun = EVAL \"-> {('\\\\' «~« @n).join(',')} \\{ [{ (|@n,\"so $x\").join(',') }] \\}\";\n\n    say (|@n,$x).join(\"\\t\");\n    .join(\"\\t\").say for map &fun, flat map { .fmt(\"\\%0{+@n}b\").comb».Int».so }, 0 ..^ 2**@n;\n    say '';\n}\n\n```\n\nOutput:\n\n```\n$ truthtable 'A ^ B'\nA   B   A ^ B\nFalse   False   False\nFalse   True    True\nTrue    False   True\nTrue    True    False\n\n$ truthtable 'foo & bar | baz'\nfoo bar baz foo & bar | baz\nFalse   False   False   False\nFalse   False   True    True\nFalse   True    False   False\nFalse   True    True    True\nTrue    False   False   False\nTrue    False   True    True\nTrue    True    False   True\nTrue    True    True    True\n\n$ truthtable 'Jim & (Spock ^ Bones) | Scotty'\nJim Spock   Bones   Scotty  Jim & (Spock ^ Bones) | Scotty\nFalse   False   False   False   False\nFalse   False   False   True    True\nFalse   False   True    False   False\nFalse   False   True    True    True\nFalse   True    False   False   False\nFalse   True    False   True    True\nFalse   True    True    False   False\nFalse   True    True    True    True\nTrue    False   False   False   False\nTrue    False   False   True    True\nTrue    False   True    False   True\nTrue    False   True    True    True\nTrue    True    False   False   True\nTrue    True    False   True    True\nTrue    True    True    False   False\nTrue    True    True    True    True\n```"}]}
{"messages": [{"role": "user", "content": "Introduction\n\nJeff Tupper, in his 2001 paper \"Reliable Two-Dimensional Graphing Methods for Mathematical Formulae with Two Free Variables\", shows a set of methods to graph equations and inequalities with two variables in the cartesian plane.\n\nOne of the examples of the paper, refers to the inequality:\n\n1\n2\n<\n\n⌊\n\n\nm\no\nd\n\n(\n\n\n⌊\n\n\ny\n17\n⌋\n\n2\n\n−\n17\n⌊\nx\n⌋\n−\n\nm\no\nd\n\n(\n\n⌊\ny\n⌋\n,\n17\n)\n,\n2\n)\n⌋\n{\\displaystyle {\\frac {1}{2}}<\\left\\lfloor \\mathrm {mod} \\left(\\left\\lfloor {\\frac {y}{17}}\\right\\rfloor 2^{-17\\lfloor x\\rfloor -\\mathrm {mod} \\left(\\lfloor y\\rfloor ,17\\right)},2\\right)\\right\\rfloor }\n\nThat inequality, once plotted in the range 0 ≤ x ≤ 106 and k ≤ y ≤ k + 17 for k = 960, 939, 379, 918, 958, 884, 971, 672, 962, 127, 852, 754, 715, 004, 339, 660, 129, 306, 651, 505, 519, 271, 702, 802, 395, 266, 424, 689, 642, 842, 174, 350, 718, 121, 267, 153, 782, 770, 623, 355, 993, 237, 280, 874, 144, 307, 891, 325, 963, 941, 337, 723, 487, 857, 735, 749, 823, 926, 629, 715, 517, 173, 716, 995, 165, 232, 890, 538, 221, 612, 403, 238, 855, 866, 184, 013, 235, 585, 136, 048, 828, 693, 337, 902, 491, 454, 229, 288, 667, 081, 096, 184, 496, 091, 705, 183, 454, 067, 827, 731, 551, 705, 405, 381, 627, 380, 967, 602, 565, 625, 016, 981, 482, 083, 418, 783, 163, 849, 115, 590, 225, 610, 003, 652, 351, 370, 343, 874, 461, 848, 378, 737, 238, 198, 224, 849, 863, 465, 033, 159, 410, 054, 974, 700, 593, 138, 339, 226, 497, 249, 461, 751, 545, 728, 366, 702, 369, 745, 461, 014, 655, 997, 933, 798, 537, 483, 143, 786, 841, 806, 593, 422, 227, 898, 388, 722, 980, 000, 748, 404, 719 produces a drawing that visually mimics the inequality itself, hence it is called self-referential.\n\nAlthough the inequality is intended to be drawn on the continuum of the cartesian plane, the drawing can be performed iterating over the integer values of both the horizontal and vertical ranges.\n\nTask\n\nMake a drawing of the Tupper's formula, either using text, a matrix or creating an image.\n\nThis task requires arbitrary precision integer operations. If your language does not intrinsically support that, you can use a library.\n\nEpilogue\n\nThe value of k is an encoding of the bitmap of the image, therefore any 17-width bitmap can be produced, using its associated encoded value as k.\n\nReferences\n\n:   * Wikipedia: Tupper's self-referential formula\n    * Tupper, Jeff. \"Reliable Two-Dimensional Graphing Methods for Mathematical Formulae with Two Free Variables\""}, {"role": "assistant", "content": "```\n# 20240802 Raku programming solution\n\nmy ( \\H, \\W, \\N ) = 17, 106, 4858450636189713423582095962494202044581400587983244549483093085061934704708809928450644769865524364849997247024915119110411605739177407856919754326571855442057210445735883681829823754139634338225199452191651284348332905131193199953502413758765239264874613394906870130562295813219481113685339535565290850023875092856892694555974281546386510730049106723058933586052544096664351265349363643957125565695936815184334857605266940161251266951421550539554519153785457525756590740540157929001765967965480064427829131488548259914721248506352686630476300;\n\nfor N+H-1 ... N -> \\y {\n   say [~] ^W .map: { (y div H) div 2**(H * $_ + y % H) % 2 ?? '█' !! ' ' }\n}\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "This puzzle is borrowed from   math-frolic.blogspot.\n\nGiven the following twelve statements, which of them are true?\n\n```\n 1.  This is a numbered list of twelve statements.\n 2.  Exactly 3 of the last 6 statements are true.\n 3.  Exactly 2 of the even-numbered statements are true.\n 4.  If statement 5 is true, then statements 6 and 7 are both true.\n 5.  The 3 preceding statements are all false.\n 6.  Exactly 4 of the odd-numbered statements are true.\n 7.  Either statement 2 or 3 is true, but not both.\n 8.  If statement 7 is true, then 5 and 6 are both true.\n 9.  Exactly 3 of the first 6 statements are true.\n10.  The next two statements are both true.\n11.  Exactly 1 of statements 7, 8 and 9 are true.\n12.  Exactly 4 of the preceding statements are true.\n\n```\n\nTask\n\nWhen you get tired of trying to figure it out in your head,\nwrite a program to solve it, and print the correct answer or answers.\n\nExtra credit\n\nPrint out a table of near misses, that is, solutions that are contradicted by only a single statement."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.07\n\n```\nsub infix:<→> ($protasis, $apodosis) { !$protasis or $apodosis }\n \nmy @tests =\n    { .end == 12 and all(.[1..12]) === any(True, False) },\n    { 3 == [+] .[7..12] },\n    { 2 == [+] .[2,4...12] },\n    { .[5] → all .[6,7] },\n    { none .[2,3,4] },\n    { 4 == [+] .[1,3...11] },\n    { one .[2,3] },\n    { .[7] → all .[5,6] },\n    { 3 == [+] .[1..6] },\n    { all .[11,12] },\n    { one .[7,8,9] },\n    { 4 == [+] .[1..11] },\n;\n\nmy @solutions;\nmy @misses;\n\nfor [X] (True, False) xx 12 {\n    my @assert = Nil, |$_;\n    my @result = Nil, |@tests.map({ ?.(@assert) });\n    my @true = @assert.grep(?*, :k);\n    my @cons = (@assert Z=== @result).grep(!*, :k);\n    given @cons {\n        when 0 { push @solutions, \"<{@true}> is consistent.\"; }\n        when 1 { push @misses, \"<{@true}> implies { \"¬\" if !@result[~$_] }$_.\" }\n    }\n}\n\n.say for @solutions;\nsay \"\";\nsay \"Near misses:\";\n.say for @misses;\n\n```\n\nOutput:\n\n```\n<1 3 4 6 7 11> is consistent.\n\nNear misses:\n<1 2 4 7 8 9> implies ¬8.\n<1 2 4 7 9 10> implies ¬10.\n<1 2 4 7 9 12> implies ¬12.\n<1 3 4 6 7 9> implies ¬9.\n<1 3 4 8 9> implies 7.\n<1 4 6 8 9> implies ¬6.\n<1 4 8 10 11 12> implies ¬12.\n<1 4> implies 8.\n<1 5 6 9 11> implies 8.\n<1 5 8 10 11 12> implies ¬12.\n<1 5 8 11> implies 12.\n<1 5 8> implies 11.\n<1 5> implies 8.\n<4 8 10 11 12> implies 1.\n<5 8 10 11 12> implies 1.\n<5 8 11> implies 1.\n```"}]}
{"messages": [{"role": "user", "content": "Twin primes are pairs of natural numbers   (P1  and  P2)   that satisfy the following:\n\n:   :   1. P1   and   P2   are primes\n        2. P1  +  **2**   =   P2\n\nTask\n\nWrite a program that displays the number of **pairs of twin primes** that can be found under a user-specified number\n  \n(P1 < *user-specified number* & P2 < *user-specified number*).\n\nExtension\n:   :   1. Find all twin prime pairs under 100000, 10000000 and 1000000000.\n        2. What is the time complexity of the program? Are there ways to reduce computation time?\n\nExamples\n\n```\n> Search Size: 100\n> 8 twin prime pairs.\n\n```\n\n```\n> Search Size: 1000\n> 35 twin prime pairs.\n\n```\n\nAlso see\n\n* The OEIS entry: A001097: Twin primes.\n* The OEIS entry: A167874: The number of distinct primes < 10^n which are members of twin-prime pairs.\n* The OEIS entry: A077800: List of twin primes {p, p+2}, with repetition.\n* The OEIS entry: A007508: Number of twin prime pairs below 10^n."}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.07\n\n```\nuse Lingua::EN::Numbers;\n\nuse Math::Primesieve;\n\nmy $p = Math::Primesieve.new;\n\nprintf \"Twin prime pairs less than %17s: %s\\n\", comma(10**$_), comma $p.count(10**$_, :twins) for 1 .. 12;\nsay (now - INIT now).round(.01) ~ ' seconds';\n\n```\n\nOutput:\n\n```\nTwin prime pairs less than                10: 2\nTwin prime pairs less than               100: 8\nTwin prime pairs less than             1,000: 35\nTwin prime pairs less than            10,000: 205\nTwin prime pairs less than           100,000: 1,224\nTwin prime pairs less than         1,000,000: 8,169\nTwin prime pairs less than        10,000,000: 58,980\nTwin prime pairs less than       100,000,000: 440,312\nTwin prime pairs less than     1,000,000,000: 3,424,506\nTwin prime pairs less than    10,000,000,000: 27,412,679\nTwin prime pairs less than   100,000,000,000: 224,376,048\nTwin prime pairs less than 1,000,000,000,000: 1,870,585,220\n6.89 seconds\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program that displays twin primes under 10.000.000 whose sum is a square number."}, {"role": "assistant", "content": "Updated for updated task requirements. Trivial to find the squares that are sums of twin primes less than 1e7. (First 69.) Also find the largest square less than 1e12 (#4288) (Not sure why, but that seems to be a popular \"stretch\" task, and the largest matching *root* less than 1e7, that when squared is a sum of two twin primes. (#29,996) Added some timing info as well. Timing is going to be system dependent. This task is ridiculously parallelizable. Run on a 16 core Ryzen 7950X.\n\n```\nuse List::Divvy;\n\nmy @tps = lazy (^Inf).hyper(:1000batch).map({next if $_%2; (my $s = .², $_, $s+>1)}).grep:\n  {(.[2]-1).is-prime && (.[2]+1).is-prime};\n\n{\n    state $c;\n    say \"{++$c}: {.[1]}² ({.[0]}) == {.[2]-1} + {.[2]+1}\"\n} for @tps.&before({.[2] > 1e7});\n\nsay \"{(now - INIT now).round(.001)} seconds elapsed\\n\";\n\n{\n    my $s =  @tps[$_];\n    say \"{1+$_}: {$s[1]}² ({$s[0]}) == {$s[2]-1} + {$s[2]+1}\";\n} for @tps.&before({.[0] > 1e12}).elems - 1, @tps.first({.[1] > 1e7},:k) - 1;\n\nsay \"\\n{(now - INIT now).round(.001)} total seconds elapsed\\n\";\n\n```\n\nOutput:\n\n```\n1: 6² (36) == 17 + 19\n2: 12² (144) == 71 + 73\n3: 42² (1764) == 881 + 883\n4: 48² (2304) == 1151 + 1153\n5: 72² (5184) == 2591 + 2593\n6: 84² (7056) == 3527 + 3529\n7: 90² (8100) == 4049 + 4051\n8: 174² (30276) == 15137 + 15139\n9: 204² (41616) == 20807 + 20809\n10: 264² (69696) == 34847 + 34849\n11: 306² (93636) == 46817 + 46819\n12: 372² (138384) == 69191 + 69193\n13: 408² (166464) == 83231 + 83233\n14: 456² (207936) == 103967 + 103969\n15: 474² (224676) == 112337 + 112339\n16: 546² (298116) == 149057 + 149059\n17: 594² (352836) == 176417 + 176419\n18: 600² (360000) == 179999 + 180001\n19: 642² (412164) == 206081 + 206083\n20: 750² (562500) == 281249 + 281251\n21: 852² (725904) == 362951 + 362953\n22: 882² (777924) == 388961 + 388963\n23: 936² (876096) == 438047 + 438049\n24: 972² (944784) == 472391 + 472393\n25: 978² (956484) == 478241 + 478243\n26: 1038² (1077444) == 538721 + 538723\n27: 1140² (1299600) == 649799 + 649801\n28: 1212² (1468944) == 734471 + 734473\n29: 1272² (1617984) == 808991 + 808993\n30: 1386² (1920996) == 960497 + 960499\n31: 1470² (2160900) == 1080449 + 1080451\n32: 1512² (2286144) == 1143071 + 1143073\n33: 1518² (2304324) == 1152161 + 1152163\n34: 1584² (2509056) == 1254527 + 1254529\n35: 1770² (3132900) == 1566449 + 1566451\n36: 1836² (3370896) == 1685447 + 1685449\n37: 1902² (3617604) == 1808801 + 1808803\n38: 1980² (3920400) == 1960199 + 1960201\n39: 1986² (3944196) == 1972097 + 1972099\n40: 2130² (4536900) == 2268449 + 2268451\n41: 2196² (4822416) == 2411207 + 2411209\n42: 2256² (5089536) == 2544767 + 2544769\n43: 2262² (5116644) == 2558321 + 2558323\n44: 2316² (5363856) == 2681927 + 2681929\n45: 2382² (5673924) == 2836961 + 2836963\n46: 2652² (7033104) == 3516551 + 3516553\n47: 2688² (7225344) == 3612671 + 3612673\n48: 2718² (7387524) == 3693761 + 3693763\n49: 2772² (7683984) == 3841991 + 3841993\n50: 2814² (7918596) == 3959297 + 3959299\n51: 2886² (8328996) == 4164497 + 4164499\n52: 2946² (8678916) == 4339457 + 4339459\n53: 2988² (8928144) == 4464071 + 4464073\n54: 3012² (9072144) == 4536071 + 4536073\n55: 3096² (9585216) == 4792607 + 4792609\n56: 3282² (10771524) == 5385761 + 5385763\n57: 3366² (11329956) == 5664977 + 5664979\n58: 3498² (12236004) == 6118001 + 6118003\n59: 3558² (12659364) == 6329681 + 6329683\n60: 3582² (12830724) == 6415361 + 6415363\n61: 3738² (13972644) == 6986321 + 6986323\n62: 3786² (14333796) == 7166897 + 7166899\n63: 3936² (15492096) == 7746047 + 7746049\n64: 3948² (15586704) == 7793351 + 7793353\n65: 4032² (16257024) == 8128511 + 8128513\n66: 4170² (17388900) == 8694449 + 8694451\n67: 4200² (17640000) == 8819999 + 8820001\n68: 4314² (18610596) == 9305297 + 9305299\n69: 4416² (19501056) == 9750527 + 9750529\n0.027 seconds elapsed\n\n4288: 999684² (999368099856) == 499684049927 + 499684049929\n29996: 9999450² (99989000302500) == 49994500151249 + 49994500151251\n\n71.494 total seconds elapsed\n\n```"}]}
{"messages": [{"role": "user", "content": "The following is supposedly a question given to mathematics graduates seeking jobs on Wall Street:\n\n> A revolver handgun has a revolving cylinder with six chambers for bullets.\n>\n> It is loaded with the following procedure:\n>\n> 1. Check the first chamber to the right of the trigger for a bullet. If a bullet\n> is seen, the cylinder is rotated one chamber clockwise and the next chamber\n> checked until an empty chamber is found.\n>\n> 2. A cartridge containing a bullet is placed in the empty chamber.\n>\n> 3. The cylinder is then rotated one chamber clockwise.\n>\n> To randomize the cylinder's position, the cylinder is spun, which causes the cylinder to take\n> a random position from 1 to 6 chamber rotations clockwise from its starting position.\n>\n> When the trigger is pulled the gun will fire if there is a bullet in position 0, which is just\n> counterclockwise from the loading position.\n>\n> The gun is unloaded by removing all cartridges from the cylinder.\n>\n> According to the legend, a suicidal Russian imperial military officer plays a game of Russian\n> roulette by putting two bullets in a six-chamber cylinder and pulls the trigger twice.\n> If the gun fires with a trigger pull, this is considered a successful suicide.\n>\n> The cylinder is always spun before the first shot, but it may or may not be spun after putting\n> in the first bullet and may or may not be spun after taking the first shot.\n>\n> Which of the following situations produces the highest probability of suicide?\n>\n> A. Spinning the cylinder after loading the first bullet, and spinning again after the first shot.\n>\n> B. Spinning the cylinder after loading the first bullet only.\n>\n> C. Spinning the cylinder after firing the first shot only.\n>\n> D. Not spinning the cylinder either after loading the first bullet or after the first shot.\n>\n> E. The probability is the same for all cases.\n\nTask\n\n1. Run a repeated simulation of each of the above scenario, calculating the percentage of suicide with a randomization of the four spinning, loading and firing order scenarios.\n2. Show the results as a percentage of deaths for each type of scenario.\n3. The hand calculated probabilities are 5/9, 7/12, 5/9, and 1/2. A correct program should produce results close enough to those to allow a correct response to the interview question.\n\nReference\n\nYoutube video on the Russian 1895 Nagant revolver [[1]]"}, {"role": "assistant", "content": "```\nunit sub MAIN ($shots = 6);\n\nmy @cyl;\n\nsub load () {\n    @cyl.=rotate(-1) while @cyl[1];\n    @cyl[1] = 1;\n    @cyl.=rotate(-1);\n}\n\nsub spin () { @cyl.=rotate: (^@cyl).pick }\n\nsub fire () { @cyl.=rotate; @cyl[0] }\n\nsub LSLSFSF {\n    @cyl = 0 xx $shots;\n    load, spin, load, spin;\n    return 1 if fire;\n    spin;\n    fire\n}\n\nsub LSLSFF {\n    @cyl = 0 xx $shots;\n    load, spin, load, spin;\n    fire() || fire\n}\n\nsub LLSFSF {\n    @cyl = 0 xx $shots;\n    load, load, spin;\n    return 1 if fire;\n    spin;\n    fire\n}\n\nsub LLSFF {\n    @cyl = 0 xx $shots;\n    load, load, spin;\n    fire() || fire\n}\n\nmy %revolver;\nmy $trials = 100000;\n\nfor ^$trials {\n    %revolver<LSLSFSF> += LSLSFSF;\n    %revolver<LSLSFF>  += LSLSFF;\n    %revolver<LLSFSF>  += LLSFSF;\n    %revolver<LLSFF>   += LLSFF;\n}\n\nsay \"{.fmt('%7s')}: %{(%revolver{$_} / $trials × 100).fmt('%.2f')}\"\n  for <LSLSFSF LSLSFF LLSFSF LLSFF>\n\n```\n\nSample output (default; 6 shooter):\n\n```\nLSLSFSF: %55.37\n LSLSFF: %58.30\n LLSFSF: %55.42\n  LLSFF: %50.29\n\n```\n\nThough if you go and look at the Wikipedia article for the 1895 Nagant revolver mentioned in the task reference section, you'll see it is actually a **7** shot revolver... so, run again with 7 chambers:\n\n`raku roulette.raku 7`\n\nSample output (7 shooter):\n\n```\nLSLSFSF: %49.29\n LSLSFF: %51.14\n LLSFSF: %48.74\n  LLSFF: %43.08\n```\n\nOr, how about a Ruger GP100 10 round revolver?\n\n`raku roulette.raku 10`\n\nSample output (10 shooter):\n\n```\nLSLSFSF: %36.00\n LSLSFF: %37.00\n LLSFSF: %36.13\n  LLSFF: %29.77\n```\n\nDoesn't change the answers, B (LSLSFF) is definitely the worst most likely choice in all cases."}]}
{"messages": [{"role": "user", "content": "Task\n\nFind and display   (here on this page)   positive integers, n, whose base 2 representation is the concatenation of two identical binary strings,\n  \nwhere    **n** <   1,00010 **(one thousand).**\n\nFor each such integer, show its decimal and binary forms."}, {"role": "assistant", "content": "```\nmy @cat = (1..*).map: { :2([~] .base(2) xx 2) };\nsay \"{+$_} matching numbers\\n{.batch(5)».map({$_ ~ .base(2).fmt('(%s)')})».fmt('%15s').join: \"\\n\"}\\n\"\n    given @cat[^(@cat.first: * > 1000, :k)];\n\n```\n\nOutput:\n\n```\n30 matching numbers\n          3(11)        10(1010)        15(1111)      36(100100)      45(101101)\n     54(110110)      63(111111)   136(10001000)   153(10011001)   170(10101010)\n  187(10111011)   204(11001100)   221(11011101)   238(11101110)   255(11111111)\n528(1000010000) 561(1000110001) 594(1001010010) 627(1001110011) 660(1010010100)\n693(1010110101) 726(1011010110) 759(1011110111) 792(1100011000) 825(1100111001)\n858(1101011010) 891(1101111011) 924(1110011100) 957(1110111101) 990(1111011110)\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nTask\n\nGiven a sorted array of integers (with possibly duplicates), is it possible to find a pair of integers from that array that sum up to a given sum? If so, return indices of the two integers or an empty array if not. The solution is not necessarily unique.\n\nExample\n\nGiven numbers = [0, 2, 11, 19, 90], sum = 21,  \nBecause numbers[1] + numbers[3] = 2 + 19 = 21,  \nreturn [1, 3].\n\nSource\n\nStack Overflow: Find pair of numbers in array that add to given sum"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Procedural\n\n**Translation of**: zkl\n\n```\nsub two_sum ( @numbers, $sum ) {\n    die '@numbers is not sorted' unless [<=] @numbers;\n\n    my ( $i, $j ) = 0, @numbers.end;\n    while $i < $j {\n        given $sum <=> @numbers[$i,$j].sum {\n            when Order::More { $i += 1 }\n            when Order::Less { $j -= 1 }\n            when Order::Same { return $i, $j }\n        }\n    }\n    return;\n}\n\nsay two_sum ( 0, 2, 11, 19, 90 ), 21;\nsay two_sum ( 0, 2, 11, 19, 90 ), 25;\n\n```\n\nOutput:\n\n```\n(1 3)\nNil\n```\n\n### Functional\n\nThe two versions differ only in how one 'reads' the notional flow of processing: left-to-right versus right-to-left.\nBoth return all pairs that sum to the target value, not just the first (e.g. for input of `0 2 10 11 19 90` would get indices 1/4 and 2/3).\n\n```\nsub two-sum-lr (@a, $sum) {\n  # (((^@a X ^@a) Z=> (@a X+ @a)).grep($sum == *.value)>>.keys.map:{ .split(' ').sort.join(' ')}).unique\n    (\n     (\n      (^@a X ^@a) Z=> (@a X+ @a)\n     ).grep($sum == *.value)>>.keys\n     .map:{ .split(' ').sort.join(' ')}\n    ).unique\n}\n\nsub two-sum-rl (@a, $sum) {\n  # unique map {.split(' ').sort.join(' ')}, keys %(grep {.value == $sum}, ((^@a X ^@a) Z=> (@a X+ @a)))\n    unique\n    map {.split(' ').sort.join(' ')},\n    keys %(\n     grep {.value == $sum}, (\n      (^@a X ^@a) Z=> (@a X+ @a)\n     )\n    )\n}\n\nmy @a = <0 2 11 19 90>;\nfor 21, 25 {\n    say two-sum-rl(@a, $_);\n    say two-sum-lr(@a, $_);\n}\n\n```\n\nOutput:\n\n```\n(1 3)\n(1 3)\n()\n()\n```"}]}
{"messages": [{"role": "user", "content": "Two's complement is an important concept in representing negative numbers. To turn a positive integer negative, flip the bits and add one.\n\nTask\n\nShow how to calculate the two's complement of an integer. (It doesn't necessarily need to be a 32 bit integer.)"}, {"role": "assistant", "content": "By default Rakus integers are arbitrary sized, theoretically of infinite length. You can't really take the twos complement of an infinitely long number; so, we need to specifically use fixed size integers.\n\nThere is a module available from the Raku ecosystem that provides fixed size integer support, named (appropriately enough.) FixedInt.\n\nFixedInt supports fixed bit size integers, not only 8 bit, 16 bit, 32 bit or 64 bit, but *ANY* integer size. 22 bit, 35 bit, 191 bit, whatever.\n\nHere we'll demonstrate twos complement on a 57 bit integer.\n\n```\nuse FixedInt;\n\n# Instantiate a new 57(!) bit fixed size integer\nmy \\fixedint = FixedInt.new: :57bits;\n\nfixedint = (2³⁷ / 72 - 5¹⁷); # Set it to a large value\n\nsay fixedint;     # Echo the value to the console in decimal format\nsay fixedint.bin; # Echo the value to the console in binary format\n\nfixedint.=C2;     # Take the twos complement\n\nsay fixedint;     # Echo the value to the console in decimal format\nsay fixedint.bin; # Echo the value to the console in binary format\n\n```\n\nOutput:\n\n```\n144114427045277101\n0b111111111111111110100111011001111000010101110110110101101\n761030578771\n0b000000000000000001011000100110000111101010001001001010011\n```"}]}
{"messages": [{"role": "user", "content": "This draft task needs a purpose, a description and some way to tell whether examples satisfy or do not satisfy it.\n\nTask\n\nShow a function/procedure that processes a block of text by printing it.\n\nThe function takes one parameter (ideally) that describes the text.\n\nDemonstrate by calling the function twice, each time passing in a different type.\n\nThis can be done with pattern matching, multi-methods, dynamic type detection, structure(s) with a tag, etc.\n\nThe objective is write a [e.g. library] function that processes text from multiple sources (such as a string/char \\*, socket, file, etc).\n\nIf not practical, show how the caller would coerce a type that can be passed to the library function."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\nRaku is a dynamic language that has gradual, duck typing. It provides introspection methods through its comprehensive MOP (Meta Object Protocol) making it easy to do type detection, subroutine signatures and multi-dispatch. Raku types have two general flavors: content types and container types. Different container types have varying restrictions on what sort of content they can contain and in return provide specialized methods to operate on those contents. Content types give the compiler hints on how to best handle the information, what storage requirements it may have, what operators will work with it, etc.\n\nThis is really a very broad and kind of hand-wavey overview of Raku types. For much more in-depth coverage see: https://docs.raku.org/type.html\n\n```\nsub type ($t) { say $t.raku, \"\\tis type: \", $t.WHAT }\n\n# some content types\n.&type for 1, 2.0, 3e0, 4i, π, Inf, NaN, 'String';\n\n# some primitive container types\n.&type for $, [ ], @, { }, %, (5 .. 7), (8 ... 10), /0/, {;}, sub {}, ( );\n\n# undefined things\n.&type for Any, Nil;\n\n# user defined types\nclass my-type { };\n\nmy my-type $object;\n\n$object.&type;\n\n```\n\nOutput:\n\n```\n1\tis type: (Int)\n2.0\tis type: (Rat)\n3e0\tis type: (Num)\n<0+4i>\tis type: (Complex)\n3.14159265358979e0\tis type: (Num)\nInf\tis type: (Num)\nNaN\tis type: (Num)\n\"String\"\tis type: (Str)\nAny\tis type: (Any)\n$[]\tis type: (Array)\n$[]\tis type: (Array)\n{}\tis type: (Hash)\n{}\tis type: (Hash)\n5..7\tis type: (Range)\n(8, 9, 10).Seq\tis type: (Seq)\n/0/\tis type: (Regex)\n-> ;; $_? is raw { #`(Block|61385680) ... }\tis type: (Block)\nsub () { #`(Sub|62948936) ... }\tis type: (Sub)\n$()\tis type: (List)\nAny\tis type: (Any)\nNil\tis type: Nil\nmy-type\tis type: (my-type)\n```"}]}
{"messages": [{"role": "user", "content": "With the following initial conditions:\n\n```\n      u1 = 1 \n      u2 = 2 \n\n```\n\nWe define the    nth    Ulam number    un    as the smallest number that is greater than    un-1      and\n  \nis the unique sum of two different Ulam numbers    ui (<n)    and    uj (<n).\n\nTask\n\nWrite a function to generate the    nth    Ulam number.\n\nReferences\n\n* OEIS Ulam numbers"}, {"role": "assistant", "content": "```\nmy @ulams = 1, 2, &next-ulam … *;\n\nsub next-ulam {\n    state $i = 1;\n    state @sums = 0,1,1;\n    my $last = @ulams[$i];\n    (^$i).map: { @sums[@ulams[$_] + $last]++ };\n    ++$i;\n    quietly ($last ^.. *).first: { @sums[$_] == 1 };\n}\n\nfor 1 .. 4 {\n    say \"The {10**$_}th Ulam number is: \", @ulams[10**$_ - 1]\n}\n\n```\n\nOutput:\n\n```\nThe 10th Ulam number is: 18\nThe 100th Ulam number is: 690\nThe 1000th Ulam number is: 12294\nThe 10000th Ulam number is: 132788\n```"}]}
{"messages": [{"role": "user", "content": "An Ulam spiral (of primes) is a method of visualizing primes when expressed in a (normally counter-clockwise) outward spiral (usually starting at **1**),   constructed on a square grid, starting at the \"center\".\n\nAn Ulam spiral is also known as a   *prime spiral*.\n\nThe first grid (green) is shown with sequential integers,   starting at   **1**.\n\nIn an Ulam spiral of primes, only the primes are shown (usually indicated by some glyph such as a dot or asterisk),   and all non-primes as shown as a blank   (or some other whitespace).\n\nOf course, the grid and border are not to be displayed (but they are displayed here when using these Wiki HTML tables).\n\nNormally, the spiral starts in the \"center\",   and the   2nd   number is to the viewer's right and the number spiral starts from there in a counter-clockwise direction.\n\nThere are other geometric shapes that are used as well, including clock-wise spirals.\n\nAlso, some spirals (for the   2nd   number)   is viewed upwards from the   1st   number instead of to the right, but that is just a matter of orientation.\n\nSometimes, the starting number can be specified to show more visual striking patterns (of prime densities).\n\n[A larger than necessary grid (numbers wise) is shown here to illustrate the pattern of numbers on the diagonals   (which may be used by the method to orientate the direction of spiral-construction algorithm within the example computer programs)].\n\nThen, in the next phase in the transformation of the Ulam prime spiral,   the non-primes are translated to blanks.\n\nIn the orange grid below,   the primes are left intact,   and all non-primes are changed to blanks.\n\nThen, in the final transformation of the Ulam spiral (the yellow grid),   translate the primes to a glyph such as a    **•**    or some other suitable glyph.\n\n|  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| **65** | **64** | **63** | **62** | **61** | **60** | **59** | **58** | **57** |\n| **66** | **37** | **36** | **35** | **34** | **33** | **32** | **31** | **56** |\n| **67** | **38** | **17** | **16** | **15** | **14** | **13** | **30** | **55** |\n| **68** | **39** | **18** | **5** | **4** | **3** | **12** | **29** | **54** |\n| **69** | **40** | **19** | **6** | **1** | **2** | **11** | **28** | **53** |\n| **70** | **41** | **20** | **7** | **8** | **9** | **10** | **27** | **52** |\n| **71** | **42** | **21** | **22** | **23** | **24** | **25** | **26** | **51** |\n| **72** | **43** | **44** | **45** | **46** | **47** | **48** | **49** | **50** |\n| **73** | **74** | **75** | **76** | **77** | **78** | **79** | **80** | **81** |\n\n|  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- |\n|  |  |  |  | **61** |  | **59** |  |  |\n|  | **37** |  |  |  |  |  | **31** |  |\n| **67** |  | **17** |  |  |  | **13** |  |  |\n|  |  |  | **5** |  | **3** |  | **29** |  |\n|  |  | **19** |  |  | **2** | **11** |  | **53** |\n|  | **41** |  | **7** |  |  |  |  |  |\n| **71** |  |  |  | **23** |  |  |  |  |\n|  | **43** |  |  |  | **47** |  |  |  |\n| **73** |  |  |  |  |  | **79** |  |  |\n\n|  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- |\n|  |  |  |  | **•** |  | **•** |  |  |\n|  | **•** |  |  |  |  |  | **•** |  |\n| **•** |  | **•** |  |  |  | **•** |  |  |\n|  |  |  | **•** |  | **•** |  | **•** |  |\n|  |  | **•** |  |  | **•** | **•** |  | **•** |\n|  | **•** |  | **•** |  |  |  |  |  |\n| **•** |  |  |  | **•** |  |  |  |  |\n|  | **•** |  |  |  | **•** |  |  |  |\n| **•** |  |  |  |  |  | **•** |  |  |\n\nThe Ulam spiral becomes more visually obvious as the grid increases in size.\n\nTask\n\nFor any sized   **N × N**   grid,   construct and show an Ulam spiral (counter-clockwise) of primes starting at some specified initial number   (the default would be **1**),   with some suitably   *dotty*   (glyph) representation to indicate primes,   and the absence of dots to indicate non-primes.\n\nYou should demonstrate the generator by showing at Ulam prime spiral large enough to (almost) fill your terminal screen.\n\nRelated tasks\n\n* Spiral matrix\n* Zig-zag matrix\n* Identity matrix\n* Sequence of primes by Trial Division\n\nSee also\n\n* Wikipedia entry:   Ulam spiral\n* MathWorld™ entry:   Prime Spiral"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub MAIN($max = 160, $start = 1) {\n    (my %world){0}{0} = 0;\n    my ($n, $dir, $side, $loc) = $start, 1, 0, 0+0i;\n\n    while ++$side < $max {\n\tstep for ^$side; turn-left;\n\tstep for ^$side; turn-left;\n    }\n\n    braille-graphics %world;\n\n    sub step {\n\t$loc += $dir;\n\t%world{$loc.im}{$loc.re} = $n if (++$n).is-prime;\n    }\n\n    sub turn-left  { $dir ×= -i }\n    sub turn-right { $dir ×=  i }\n}\n\nsub braille-graphics (%a) {\n    my ($y-lo, $y-hi, $x-lo, $x-hi);\n    for %a.keys.map(+*) -> \\y {\n        for %a{y}.keys.map(+*) -> \\x {\n            $y-lo min= y; $y-hi max= y;\n            $x-lo min= x; $x-hi max= x;\n        }\n    }\n\n    for $y-lo, $y-lo + 4 ...^ $y-hi -> \\y {\n\tfor $x-lo, $x-lo + 2 ...^ $x-hi -> \\x {\n\t    my $cell = 0x2800;\n            $cell += 2⁰ if %a{y + 0}{x + 0};\n            $cell += 2¹ if %a{y + 1}{x + 0};\n            $cell += 2² if %a{y + 2}{x + 0};\n            $cell += 2³ if %a{y + 0}{x + 1};\n            $cell += 2⁴ if %a{y + 1}{x + 1};\n            $cell += 2⁵ if %a{y + 2}{x + 1};\n            $cell += 2⁶ if %a{y + 3}{x + 0};\n            $cell += 2⁷ if %a{y + 3}{x + 1};\n            print chr($cell);\n\t}\n\tprint \"\\n\";\n    }\n}\n\n```\n\nOutput:\n\n```\n⠔⠀⠀⠀⢐⠀⠁⠀⠀⠀⢐⠁⠀⢀⠀⠄⠄⠀⢀⠀⠀⠅⢀⠁⢅⢄⠀⢀⠔⠁⠀⠀⠀⢀⢀⠀⠀⠀⠁⢀⢀⠀⠀⢔⠁⢔⠄⠀⢄⠐⠀⠀⢀⠁⠐⠄⠀⢑⠄⠁⠄⠀⠁⠄⠀⠀⠀⢐⠀⠄⠐⠀⢁⢀⠀⠀⠄⠀⢕⠐\n⠄⠁⠁⠄⠀⠄⢀⠀⠐⠀⠀⠁⢁⢀⠐⠀⠀⠀⢁⠐⠄⠀⠀⠔⠀⢐⠁⠄⠀⠑⠀⢀⠁⠀⠐⠐⠁⠀⠄⠀⢀⠀⠀⠀⠐⠀⠐⠀⠅⠀⠀⢄⢀⠐⠁⠐⠄⠁⢀⠀⠀⠐⠁⠀⠀⠄⢄⠀⠕⠁⠀⠐⢄⠀⠀⢀⠐⠄⠁⠀\n⠀⠀⢀⠁⢀⠀⠑⢀⠀⠄⠀⠀⠅⢑⠀⠁⠐⠀⠀⠐⠀⠄⠁⢄⠀⢑⠀⠄⢑⠀⠁⠀⢀⠑⢐⠀⠁⢀⠄⠐⢀⠄⠁⠀⠀⠀⠀⢀⠄⠀⠀⠑⠀⢀⠔⢁⠀⠀⠀⠀⠐⠁⠀⠑⢀⠀⠐⠀⢄⠔⢐⠄⠅⠐⠀⠅⢁⠀⠁⠁\n⠅⢀⠄⠑⠀⠀⠅⠄⠀⢐⠐⠀⠀⠄⠀⢁⠄⠀⢔⢀⠁⠀⠔⠁⠑⢐⠀⠐⠀⠁⢑⠀⠀⢁⠀⠀⠄⠀⠀⠑⢀⠀⠄⠔⠁⠀⠄⠀⠐⢀⠀⠀⠔⠁⠀⠐⠀⠀⠐⠁⠐⠀⠀⢀⠄⠁⢁⠀⠀⠐⠀⠁⢐⠀⠐⠀⠄⠑⠐⠄\n⠀⠀⠀⢐⠑⠑⢀⠁⠑⢀⠐⠀⠄⠀⠀⢀⢐⠕⠄⠀⠀⠀⠐⠀⠀⢀⠄⠀⠀⠀⠄⠐⠐⠀⠀⠁⢄⠐⠅⢀⠐⠄⠁⠐⠀⠅⢀⠐⢁⢀⠀⠁⠐⠕⠀⠀⠀⠀⢐⠀⠅⠐⠔⢁⠀⠐⠅⠐⠄⢀⠀⢄⠀⢀⠄⠀⠀⢀⠁⠐\n⢀⠀⠀⢀⠁⠀⠀⠀⢁⠁⠐⠀⠁⢐⢀⠀⠁⠀⠔⠁⢄⠁⠁⠄⠀⢀⠄⠀⢐⠀⠔⠁⢀⠕⠁⢀⠁⠀⢀⠔⢐⠀⠀⠁⢀⠀⠀⢀⠔⠀⠄⠄⠁⠀⠄⢐⠄⠁⢁⠀⠄⠀⠀⠄⠀⢄⠀⢀⢀⠁⠄⢀⠄⠀⢀⠁⢁⠀⠀⠀\n⠁⠄⠀⠀⠄⠀⠄⠀⠄⠑⢄⠔⠁⠀⠁⠀⠐⠀⠀⠀⠀⠀⢀⠀⠀⠄⠁⢁⠐⠀⠀⢀⠀⠄⠐⠀⢐⠀⠁⠀⠀⠁⠁⠄⠁⢄⠔⠀⠐⠀⠀⠔⢄⠀⠀⢐⠀⢅⠀⠁⢀⠀⠀⠀⠀⠀⠄⠀⠐⠀⠀⠀⠄⠀⠀⠀⠐⠀⠄⠄\n⠀⠑⠐⠔⠀⢀⢀⠀⢁⠔⠁⢁⠄⠁⠀⠀⠀⠅⠀⢀⠀⠁⢀⠀⢄⠀⠀⠀⠐⠀⢀⠐⠁⢀⠀⠀⠀⢀⠁⠀⠐⠀⠄⢀⠔⢁⠀⠀⢅⠐⠑⠅⠀⠐⠀⢀⠁⢄⠀⠀⢁⠐⠄⠀⠐⢕⢀⠁⢀⠁⠑⠅⠀⢁⠐⠀⠁⠀⢁⢐\n⢀⠁⠄⠀⠀⢄⠁⠄⠀⠀⠐⠅⠁⠁⢀⢀⢅⠄⠐⢁⠀⠄⠀⠄⠅⠑⢀⠔⢀⠀⠀⢁⠀⠕⠐⠀⠀⠐⢄⠐⢀⠄⠀⠁⢀⠁⢀⠀⠄⢀⠀⠀⠀⢀⠑⢐⠀⠀⠁⠄⠐⠁⠄⠄⠀⠀⠐⢄⢀⠀⠄⠄⠀⠀⠀⠄⢄⢀⠄⠀\n⠐⠄⠐⠁⠀⠔⠑⠀⠀⠐⠀⠀⠑⠀⠐⠄⠀⠀⠐⠀⠁⢀⠄⠀⠀⢐⠀⠔⠀⠀⢄⠄⠁⢐⠀⠀⢄⠔⠀⢀⢐⠁⠅⢀⠀⠄⠐⠀⢐⠀⠁⢕⠄⠀⠀⢔⠁⠀⢐⠀⢀⠄⠑⠄⠀⠀⠄⠀⠀⠄⠐⠁⠄⠀⠐⠔⠄⠀⠀⠀\n⢀⠐⢀⢐⠀⠀⠄⠑⠑⠐⠐⠀⠔⠑⠀⠐⠀⢀⠀⠀⢀⠄⠀⠁⢄⠀⠁⠀⢀⠁⢀⠀⠀⠀⠐⠄⠁⢐⠔⠅⢐⠅⠀⠀⠅⠀⠀⠀⠁⠀⠔⠄⠀⠔⢀⠀⠄⢁⠐⢁⢀⢁⢀⢀⢁⠄⠁⢀⠀⠀⢁⢑⠀⢀⢐⠁⠀⠀⠀⠁\n⠀⠄⠅⠀⠁⠅⠁⢁⠄⠀⠀⢀⠀⢄⠀⠁⠁⢁⠀⠄⢅⢁⠄⠄⠐⢀⢀⠄⠁⠀⠀⠀⢄⠔⠁⢀⠐⠁⠄⠐⠀⠀⠁⢐⠀⠀⢀⢀⠀⠀⠀⠐⠀⠄⠐⠀⠀⠁⠄⠀⠁⠀⠀⠁⢄⠀⠁⢅⠀⠄⠁⠀⠁⠅⢀⠀⠀⠀⠐⠁\n⠁⠀⠀⠀⠀⠀⠀⢄⠀⠐⢀⠀⠐⠄⠄⠁⠀⠔⠔⠄⠀⠁⠀⠐⠄⢀⠀⠄⠔⠀⠁⠀⠀⢐⢔⠁⠅⠀⠀⢐⠀⠀⠄⠄⠀⠑⠔⠀⠅⢀⠁⠔⢀⠀⢔⠀⠁⠐⠐⠐⢐⠔⠀⠐⠀⠐⠀⠀⠐⢐⠄⠐⠐⠀⠑⢐⠐⠑⠐⠐\n⢀⠁⠁⠀⠀⢑⢀⠀⠑⢀⠀⢀⠀⠀⠁⢔⠀⠀⠀⠀⢀⢀⠁⠁⢄⠀⢁⠀⠀⠐⠁⢀⠐⢁⠐⠐⢁⠐⠀⢄⠐⠅⠀⢐⠄⢁⢀⠐⠄⠐⠐⠀⠀⠔⠀⠑⢔⢀⠑⠀⠀⠐⠑⠀⠀⠐⢀⢀⠑⠀⠐⢀⠀⠁⠐⠁⠀⢁⠀⠀\n⠀⠔⠀⢀⠀⠀⢀⠑⠄⠁⠄⠄⢀⠐⠁⠁⠅⠁⢁⢀⠁⠀⢐⠀⠁⠅⢀⢁⠀⢀⠑⢑⠄⠀⠀⠄⠀⠁⢄⠀⢐⠄⠁⠑⢀⠅⢑⠀⠀⠀⠄⠄⢄⠄⠕⢀⠀⠔⢄⢀⠀⠀⠀⠁⢄⠄⠀⠁⠀⠐⠄⠀⠁⢀⠄⠔⠁⠀⠁⠄\n⠀⠀⠐⠀⠄⠀⠀⢀⠄⠄⢄⠔⠐⢄⠀⠀⠄⠀⠀⠀⠀⠀⢄⠔⠐⠀⠔⠐⠀⠀⠔⠀⠀⢕⢔⠀⠁⢐⠁⢑⠐⠁⠀⠀⠀⢄⠀⠀⢅⠐⠑⠐⠀⠀⢐⠔⠀⠄⠀⠑⢔⠀⠀⠔⠀⠁⢀⠄⠀⠀⠀⠀⠀⠐⠀⠀⠐⠀⠐⠀\n⠄⠐⠀⠄⠀⢀⠐⠀⢀⢐⠀⢀⠄⠀⢐⠀⠀⠀⠀⠐⠐⢄⠀⠀⠔⠀⢀⠀⠀⢐⢔⠀⢀⢄⠀⠄⢀⢀⠐⠁⢐⠅⠅⢀⠑⠄⠐⠐⠀⢀⠀⠁⠁⠑⠀⢁⠅⠀⠁⠄⠀⠁⠀⠀⠁⠁⠁⠐⠑⠁⠁⠀⢀⠐⢀⢀⠀⠁⠀⢀\n⢁⢀⠄⠁⠐⠀⢁⠀⠀⠀⠀⠁⠀⢑⠀⢁⠐⠀⠀⠀⢁⠁⢐⠀⢀⠀⠀⠀⢕⢄⢁⢑⠄⠀⠔⢀⠐⠁⢀⠄⠐⠄⠄⢑⢄⠅⢄⠀⠁⢁⢀⠐⠁⢀⠀⠄⠀⠐⠀⠀⠀⢀⠀⠁⢄⠀⠄⠀⢀⠅⢁⠀⠀⢀⠀⠅⠄⠀⠑⠀\n⠁⠄⠄⠁⠄⠀⠀⠀⠀⠁⠀⠄⠁⠀⠀⠄⠀⠀⠁⠄⠀⠁⠄⠀⠀⠄⠄⠄⠀⠀⠄⠀⠄⠁⠄⠀⠅⠄⠁⢕⢐⠀⢀⠔⠀⠔⠄⠑⠐⠀⠑⢔⠐⠁⠐⠐⠀⢄⠐⠐⠄⠀⠀⠀⠔⠑⠄⠄⠀⠀⠀⠀⢀⠄⠀⠀⠀⠁⢐⠔\n⠐⠀⠑⢐⠁⠀⢐⠑⢁⢀⠐⢀⢐⠑⠁⠀⠀⢀⠀⠁⠑⠀⠑⢐⢀⠑⢐⠀⠁⢑⠀⠑⠐⠐⠐⠑⢐⠑⢑⠄⣔⢅⢁⢁⠐⢀⢁⢅⠁⠐⢐⠀⠀⠄⢀⢐⢅⢁⠀⠀⠀⠀⠐⠁⢁⠔⢀⢑⠁⢁⠐⢀⠀⠀⢄⢀⢁⢅⢀⠀\n⢀⠀⠀⠁⠀⠀⠀⢐⢀⠁⠀⠀⠁⠀⠅⠀⠔⢁⢀⠀⠀⠀⢁⢁⠁⢐⠀⢀⠅⠅⢀⠀⠄⢁⠄⢄⠀⢕⠅⠑⢄⠀⠄⢄⢀⠄⢀⠄⠄⠀⢄⠀⠄⢄⠀⠀⢀⠄⢀⢀⠄⠀⠄⠄⠀⢀⠀⢄⠄⠀⢄⢀⠄⢀⢀⠄⠀⠄⠀⢀\n⠐⢄⠀⠄⠀⠄⠐⠀⠀⠁⢀⠀⠅⠀⠄⠄⠀⠀⠀⢀⠔⠕⠄⠄⠑⠀⠀⠁⠀⠐⠔⢄⠀⠀⢄⠐⠔⢀⠁⢐⢀⠐⠄⠐⠁⠀⠄⠐⠐⠄⠁⠀⠐⠀⠄⠀⠑⠄⠐⠀⠀⠐⠀⠔⠀⠁⠔⠀⠁⠀⠀⠑⠄⠔⠀⠀⠀⠑⠐⠀\n⠀⠀⢀⠄⠐⠀⠀⠀⢀⠄⠀⢑⢀⠁⠐⢀⠑⠀⠔⠐⢁⢐⠀⠐⢀⠀⠑⢐⠀⠀⢀⠐⢐⢔⠐⠄⢀⠁⠁⢐⠑⢄⢄⠑⠀⠁⠐⠐⢁⠐⠑⢁⠑⢀⢀⢀⠐⠁⢐⢐⠀⠐⠐⠀⢀⠑⢁⠁⠀⠀⠀⠑⠀⠁⢐⢀⠑⠀⢀⢀\n⠁⢀⠀⠀⢁⠀⠀⠅⠀⠀⠅⠀⠀⠐⢀⢀⢀⠄⠀⠅⠀⢁⠔⠀⠁⢁⠁⠁⠑⢄⠀⠁⠁⢀⢀⠄⠑⢔⠀⠐⠔⠁⠀⠄⠀⠑⢀⠀⠕⠄⠀⠀⠄⢀⠀⠁⢄⠁⢄⠄⠐⠄⢄⠔⠀⠀⠐⠁⢀⠐⠀⠀⠅⠀⠀⠔⠀⢀⠁⠀\n⠀⢄⠐⠁⠀⠐⠕⠀⠄⠐⠀⠐⠀⢀⠐⠐⠀⠀⠅⠀⠄⠁⢀⠄⠀⠄⠔⠑⢀⠀⠅⠀⠅⠄⠀⠄⠁⢀⠄⠀⢀⠀⢁⢀⠕⠀⠀⠑⠀⠐⠀⢄⠐⠁⢄⠄⠁⠐⠄⠐⢀⠀⠁⠄⠔⠀⢄⠀⠁⠄⠔⠁⢐⠄⠐⠀⠀⠑⢀⠔\n⢀⠐⢀⠀⠀⠐⠄⠁⠐⠄⠐⠀⢀⠑⠁⠄⠀⠁⠐⠀⢀⠀⠁⢀⠀⠐⠐⠔⠁⢀⠀⠑⠀⠀⠐⠀⢔⠑⠀⢐⠀⢁⢀⠐⠀⢀⠐⢀⠄⠁⢄⠁⠀⠀⠁⠀⠀⠀⢐⢀⢁⢑⠀⢀⠑⠐⠁⠀⢀⢀⠀⠁⢀⢀⠀⠀⠐⢀⠀⠐\n⢀⢁⠀⠀⢑⢅⢁⢄⢀⢀⠅⠀⠀⠄⢀⢁⢐⢁⢀⢅⢄⠀⠀⢀⢀⠐⠅⠁⠀⠀⢁⠐⠀⢀⠀⠀⠐⢀⠀⢀⠄⠅⠐⢐⠀⠀⠔⠁⠑⠐⠄⠀⠄⠀⠅⠁⠄⠐⠀⠀⠁⠁⠀⠄⠅⠀⠀⠄⠄⠅⠀⠄⠀⠄⠀⠁⠀⠀⠔⠀\n⠁⠀⠀⠁⠀⠀⠀⢀⠄⠀⠀⠀⠀⠄⠄⠀⢀⠀⠐⢀⠀⠀⢄⠔⠄⠀⠄⠀⠀⠔⠕⢀⠔⠀⠀⠄⠄⠀⠁⠐⠀⠀⠕⢀⠕⠁⠀⠁⢑⠀⠀⢀⢀⠐⠄⠀⠑⠀⠀⠁⢄⠔⠑⢐⠀⠑⢄⠐⠀⠀⠐⠀⠀⠀⠀⠀⠄⠁⢀⠄\n⠀⠁⠐⠀⠁⠀⠄⠀⠑⠀⠀⢀⠀⠐⠀⠄⠀⠑⠀⠀⢐⠀⠁⢅⠀⠀⠀⠐⠀⢀⠄⠀⢁⢄⠀⠁⠔⠑⠄⠀⠑⢄⠔⠁⢀⠀⠀⢄⠄⠀⠀⠐⠁⠁⢀⠐⠄⠀⠁⠐⠁⢀⢑⠁⠐⠐⢀⠑⠔⠀⠁⠀⢁⢀⠄⠁⢐⠀⠀⠀\n⠀⠅⠁⢀⠐⠀⠁⠐⠀⠁⠐⢄⠀⢄⢀⠀⠄⢀⠁⢁⠄⠀⠐⠀⢑⠄⠀⠑⠐⠀⠁⠀⠁⠐⠐⠀⠁⠄⠄⢀⠄⠁⠐⢀⠄⠐⠀⠄⠀⠄⠀⠀⢀⠄⢀⢐⠀⠑⠀⠀⠄⢄⢄⠀⢅⠀⠀⠄⠀⠅⠀⠄⠐⢀⠀⠔⠅⠀⠄⢁\n⠄⠀⠄⠄⠀⠄⠀⢀⠀⠐⠀⠀⠁⠀⠔⠄⠀⠀⠁⠀⠄⢄⠀⠐⠀⠀⠄⢑⠀⠁⠅⠀⠁⠀⢀⠄⠑⢀⠄⢀⢀⠔⢀⠀⠑⠄⠀⠅⠀⠀⠅⢕⠀⠐⢐⠀⠄⠕⠀⠀⢀⠀⠀⢀⠀⠁⠀⠀⠐⢀⠐⠁⢀⠔⠁⢐⠀⠀⠐⠀\n⠀⠐⢁⢀⠐⠀⢀⠁⠀⠀⠁⠑⠄⠀⢁⠐⠁⠅⢀⠐⢀⠄⠀⠀⠐⠀⠅⢀⠐⢀⢀⠁⠅⢀⠀⠄⠔⠑⠁⠀⠁⠀⠐⠁⢀⠀⠀⢀⠀⠐⠄⠔⠐⠁⢄⠀⠅⢄⠑⠀⢀⠐⠀⠀⢁⢀⠀⢀⠁⢀⠁⠅⠁⠀⠁⠀⠀⠄⠀⠁\n⠀⠀⢀⠀⠄⢁⠀⠀⠄⠀⢁⢁⠀⠀⠀⠐⠀⠄⠀⠐⠀⢀⢀⠁⠁⠄⠄⢀⠀⠀⠑⢀⠀⠑⠐⠁⠀⠀⠁⢐⠄⠀⢀⠐⠄⠐⢀⠁⠑⢀⠀⠀⠐⠀⢑⠄⠀⠁⠀⠅⠐⠄⠀⠀⠄⠀⠄⠁⠀⠄⢁⢀⠁⠁⠄⠀⠀⠀⠀⢄\n⠑⠀⠀⠀⢀⠀⠁⠄⠐⠀⠀⠄⢄⠀⠐⠐⠀⠑⢁⠀⠔⠀⠀⠀⠀⠀⠕⢄⠀⠐⠀⢀⠔⠅⢀⠀⠐⠀⠅⢐⠀⠕⠐⢀⠀⠔⠀⠅⠀⠀⠀⠄⢀⠁⢀⠀⠀⠔⠀⠐⠁⢀⠀⠁⢀⠁⠀⠐⠐⠄⠐⠐⠄⠀⠀⠀⠀⠀⠔⠐\n⠐⠀⢐⠀⠀⠀⢀⠀⠐⠐⠀⠀⠐⠀⠄⢀⠁⢄⠀⠑⢀⠀⠐⢀⢄⠀⠀⢀⠀⢅⢔⠁⠄⠐⠀⠁⠀⠑⠀⠀⠐⠁⠄⠀⢁⢀⠀⠁⠐⠁⠀⠀⠀⠀⠀⠀⠀⠀⠐⢀⠄⠀⢀⢔⠑⢅⠀⠐⢄⠁⢀⠄⢁⢀⠐⠀⠀⢀⢀⢑\n⠀⠄⠅⢀⠁⠀⠀⠅⠁⠀⢄⠀⠁⠐⠁⢀⠀⠀⠀⠀⠀⠑⠀⠄⢀⠀⠀⢀⠐⠀⠀⢀⠁⠐⢀⠄⠁⢔⠄⠀⠄⠄⠑⠄⠁⠀⠀⠁⠐⠐⠄⠁⢄⠀⢀⠄⠁⠀⠔⠁⢀⠐⠄⠀⠀⠀⢁⢐⠀⠀⠄⠀⠀⢀⠀⠅⠀⠀⠀⠀\n⠔⠀⠄⠀⢀⠄⠁⢀⠁⠄⠀⠀⠑⠀⠐⠁⠀⠐⠑⢀⠄⠄⠀⠀⢄⠀⠔⠔⢀⠀⠁⠀⠔⠀⢀⠄⠀⠀⠁⢐⠀⠑⠀⠀⠀⢅⠀⠀⢀⠀⠁⠄⠀⠁⢀⠀⠔⠐⠀⠀⢅⠀⠐⢀⠀⠀⠄⢀⠐⠔⠀⠁⠄⠀⠁⠀⠔⠐⠀⠀\n⠀⠐⢀⠐⠀⠁⢀⠀⠀⠐⠐⢀⢄⠐⢄⠐⠀⠅⠀⠁⠁⠄⠐⢁⠄⠀⠀⢄⠀⠅⠔⠀⢁⠀⠐⠄⢀⠀⠁⠀⠐⠀⢀⠑⢀⠄⠀⠅⠀⠀⠅⠀⠀⢀⢔⠐⠄⠀⠁⠀⠐⠀⠀⢀⠑⠀⠄⠐⢁⢀⠀⢄⢄⠁⢀⠀⢐⠐⠁⠁\n⠁⠄⠄⠀⠀⠁⠀⢐⠀⠐⠀⠄⢑⠀⠀⠑⠄⠁⢁⢀⠀⢑⠔⠁⠀⠄⠄⠀⢀⠀⠑⠔⠁⢁⠀⠄⢁⠔⠀⢀⠔⠀⢐⠀⠀⠀⠄⠄⠀⠐⠁⢁⠔⠁⠐⠐⠁⢀⢀⠀⠁⠔⠀⠀⠀⠅⠁⠀⠄⠀⠔⠁⢑⠀⠀⠀⠀⠀⠐⠀\n⠁⠀⠅⠐⠀⠁⠀⠀⠐⠁⠀⠀⠕⠀⠀⠅⠀⠐⠀⠀⠕⠁⠀⠄⠅⠀⠀⠐⠀⠐⠅⠀⠀⠄⠀⠀⠀⠀⠀⠐⠀⠀⠀⠀⠁⠀⠀⠀⠄⠀⠐⠁⠀⠄⠁⠀⠁⠄⠀⠐⠄⠀⠅⠀⠀⠔⠁⠀⠀⠕⠀⠀⠀⠀⠀⠁⠀⠁⠀⠀\n\n```"}]}
{"messages": [{"role": "user", "content": "An **ultra-useful prime** is a member of the sequence where each **a(n)** is the smallest positive integer **k** such that **2(2n) - k** is prime.\n\n***k** must always be an odd number since 2 to any power is always even.*\n\nTask\n\n* Find and show here, on this page, the first **10** elements of the sequence.\n\nStretch\n\n* Find and show the next several elements. (The numbers get really big really fast. Only nineteen elements have been identified as of this writing.)\n\nSee also\n\n* OEIS:A058220 - Ultra-useful primes: smallest k such that 2^(2^n) - k is prime"}, {"role": "assistant", "content": "The first 10 take less than a quarter second. 11 through 13, a little under 30 seconds. Drops off a cliff after that.\n\n```\nsub useful ($n) {\n    (|$n).map: {\n        my $p = 1 +< ( 1 +< $_ );\n        ^$p .first: ($p - *).is-prime\n    }\n}\n\nput useful 1..10;\n\nput useful 11..13;\n\n```\n\nOutput:\n\n```\n1 3 5 15 5 59 159 189 569 105\n1557 2549 2439\n```"}]}
{"messages": [{"role": "user", "content": "Given a weighted one-bit generator of random numbers where the probability of a one occurring,\n\nP\n\n1\n{\\displaystyle {\\displaystyle P\\_{1}}}\n\n, is not the same as\n\nP\n\n0\n{\\displaystyle {\\displaystyle P\\_{0}}}\n\n, the probability of a zero occurring, the probability of the occurrence of a one followed by a zero is\n\nP\n\n1\n{\\displaystyle {\\displaystyle P\\_{1}}}\n\n×\n\nP\n\n0\n{\\displaystyle {\\displaystyle P\\_{0}}}\n\n, assuming independence. This is the same as the probability of a zero followed by a one:\n\nP\n\n0\n{\\displaystyle {\\displaystyle P\\_{0}}}\n\n×\n\nP\n\n1\n{\\displaystyle {\\displaystyle P\\_{1}}}\n\n.\n\nTask details\n\n* Use your language's random number generator to create a function/method/subroutine/... **randN** that returns a one or a zero, but with one occurring, on average, 1 out of N times, where N is an integer from the range 3 to 6 inclusive.\n* Create a function **unbiased** that uses only randN as its source of randomness to become an unbiased generator of random ones and zeroes.\n* For N over its range, generate and show counts of the outputs of randN and unbiased(randN).\n\nThe actual unbiasing should be done by generating two numbers at a time from randN and only returning a 1 or 0 if they are different. As long as you always return the first number or always return the second number, the probabilities discussed above should take over the biased probability of randN.\n\nThis task is an implementation of Von Neumann debiasing, first described in a 1951 paper."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n**Works with**: Rakudo version 2020.08.1\n\n```\nsub randN ( $n where 3..6 ) {\n    return ( $n.rand / ($n - 1) ).Int;\n}\n\nsub unbiased ( $n where 3..6 ) {\n    my $n1;\n    repeat { $n1 = randN($n) } until $n1 != randN($n);\n    return $n1;\n}\n\nmy $iterations = 1000;\nfor 3 .. 6 -> $n {\n    my ( @raw, @fixed );\n    for ^$iterations {\n        @raw[      randN($n) ]++;\n        @fixed[ unbiased($n) ]++;\n    }\n    printf \"N=%d   randN: %s, %4.1f%%   unbiased: %s, %4.1f%%\\n\",\n        $n, map { .raku, .[1] * 100 / $iterations }, @raw, @fixed;\n}\n\n```\n\nOutput:\n\n```\nN=3   randN: [676, 324], 32.4%   unbiased: [517, 483], 48.3%\nN=4   randN: [734, 266], 26.6%   unbiased: [489, 511], 51.1%\nN=5   randN: [792, 208], 20.8%   unbiased: [494, 506], 50.6%\nN=6   randN: [834, 166], 16.6%   unbiased: [514, 486], 48.6%\n```"}]}
{"messages": [{"role": "user", "content": "For languages which have an explicit notion of an undefined value, identify and exercise those language's mechanisms for identifying and manipulating a variable's value's status as being undefined."}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku has \"interesting\" values of undef, but unlike Perl 5, doesn't actually have a value named undef. Instead, several very different meanings of undefinedness are distinguished. First, Nil represents the absence of a value. The absence of a value cannot be stored. Instead, an attempt to assign Nil to a storage location causes that location to revert to its uninitialized state, however that is defined.\n\n```\nmy $x; $x = 42; $x = Nil; say $x.WHAT; # prints Any()\n\n```\n\nThis Any is an example of another kind of undefined type, which is a typed undef. All reference types have an undefined value representing the type. You can think of it as a sort of \"type gluon\" that carries a type charge without being a \"real\" particle. Hence there are undefined values whose names represent types, such as Int, Num, Str, and all the other object types in Raku. As generic objects, such undefined values carry the same metaobject pointer that a real object of the type would have, without being instantiated as a real object. As such, these types are in the type hierarchy. For example, Int derives from Cool, Cool derives from Any, and Any derives from Mu, the most general undefined object (akin to Object in other languages). Since they are real objects of the type, even if undefined, they can be used in reasoning about the type. You don't have to instantiate a Method object in order to ask if Method is derived from Routine, for instance.\n\n```\nsay Method ~~ Routine;  # Bool::True\n\n```\n\nVariables default to Any, unless declared to be of another type:\n\n```\nmy     $x; say $x.WHAT; # Any()\nmy Int $y; say $y.WHAT; # Int()\nmy Str $z; say $z.WHAT; # Str()\n\n```\n\nThe user-interface for definedness are type smilies and the with-statement.\n\n```\nmy Int:D $i = 1; # if $i has to be defined you must provide a default value\nmulti sub foo(Int:D $i where * != 0){ (0..100).roll / $i } # we will never divide by 0\nmulti sub foo(Int:U $i){ die 'WELP! $i is undefined' } # because undefinedness is deadly\n\nwith $i { say 'defined' } # as \"if\" is looking for Bool::True, \"with\" is looking for *.defined\nwith 0 { say '0 may not divide but it is defined' }\n\n```\n\nThere are further some operators for your convenience.\n\n```\nmy $is-defined = 1;\nmy $ain't-defined = Any;\nmy $doesn't-matter;\nmy Any:D $will-be-defined = $ain't-defined // $is-defined // $doesn't-matter;\n\nmy @a-mixed-list = Any, 1, Any, 'a';\n$will-be-defined = [//] @a-mixed-list; # [//] will return the first defined value\n\nmy @a = Any,Any,1,1;\nmy @b = 2,Any,Any,2;\nmy @may-contain-any = @a >>//<< @b; # contains: [2, Any, 1, 1]\n\nsub f1(){Failure.new('WELP!')};\nsub f2(){ $_ ~~ Failure }; # orelse will kindly set the topic for us\nmy $s = (f1() orelse f2()); # Please note the parentheses, which are needed because orelse is\n                            # much looser then infix:<=> .\ndd $s; # this be Bool::False\n\n```\n\nFinally, another major group of undefined values represents failures. Raku is designed with the notion that throwing exceptions is bad for parallel processing, so exceptions are thrown lazily; that is, they tend to be returned in-band instead as data, and are only thrown for real if not properly handled as exception data. (In which case, the exception is required to report the original difficulty accurately.) In order not to disrupt control flow and the synchronicity of event ordering, such failures are returned in-band as a normal values. And in order not to subvert the type system when it comes to return types, failure may be mixed into any reference type which produces an undefined, typed value which is also indicates the nature of the failure.\n\nNative storage types work under different rules, since most native types cannot represent failure, or even undefinedness. Any attempt to assign a value to a storage location that cannot represent a failure will cause an exception to be thrown."}]}
{"messages": [{"role": "user", "content": "An **Undulating number** in some base is a number which has the digit form ABABAB... where A and B are digits in that base.\n\nFor the purposes of this task, we shall only consider a number to be undulating if it has at least 3 digits in a given base and A != B.\n\nExamples\n\nThe numbers: 101 and 9898 are undulating numbers in base 10.\n\nThe numbers: 50 and 2350 are undulating numbers in base 7 because their base 7 representations are: 101 and 6565 respectively.\n\nTask\n\nFor base 10, find and show on this page:\n\n1. All three digit undulating numbers.\n\n2. All four digit undulating numbers.\n\n3. All three digit undulating numbers which are primes.\n\n4. The 600th undulating number.\n\n5. How many undulating numbers are less than 2^53 and the largest such number.\n\nBonus\n\nDo the same for base 7 expressing the results in base 10 apart from 4. and 5. which should be expressed in base 7 also.\n\nNote that undulating numbers with a given number of digits in base 7 may, of course, have less digits when expressed in base 10 and are unlikely to be still undulating. However, 121 (or 232 in base 7) is an exception to this.\n\nReferences\n\n* Wikipedia article : Undulating number\n* OEIS sequence A046075: Non-trivial undulants"}, {"role": "assistant", "content": "**Translation of**: Wren\n\n```\n# 20230602 Raku programming solution\n\nsub undulating ($base, \\n) {\n   my \\limit = 2**(my \\mpow = 53) - 1;\n   my (\\bsquare,@u3,@u4) = $base*$base; \n   for 1..^$base X 0..^$base -> (\\a,\\b) {\n      next if b == a;\n      @u3.push(a * bsquare + b * $base + a);\n      @u4.push((my \\v = a * $base + b) * bsquare + v)\n   }\n   say \"\\nAll 3 digit undulating numbers in base $base:\";\n   .fmt('%3d').say for @u3.rotor: 9;\n   say \"\\nAll 4 digit undulating numbers in base $base:\";\n   .fmt('%4d').say for @u4.rotor: 9; \n   say \"\\nAll 3 digit undulating numbers which are primes in base $base:\";\n   my @primes = @u3.grep: *.is-prime; \n    .fmt('%3d').say for @primes.rotor: 10, :partial;\n   my \\unc = (my @un = @u3.append: @u4).elems;\n   my ($j, $done) = 0, False;\n   loop {\n      for 0..^unc {\n         my  \\u = @un[$j * unc + $_] * bsquare + @un[$j * unc + $_] % bsquare;\n\t u > limit ?? ( $done = True and last ) !! ( @un.push: u );\n      }\n      $done ?? ( last ) !! $j++ \n   }\n   say \"\\nThe {n} undulating number in $base $base is: @un[n-1]\";\n   say \"or expressed in base $base : {@un[n-1].base($base)}\" unless $base == 10;\n   say \"\\nTotal number of undulating numbers in base $base < 2**{mpow} = {+@un}\";\n   say \"of which the largest is: \", @un[*-1];\n   say \"or expressed in base $base : {@un[*-1].base($base)}\" unless $base == 10;\n}\n\nundulating $_, 600 for 10, 7;\n\n```\n\nYou may Try it online!"}]}
{"messages": [{"role": "user", "content": "Within a string, an escape sequence gives special meaning to otherwise ordinary characters.\n\nFor example, in the C programming language, the string literal `\"a\\nb\"`, containing the escape sequence `\\n`, would be interpreted by the compiler as the bytes `61 0a 62`, not `61 5c 6e 62`.\n\nIn JavaScript Object Notation, the string value `\"a\\u263Ac\"`, containing the escape sequence `\\u263A`, would be parsed into `\"a☺c\"`.\n\nTask\n\nWrite a function (or routine, subroutine, procedure, etc.) that, when given a UTF-8 encoded string, returns a new string, also encoded in UTF-8, with all escape sequences replaced with equivalent Unicode code points.\n\nFor this task we'll follow JSON string semantics, defined in Section 7 of RFC 8259. In summary:\n\n* Allowed two-character escapes are `\\\\`, `\\\"`, `\\/`, `\\b`, `\\f`, `\\n`, `\\r`, `\\t`.\n* `\"`, `\\` and control characters (U+0000 through U+001F) must be escaped.\n* Any \"character\" in the Basic Multilingual Plane may be escaped with a `\\uXXXX` sequence, where `XXXX` are hexadecimal digits encoding the character's code point\n* Characters outside the Basic Multilingual Plane may be escaped with a `\\uXXXX\\uXXXX` sequence, where `XXXX` are hexadecimal digits encoding the code point using UTF-16.\n\nAlthough not required by RFC 8259, we'll treat strings containing invalid `\\u` escape sequences (those that can't be decoded to a Unicode code point) as an error condition.\n\nTest your program with the following inputs and display the string before and after unescaping. It's OK to display bytes rather than \"characters\" if it's more convenient for your language, or both, if you prefer.\n\nTest cases\n\n| Input string | Expected result | Comment |\n| --- | --- | --- |\n| `abc` | `abc` | No escape sequences |\n| `a☺c` | `a☺c` | No escape sequences, extended unicode |\n| `a\\\"c` | `a\"c` | Two-character escape |\n| `\\u0061\\u0062\\u0063` | `abc` | Just escape sequences |\n| `a\\\\c` | `a\\c` | Two-character escape for reverse solidus |\n| `a\\u263Ac` | `a☺c` | `\\u` escape, basic multilingual plane |\n| `a\\\\u263Ac` | `a\\u263Ac` | Escaped `\\` before `u` |\n| `a\\uD834\\uDD1Ec` | `a𝄞c` | `\\u` escape, surrogate pair |\n| `a\\ud834\\udd1ec` | `a𝄞c` | Lower case hex digits |\n| `a\\u263` | *error* | Incomplete escape sequence |\n| `a\\u263Xc` | *error* | Invalid hexadecimal digit |\n| `a\\uDD1Ec` | *error* | Lone low surrogate |\n| `a\\uD834c` | *error* | Lone high surrogate |\n| `a\\uD834\\u263Ac` | *error* | High surrogate followed by non-surrogate |\n\nRelated tasks\n\n* Literals/String\n* Special characters\n* UTF-8 encode and decode"}, {"role": "assistant", "content": "Implement a JSON string unescape Grammar.\n\n```\n# 20240816 Raku programming solution\n\ngrammar JSON-Unescape {\n   token TOP             { ^ <value> $ }\n   token value           { [ <str> | \\\\ <str=.str_escape> ]* }\n   token str             { <-[\"\\\\\\t\\x[0A]]>+ }\n   token str_escape      { <[\"\\\\/bfnrt]> | 'u' <utf16_codepoint>+ % '\\u' }\n   token utf16_codepoint { <.xdigit>**4 }\n}\n\nclass JSON-Unescape-Actions {\n   method        TOP($/) { make $<value>.made }\n   method        str($/) { make ~$/ }\n   method      value($/) { make $<str>».made.join }\n   method str_escape($/) {\n      make $<utf16_codepoint>.Bool \n         ?? utf16.new( $<utf16_codepoint>.map({:16(~$_)}) ).decode()\n         !! %(< \\\\ / b n t f r \" > Z=> < \\\\ / \\b \\n \\t \\f \\r \" >).{~$/}\n   }\n}\n\nfor < abc  a☺c  a\\\"c \\u0061\\u0062\\u0063 a\\\\\\c   a\\u263Ac  a\\\\\\u263Ac\n      a\\uD834\\uDD1Ec a\\ud834\\udd1ec     a\"c     a\\\\u263   a\\\\u263Xc \n      a\\\\uDD1Ec      a\\\\uD834c          a\\\\uD834\\\\u263Ac > -> $input {\n   printf \"%20s => \", $input;\n   my $o = JSON-Unescape.parse($input, actions => JSON-Unescape-Actions.new).made;\n   fail \"Invalid JSON string\" unless $o.defined;\n   say $o;\n   CATCH { default { say \"Error: $_\" } }\n}\n\n```\n\nYou may Attempt This Online!\n\nOutput:\n\n```\n                 abc => abc\n                 a☺c => a☺c\n                a\\\"c => a\"c\n  \\u0061\\u0062\\u0063 => abc\n                a\\\\c => a\\c\n            a\\u263Ac => a☺c\n           a\\\\u263Ac => a\\u263Ac\n      a\\uD834\\uDD1Ec => a𝄞c\n      a\\ud834\\udd1ec => a𝄞c\n                 a\"c => Error: Invalid JSON string\n              a\\u263 => Error: Invalid JSON string\n            a\\u263Xc => Error: Invalid JSON string\n            a\\uDD1Ec => Error: Malformed UTF-16; unexpected low surrogate\n            a\\uD834c => Error: Malformed UTF-16; incomplete surrogate pair\n      a\\uD834\\u263Ac => Error: Malformed UTF-16; incomplete surrogate pair\n```"}]}
{"messages": [{"role": "user", "content": "As the world gets smaller each day, internationalization becomes more and more important.   For handling multiple languages, Unicode is your best friend.\n\nIt is a very capable and remarquable tool, but also quite complex compared to older single- and double-byte character encodings.\n\nHow well prepared is your programming language for Unicode?\n\nTask\n\nDiscuss and demonstrate its unicode awareness and capabilities.\n\nSome suggested topics:\n\n:   * How easy is it to present Unicode strings in source code?\n    * Can Unicode literals be written directly, or be part of identifiers/keywords/etc?\n    * How well can the language communicate with the rest of the world?\n    * Is it good at input/output with Unicode?\n    * Is it convenient to manipulate Unicode strings in the language?\n    * How broad/deep does the language support Unicode?\n    * What encodings (e.g. UTF-8, UTF-16, etc) can be used?\n    * Does it support normalization?\n\nNote\n\nThis task is a bit unusual in that it encourages general discussion rather than clever coding.\n\nSee also\n\n* Unicode variable names\n* Terminal control/Display an extended character"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nRaku programs and strings are all in Unicode and operate at a grapheme abstraction level, which is agnostic to underlying encodings. (These are generally handled at program boundaries.) Opened files default to UTF-8 encoding. All Unicode character properties are in play, so any appropriate characters may be used as parts of identifiers, whitespace, or user-defined operators. For instance:\n\n```\nsub prefix:<∛> (\\𝐕) { 𝐕 ** ⅓ }\nsay ∛27;  # prints 3\n\n```\n\nNon-Unicode strings are represented as Buf types rather than Str types, and Unicode operations may not be applied to Buf types without some kind of explicit conversion. Only ASCIIish operations are allowed on buffers.\n\nRaku tracks the Unicode consortium standards releases and is generally up to the latest standard within a few months or so of its release. (currently at 15.0 as of February 2023)\n\n* Supports the normalized forms NFC, NFD, NFKC, and NFKD, and character equivalence as specified in Unicode technical report #15.\n* Built-in routines provide access to character classifications (Letter, Numeric. White-space, etc) and sub-classifications: (Letter-lowercase, Letter-uppercase, Numeric-digit, etc.)\n* Allows users to use any Unicode character that has a Numeric property **as** that numeric value.\n* Provides Unicode aware upper-case, lower-case and fold-case routines.\n* Implements the Unicode technical standard #10 collation algorithm, (though not all optional mappings are supported yet).\n* Provides built-in routines to access character names, do name-to-character character-to-ordinal and ordinal-to-character conversions.\n* Works seamlessly with upper plane and private use plane character codepoints.\n* Provides tools to deal with strings that contain invalid Unicode characters.\n\nIn general, it tries to make dealing with Unicode \"just work\".\n\nRaku intends to support Unicode even better than Perl 5, which already does a great job in recent versions of accessing large swaths of Unicode spec. functionality. Raku improves on Perl 5 primarily by offering explicitly typed strings that always know which operations are sensical and which are not.\n\nA very important distinctive characteristic of Raku to keep in mind is that it applies normalization (Unicode NFC form (Normalization Form Canonical)) automatically by default to all strings as showcased and explained on the String comparison page."}]}
{"messages": [{"role": "user", "content": "Task\n\n1. Describe, and give a pointer to documentation on your languages use of characters *beyond* those of the ASCII character set in the naming of variables.\n2. Show how to:\n\n:   * Set a variable with a name including the 'Δ', (delta *character*), to 1\n    * Increment it\n    * Print its value.\n\nRelated task\n\n* Case-sensitivity of identifiers"}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku is written in Unicode so, with narrow restrictions, nearly any Unicode letter can be used in identifiers.\n\nSee the current Raku documentation on the topic here: https://docs.raku.org/language/syntax#Identifiers\n\n```\nmy $Δ = 1;\n$Δ++;\nsay $Δ;\n\n```\n\nFunction and subroutine names can also use Unicode characters: (as can methods, classes, packages, whatever...)\n\n```\nmy @ᐁ = (0, 45, 60, 90);\n\nsub π { pi };\n\nsub postfix:<°>($degrees) { $degrees * π / 180 };\n\nfor @ᐁ -> $ಠ_ಠ { say sin $ಠ_ಠ° };\n\nsub c͓͈̃͂̋̈̆̽h̥̪͕ͣ͛̊aͨͣ̍͞ơ̱͔̖͖̑̽ș̻̥ͬ̃̈ͩ { 'HE COMES' }\n\n```\n\n**See Also:**  \nEgyptian division"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a list of strings,   find characters appearing only in one string and once only.\n\nThe result should be given in alphabetical order.\n\nUse the following list for this task:\n\n```\n        [\"133252abcdeeffd\",  \"a6789798st\",  \"yxcdfgxcyz\"]\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "One has to wonder where the digits 0 through 9 come in the alphabet... 🤔 For that matter, What alphabet should they be in order of? Most of these entries seem to presuppose ASCII order but that isn't specified anywhere. What to do with characters outside of ASCII (or Latin-1)? Unicode ordinal order? Or maybe DUCET Unicode collation order? It's all very vague.\n\n```\nmy @list = <133252abcdeeffd a6789798st yxcdfgxcyz>;\n\nfor @list, (@list, 'AАΑSäaoö٥🤔👨‍👩‍👧‍👧') {\n    say \"$_\\nSemi-bogus \\\"Unicode natural sort\\\" order: \",\n    .map( *.comb ).Bag.grep( *.value == 1 )».key.sort( { .unival, .NFKD[0], .fc } ).join,\n    \"\\n        (DUCET) Unicode collation order: \",\n    .map( *.comb ).Bag.grep( *.value == 1 )».key.collate.join, \"\\n\";\n}\n\n```\n\nOutput:\n\n```\n133252abcdeeffd a6789798st yxcdfgxcyz\nSemi-bogus \"Unicode natural sort\" order: 156bgstz\n        (DUCET) Unicode collation order: 156bgstz\n\n133252abcdeeffd a6789798st yxcdfgxcyz AАΑSäaoö٥🤔👨‍👩‍👧‍👧\nSemi-bogus \"Unicode natural sort\" order: 15٥6ASäbgoöstzΑА👨‍👩‍👧‍👧🤔\n        (DUCET) Unicode collation order: 👨‍👩‍👧‍👧🤔ä15٥6AbögosStzΑА\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a list of strings, find the characters appearing exactly once in each string.\n\nThe result should be in alphabetical order.\n\nUse the following list for this task:\n\n```\n        [\"1a3c52debeffd\", \"2b6178c97a938stf\", \"3ycxdb1fgxa2yz\"]\n\n```\n\nFor this list, the result would be:\n1 2 3 a b c\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nmy $strings = <1a3c52debeffd 2b6178c97a938stf 3ycxdb1fgxa2yz>;\n\nput sort keys [∩] $strings.map: *.comb.Bag.grep: *.value == 1\n\n```\n\nOutput:\n\n```\n1 2 3 a b c\n```"}]}
{"messages": [{"role": "user", "content": "Demonstrate any support for Unit testing built into the language implementation.\n\nSee https://en.wikipedia.org/wiki/Unit\\_testing and Test a function for more information.\n\nClearly state whether this support is internal, or external to the interpreter or compiler used."}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku does not really have a mechanism built into the compiler to do unit testing, (It **does** have design-by-contract capabilities built in, but that is more for run-time, not really for unit testing.) Raku, and Perl in general **does** have unit testing built into the community. The Test-Anything-Protocol was invented and developed specifically to do unit testing on the original version of Perl, is still heavily used for modern versions, and has become a major standard for unit testing in many different languages other than Perl.\n\nTesting is such a basic value in Raku, that a suite of unit tests **is** the language specification. As decreed by Larry Wall, the original author of Perl and the lead designer of Raku, anything that can pass \"roast\", the official Raku test suite, or at least majority portions of it, can call itself Raku.\n\nUnit testing tools are not built in to the base compiler. Basic tools are distributed with the compiler as loadable modules. Many more complex toolkits and test harnesses are available through the Raku ecosystem. In general, it is uncommon to include testing code in with run-time code; not unheard-of and not forbidden, but uncommon. Instead Raku modules by convention and community pressure tend to have a test suite that is automatically run when the module is installed. Again, there is no rule that a module that is released for public consumption **must** have a test suite, but the community tends to favour modules that have them and discourage/avoid those without."}]}
{"messages": [{"role": "user", "content": "One of the foundational mathematical constructs behind computer science\nis the universal Turing Machine.\n\n(Alan Turing introduced the idea of such a machine in 1936–1937.)\n\nIndeed one way to definitively prove that a language\nis turing-complete\nis to implement a universal Turing machine in it.\n\nTask\n\nSimulate such a machine capable\nof taking the definition of any other Turing machine and executing it.\n\nOf course, you will not have an infinite tape,\nbut you should emulate this as much as is possible.\n\nThe three permissible actions on the tape are \"left\", \"right\" and \"stay\".\n\nTo test your universal Turing machine (and prove your programming language\nis Turing complete!), you should execute the following two Turing machines\nbased on the following definitions.\n\n**Simple incrementer**\n\n* **States:** q0, qf\n* **Initial state:** q0\n* **Terminating states:** qf\n* **Permissible symbols:** B, 1\n* **Blank symbol:** B\n* **Rules:**\n  + (q0, 1, 1, right, q0)\n  + (q0, B, 1, stay, qf)\n\nThe input for this machine should be a tape of `1 1 1`\n\n**Three-state busy beaver**\n\n* **States:** a, b, c, halt\n* **Initial state:** a\n* **Terminating states:** halt\n* **Permissible symbols:** 0, 1\n* **Blank symbol:** 0\n* **Rules:**\n  + (a, 0, 1, right, b)\n  + (a, 1, 1, left, c)\n  + (b, 0, 1, left, a)\n  + (b, 1, 1, right, b)\n  + (c, 0, 1, left, b)\n  + (c, 1, 1, stay, halt)\n\nThe input for this machine should be an empty tape.\n\n**Bonus:**\n\n**5-state, 2-symbol probable Busy Beaver machine from Wikipedia**\n\n* **States:** A, B, C, D, E, H\n* **Initial state:** A\n* **Terminating states:** H\n* **Permissible symbols:** 0, 1\n* **Blank symbol:** 0\n* **Rules:**\n  + (A, 0, 1, right, B)\n  + (A, 1, 1, left, C)\n  + (B, 0, 1, right, C)\n  + (B, 1, 1, right, B)\n  + (C, 0, 1, right, D)\n  + (C, 1, 0, left, E)\n  + (D, 0, 1, left, A)\n  + (D, 1, 1, left, D)\n  + (E, 0, 1, stay, H)\n  + (E, 1, 0, left, A)\n\nThe input for this machine should be an empty tape.\n\nThis machine runs for more than 47 millions steps."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n**Works with**: Rakudo version 2018.03\n\n```\nsub run_utm(:$state! is copy, :$blank!, :@rules!, :@tape = [$blank], :$halt, :$pos is copy = 0) {\n    $pos += @tape if $pos < 0;\n    die \"Bad initial position\" unless $pos ~~ ^@tape;\n\nSTEP: loop {\n        print \"$state\\t\";\n        for ^@tape {\n            my $v = @tape[$_];\n            print $_ == $pos ?? \"[$v]\" !! \" $v \";\n        }\n        print \"\\n\";\n\n        last if $state eq $halt;\n\n        for @rules -> @rule {\n            my ($s0, $v0, $v1, $dir, $s1) = @rule;\n            next unless $s0 eq $state and @tape[$pos] eq $v0;\n\n            @tape[$pos] = $v1;\n\n            given $dir {\n                when 'left' {\n                    if $pos == 0 { unshift @tape, $blank }\n                    else { $pos-- }\n                }\n                when 'right' {\n                    push @tape, $blank if ++$pos >= @tape;\n                }\n            }\n\n            $state = $s1;\n            next STEP;\n\n        }\n        die 'No matching rules';\n    }\n\n}\n\nsay \"incr machine\";\nrun_utm\t:halt<qf>,\n    :state<q0>,\n    :tape[1,1,1],\n    :blank<B>,\n    :rules[\n        [< q0 1 1 right q0 >],\n        [< q0 B 1 stay  qf >]\n    ];\n\nsay \"\\nbusy beaver\";\nrun_utm :halt<halt>,\n    :state<a>,\n    :blank<0>,\n    :rules[\n        [< a 0 1 right b >],\n        [< a 1 1 left  c >],\n        [< b 0 1 left  a >],\n        [< b 1 1 right b >],\n        [< c 0 1 left  b >],\n        [< c 1 1 stay  halt >]\n    ];\n\nsay \"\\nsorting test\";\nrun_utm :halt<STOP>,\n    :state<A>,\n    :blank<0>,\n    :tape[< 2 2 2 1 2 2 1 2 1 2 1 2 1 2 >],\n    :rules[\n        [< A 1 1 right A >],\n        [< A 2 3 right B >],\n        [< A 0 0 left  E >],\n        [< B 1 1 right B >],\n        [< B 2 2 right B >],\n        [< B 0 0 left  C >],\n        [< C 1 2 left  D >],\n        [< C 2 2 left  C >],\n        [< C 3 2 left  E >],\n        [< D 1 1 left  D >],\n        [< D 2 2 left  D >],\n        [< D 3 1 right A >],\n        [< E 1 1 left  E >],\n        [< E 0 0 right STOP >]\n    ];\n\n```\n\nOutput:\n\n```\nincr machine\nq0\t[1] 1  1\nq0\t 1 [1] 1\nq0\t 1  1 [1]\nq0\t 1  1  1 [B]\nqf\t 1  1  1 [1]\n\nbusy beaver\na\t[0]\nb\t 1 [0]\na\t[1] 1\nc\t[0] 1  1\nb\t[0] 1  1  1\na\t[0] 1  1  1  1\nb\t 1 [1] 1  1  1\nb\t 1  1 [1] 1  1\nb\t 1  1  1 [1] 1\nb\t 1  1  1  1 [1]\nb\t 1  1  1  1  1 [0]\na\t 1  1  1  1 [1] 1\nc\t 1  1  1 [1] 1  1\nhalt\t 1  1  1 [1] 1  1\n\nsorting test\nA\t[2] 2  2  1  2  2  1  2  1  2  1  2  1  2\nB\t 3 [2] 2  1  2  2  1  2  1  2  1  2  1  2\nB\t 3  2 [2] 1  2  2  1  2  1  2  1  2  1  2\nB\t 3  2  2 [1] 2  2  1  2  1  2  1  2  1  2\nB\t 3  2  2  1 [2] 2  1  2  1  2  1  2  1  2\nB\t 3  2  2  1  2 [2] 1  2  1  2  1  2  1  2\nB\t 3  2  2  1  2  2 [1] 2  1  2  1  2  1  2\nB\t 3  2  2  1  2  2  1 [2] 1  2  1  2  1  2\nB\t 3  2  2  1  2  2  1  2 [1] 2  1  2  1  2\nB\t 3  2  2  1  2  2  1  2  1 [2] 1  2  1  2\nB\t 3  2  2  1  2  2  1  2  1  2 [1] 2  1  2\nB\t 3  2  2  1  2  2  1  2  1  2  1 [2] 1  2\nB\t 3  2  2  1  2  2  1  2  1  2  1  2 [1] 2\nB\t 3  2  2  1  2  2  1  2  1  2  1  2  1 [2]\nB\t 3  2  2  1  2  2  1  2  1  2  1  2  1  2 [0]\nC\t 3  2  2  1  2  2  1  2  1  2  1  2  1 [2] 0\nC\t 3  2  2  1  2  2  1  2  1  2  1  2 [1] 2  0\nD\t 3  2  2  1  2  2  1  2  1  2  1 [2] 2  2  0\nD\t 3  2  2  1  2  2  1  2  1  2 [1] 2  2  2  0\nD\t 3  2  2  1  2  2  1  2  1 [2] 1  2  2  2  0\nD\t 3  2  2  1  2  2  1  2 [1] 2  1  2  2  2  0\nD\t 3  2  2  1  2  2  1 [2] 1  2  1  2  2  2  0\nD\t 3  2  2  1  2  2 [1] 2  1  2  1  2  2  2  0\nD\t 3  2  2  1  2 [2] 1  2  1  2  1  2  2  2  0\nD\t 3  2  2  1 [2] 2  1  2  1  2  1  2  2  2  0\nD\t 3  2  2 [1] 2  2  1  2  1  2  1  2  2  2  0\nD\t 3  2 [2] 1  2  2  1  2  1  2  1  2  2  2  0\nD\t 3 [2] 2  1  2  2  1  2  1  2  1  2  2  2  0\nD\t[3] 2  2  1  2  2  1  2  1  2  1  2  2  2  0\nA\t 1 [2] 2  1  2  2  1  2  1  2  1  2  2  2  0\nB\t 1  3 [2] 1  2  2  1  2  1  2  1  2  2  2  0\nB\t 1  3  2 [1] 2  2  1  2  1  2  1  2  2  2  0\nB\t 1  3  2  1 [2] 2  1  2  1  2  1  2  2  2  0\nB\t 1  3  2  1  2 [2] 1  2  1  2  1  2  2  2  0\nB\t 1  3  2  1  2  2 [1] 2  1  2  1  2  2  2  0\nB\t 1  3  2  1  2  2  1 [2] 1  2  1  2  2  2  0\nB\t 1  3  2  1  2  2  1  2 [1] 2  1  2  2  2  0\nB\t 1  3  2  1  2  2  1  2  1 [2] 1  2  2  2  0\nB\t 1  3  2  1  2  2  1  2  1  2 [1] 2  2  2  0\nB\t 1  3  2  1  2  2  1  2  1  2  1 [2] 2  2  0\nB\t 1  3  2  1  2  2  1  2  1  2  1  2 [2] 2  0\nB\t 1  3  2  1  2  2  1  2  1  2  1  2  2 [2] 0\nB\t 1  3  2  1  2  2  1  2  1  2  1  2  2  2 [0]\nC\t 1  3  2  1  2  2  1  2  1  2  1  2  2 [2] 0\nC\t 1  3  2  1  2  2  1  2  1  2  1  2 [2] 2  0\nC\t 1  3  2  1  2  2  1  2  1  2  1 [2] 2  2  0\nC\t 1  3  2  1  2  2  1  2  1  2 [1] 2  2  2  0\nD\t 1  3  2  1  2  2  1  2  1 [2] 2  2  2  2  0\nD\t 1  3  2  1  2  2  1  2 [1] 2  2  2  2  2  0\nD\t 1  3  2  1  2  2  1 [2] 1  2  2  2  2  2  0\nD\t 1  3  2  1  2  2 [1] 2  1  2  2  2  2  2  0\nD\t 1  3  2  1  2 [2] 1  2  1  2  2  2  2  2  0\nD\t 1  3  2  1 [2] 2  1  2  1  2  2  2  2  2  0\nD\t 1  3  2 [1] 2  2  1  2  1  2  2  2  2  2  0\nD\t 1  3 [2] 1  2  2  1  2  1  2  2  2  2  2  0\nD\t 1 [3] 2  1  2  2  1  2  1  2  2  2  2  2  0\nA\t 1  1 [2] 1  2  2  1  2  1  2  2  2  2  2  0\nB\t 1  1  3 [1] 2  2  1  2  1  2  2  2  2  2  0\nB\t 1  1  3  1 [2] 2  1  2  1  2  2  2  2  2  0\nB\t 1  1  3  1  2 [2] 1  2  1  2  2  2  2  2  0\nB\t 1  1  3  1  2  2 [1] 2  1  2  2  2  2  2  0\nB\t 1  1  3  1  2  2  1 [2] 1  2  2  2  2  2  0\nB\t 1  1  3  1  2  2  1  2 [1] 2  2  2  2  2  0\nB\t 1  1  3  1  2  2  1  2  1 [2] 2  2  2  2  0\nB\t 1  1  3  1  2  2  1  2  1  2 [2] 2  2  2  0\nB\t 1  1  3  1  2  2  1  2  1  2  2 [2] 2  2  0\nB\t 1  1  3  1  2  2  1  2  1  2  2  2 [2] 2  0\nB\t 1  1  3  1  2  2  1  2  1  2  2  2  2 [2] 0\nB\t 1  1  3  1  2  2  1  2  1  2  2  2  2  2 [0]\nC\t 1  1  3  1  2  2  1  2  1  2  2  2  2 [2] 0\nC\t 1  1  3  1  2  2  1  2  1  2  2  2 [2] 2  0\nC\t 1  1  3  1  2  2  1  2  1  2  2 [2] 2  2  0\nC\t 1  1  3  1  2  2  1  2  1  2 [2] 2  2  2  0\nC\t 1  1  3  1  2  2  1  2  1 [2] 2  2  2  2  0\nC\t 1  1  3  1  2  2  1  2 [1] 2  2  2  2  2  0\nD\t 1  1  3  1  2  2  1 [2] 2  2  2  2  2  2  0\nD\t 1  1  3  1  2  2 [1] 2  2  2  2  2  2  2  0\nD\t 1  1  3  1  2 [2] 1  2  2  2  2  2  2  2  0\nD\t 1  1  3  1 [2] 2  1  2  2  2  2  2  2  2  0\nD\t 1  1  3 [1] 2  2  1  2  2  2  2  2  2  2  0\nD\t 1  1 [3] 1  2  2  1  2  2  2  2  2  2  2  0\nA\t 1  1  1 [1] 2  2  1  2  2  2  2  2  2  2  0\nA\t 1  1  1  1 [2] 2  1  2  2  2  2  2  2  2  0\nB\t 1  1  1  1  3 [2] 1  2  2  2  2  2  2  2  0\nB\t 1  1  1  1  3  2 [1] 2  2  2  2  2  2  2  0\nB\t 1  1  1  1  3  2  1 [2] 2  2  2  2  2  2  0\nB\t 1  1  1  1  3  2  1  2 [2] 2  2  2  2  2  0\nB\t 1  1  1  1  3  2  1  2  2 [2] 2  2  2  2  0\nB\t 1  1  1  1  3  2  1  2  2  2 [2] 2  2  2  0\nB\t 1  1  1  1  3  2  1  2  2  2  2 [2] 2  2  0\nB\t 1  1  1  1  3  2  1  2  2  2  2  2 [2] 2  0\nB\t 1  1  1  1  3  2  1  2  2  2  2  2  2 [2] 0\nB\t 1  1  1  1  3  2  1  2  2  2  2  2  2  2 [0]\nC\t 1  1  1  1  3  2  1  2  2  2  2  2  2 [2] 0\nC\t 1  1  1  1  3  2  1  2  2  2  2  2 [2] 2  0\nC\t 1  1  1  1  3  2  1  2  2  2  2 [2] 2  2  0\nC\t 1  1  1  1  3  2  1  2  2  2 [2] 2  2  2  0\nC\t 1  1  1  1  3  2  1  2  2 [2] 2  2  2  2  0\nC\t 1  1  1  1  3  2  1  2 [2] 2  2  2  2  2  0\nC\t 1  1  1  1  3  2  1 [2] 2  2  2  2  2  2  0\nC\t 1  1  1  1  3  2 [1] 2  2  2  2  2  2  2  0\nD\t 1  1  1  1  3 [2] 2  2  2  2  2  2  2  2  0\nD\t 1  1  1  1 [3] 2  2  2  2  2  2  2  2  2  0\nA\t 1  1  1  1  1 [2] 2  2  2  2  2  2  2  2  0\nB\t 1  1  1  1  1  3 [2] 2  2  2  2  2  2  2  0\nB\t 1  1  1  1  1  3  2 [2] 2  2  2  2  2  2  0\nB\t 1  1  1  1  1  3  2  2 [2] 2  2  2  2  2  0\nB\t 1  1  1  1  1  3  2  2  2 [2] 2  2  2  2  0\nB\t 1  1  1  1  1  3  2  2  2  2 [2] 2  2  2  0\nB\t 1  1  1  1  1  3  2  2  2  2  2 [2] 2  2  0\nB\t 1  1  1  1  1  3  2  2  2  2  2  2 [2] 2  0\nB\t 1  1  1  1  1  3  2  2  2  2  2  2  2 [2] 0\nB\t 1  1  1  1  1  3  2  2  2  2  2  2  2  2 [0]\nC\t 1  1  1  1  1  3  2  2  2  2  2  2  2 [2] 0\nC\t 1  1  1  1  1  3  2  2  2  2  2  2 [2] 2  0\nC\t 1  1  1  1  1  3  2  2  2  2  2 [2] 2  2  0\nC\t 1  1  1  1  1  3  2  2  2  2 [2] 2  2  2  0\nC\t 1  1  1  1  1  3  2  2  2 [2] 2  2  2  2  0\nC\t 1  1  1  1  1  3  2  2 [2] 2  2  2  2  2  0\nC\t 1  1  1  1  1  3  2 [2] 2  2  2  2  2  2  0\nC\t 1  1  1  1  1  3 [2] 2  2  2  2  2  2  2  0\nC\t 1  1  1  1  1 [3] 2  2  2  2  2  2  2  2  0\nE\t 1  1  1  1 [1] 2  2  2  2  2  2  2  2  2  0\nE\t 1  1  1 [1] 1  2  2  2  2  2  2  2  2  2  0\nE\t 1  1 [1] 1  1  2  2  2  2  2  2  2  2  2  0\nE\t 1 [1] 1  1  1  2  2  2  2  2  2  2  2  2  0\nE\t[1] 1  1  1  1  2  2  2  2  2  2  2  2  2  0\nE\t[0] 1  1  1  1  1  2  2  2  2  2  2  2  2  2  0\nSTOP\t 0 [1] 1  1  1  1  2  2  2  2  2  2  2  2  2  0\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a program that will list everything in the current folder,   similar to:\n\n:   :   :   * the Unix utility   “ls”   [1]       or\n            * the Windows terminal command   “DIR”\n\nThe output must be sorted, but printing extended details and producing multi-column output is not required.\n\nExample output\n\nFor the list of paths:\n\n```\n/foo/bar\n/foo/bar/1\n/foo/bar/2\n/foo/bar/a\n/foo/bar/b\n\n```\n\nWhen the program is executed in   `/foo`,   it should print:\n\n```\nbar\n\n```\n\nand when the program is executed in   `/foo/bar`,   it should print:\n\n```\n1\n2\na\nb\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThere is a dir builtin command which returns a list of IO::Path objects. We stringify them all with a hyperoperator before sorting the strings.\n\n```\n.say for sort ~«dir\n\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nAs used here, all unprimeable numbers   (positive integers)   are always expressed in base ten.\n\n───── Definition from OEIS ─────:\n  \nUnprimeable numbers are composite numbers that always remain composite when a single decimal digit of the number is changed.\n\n───── Definition from Wiktionary   (referenced from Adam Spencer's book) ─────:\n  \n(*arithmetic*)   that cannot be turned into a prime number by changing just one of its digits to any other\ndigit.   (sic)\n\n**Unprimeable** numbers are also spelled:   **unprimable**.\n\nAll one─ and two─digit numbers can be turned into primes by changing a single decimal digit.\n\nExamples\n\n**190**   isn't unprimeable,   because by changing the zero digit into a three yields   **193**,   which is a prime.\n\nThe number   **200**   is unprimeable,   since none of the numbers   **201, 202, 203, ··· 209**   are\nprime, and all the other numbers obtained by changing a single digit to\nproduce   **100, 300, 400, ··· 900**,   or   **210, 220, 230, ··· 290**   which are all even.\n\nIt is valid to change   **189**   into   **089**   by changing the   **1**   (one)   into\na   **0**   (zero),   which then the leading zero can be removed,   and then treated as if\nthe   \"new\"   number is   **89**.\n\nTask\n:   :   * show the first   **35**   unprimeable numbers   (horizontally, on one line, preferably with a title)\n        * show the   **600th**   unprimeable number\n        * (optional) show the lowest unprimeable number ending in a specific decimal digit   (**0, 1, 2, 3, 4, 5, 6, 7, 8, 9**)\n        * (optional) use commas in the numbers where appropriate\n\nShow all output here, on this page.\n\nAlso see\n:   * the     OEIS     entry:   A118118 (unprimeable)\n    * with some useful counts to compare unprimeable number\n    * the Wiktionary entry (reference from below):   (arithmetic definition) unprimeable\n    * from the Adam Spencer book   (page 200):   *Adam Spencer's World of Numbers*       (Xoum Publishing)"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Library:** ntheory\n\n```\nuse ntheory:from<Perl5> <is_prime>;\nuse Lingua::EN::Numbers;\n\nsub is-unprimeable (\\n) {\n     return False if n.&is_prime;\n     my \\chrs = n.chars;\n     for ^chrs -> \\place {\n         my \\pow = 10**(chrs - place - 1);\n         my \\this = n.substr(place, 1) × pow;\n         ^10 .map: -> \\dgt {\n             next if this == dgt;\n             return False if is_prime(n - this + dgt × pow)\n         }\n     }\n     True\n}\n\nmy @ups = lazy ^∞ .grep: { .&is-unprimeable };\n\nsay \"First 35 unprimeables:\\n\" ~ @ups[^35];\n\nsay \"\\n{ordinal-digit(600, :u)} unprimeable: \" ~ comma( @ups[599] ) ~ \"\\n\";\n\n^10 .map: -> \\n {\n    print \"First unprimeable that ends with {n}: \" ~\n    sprintf \"%9s\\n\", comma (n, *+10 … *).race.first: { .&is-unprimeable }\n}\n\n```\n\nOutput:\n\n```\nFirst 35 unprimeables:\n200 204 206 208 320 322 324 325 326 328 510 512 514 515 516 518 530 532 534 535 536 538 620 622 624 625 626 628 840 842 844 845 846 848 890\n\n600ᵗʰ unprimeable: 5,242\n\nFirst unprimeable that ends with 0:       200\nFirst unprimeable that ends with 1:   595,631\nFirst unprimeable that ends with 2:       322\nFirst unprimeable that ends with 3: 1,203,623\nFirst unprimeable that ends with 4:       204\nFirst unprimeable that ends with 5:       325\nFirst unprimeable that ends with 6:       206\nFirst unprimeable that ends with 7:   872,897\nFirst unprimeable that ends with 8:       208\nFirst unprimeable that ends with 9:   212,159\n```"}]}
{"messages": [{"role": "user", "content": "Definitions\n:   * *Untouchable numbers*   are also known as   *nonaliquot numbers*.\n\n:   * An   untouchable number   is a positive integer that cannot be expressed as the sum of all the proper divisors of any positive integer.   (From Wikipedia)\n\n:   * The   *sum of all the proper divisors*   is also known as   the   *aliquot sum*.\n\n:   * An   untouchable   are those numbers that are not in the image of the aliquot sum function.   (From Wikipedia)\n\n:   * Untouchable numbers:   impossible values for the sum of all aliquot parts function.   (From OEIS:   The On-line Encyclopedia of Integer Sequences®)\n\n:   * An untouchable number is a positive integer that is not the sum of the proper divisors of any number.   (From MathWorld™)\n\nObservations and conjectures\n\nAll untouchable numbers   >  **5**  are composite numbers.\n\nNo untouchable number is perfect.\n\nNo untouchable number is sociable.\n\nNo untouchable number is a Mersenne prime.\n\nNo untouchable number is   one more   than a prime number,   since if   **p**   is prime,   then\nthe sum of the proper divisors of   **p2**   is  **p + 1**.\n\nNo untouchable number is   three more   than an odd prime number,   since if   **p**   is an odd prime,   then the\nsum of the proper divisors of   **2p**   is  **p + 3**.\n\nThe number  **5**  is believed to be the only odd untouchable number,   but this has not been proven:   it would follow from a\nslightly stronger version of the   Goldbach's conjecture,   since the sum of the\nproper divisors of   **pq**   (with   **p**, **q**   being\ndistinct primes)   is   **1 + p + q**.\n\nThere are infinitely many untouchable numbers,   a fact that was proven\nby   Paul Erdős.\n\nAccording to Chen & Zhao,   their natural density is at least   **d > 0.06**.\n\nTask\n:   * show  (in a grid format)  all untouchable numbers  ≤  2,000.\n    * show (for the above)   the   *count*   of untouchable numbers.\n    * show the   *count*   of untouchable numbers from unity up to   (inclusive):\n\n    :   :   :   * 10\n                * 100\n                * 1,000\n                * 10,000\n                * 100,000\n                * ... or as high as is you think is practical.\n\n    * all output is to be shown here, on this page.\n\nSee also\n:   * Wolfram MathWorld:   untouchable number.\n    * OEIS:   A005114 untouchable numbers.\n    * OEIS:   a list of all untouchable numbers below 100,000   (inclusive).\n    * Wikipedia: untouchable number.\n    * Wikipedia: Goldbach's conjecture."}, {"role": "assistant", "content": "Borrow the proper divisors routine from here.\n\n**Translation of**: Wren\n\n```\n# 20210220 Raku programming solution\n\nsub propdiv (\\x) {\n   my @l = 1 if x > 1;\n   (2 .. x.sqrt.floor).map: -> \\d {\n      unless x % d { @l.push: d; my \\y = x div d; @l.push: y if y != d }\n   }\n   @l\n}\n\nsub sieve (\\n) {\n   my %s;\n   for (0..(n+1)) -> \\k {\n      given ( [+] propdiv k ) { %s{$_} = True if $_ ≤ (n+1) }\n   }\n   %s;\n}\n\nmy \\limit = 1e5;\nmy %c = ( grep { !.is-prime }, 1..limit ).Set; # store composites\nmy %s = sieve(14 * limit);\nmy @untouchable = 2, 5;\n\nloop ( my \\n = $ = 6 ; n ≤ limit ; n += 2 ) {\n   @untouchable.append(n) if (!%s{n} && %c{n-1} && %c{n-3})\n}\n\nmy ($c, $last) = 0, False;  \nfor @untouchable.rotor(10) { \n   say [~] @_».&{$c++ ; $_ > 2000 ?? ( $last = True and last ) !! .fmt: \"%6d \"}\n   $c-- and last if $last\n}\n\nsay \"\\nList of untouchable numbers ≤ 2,000 : $c \\n\"; \n\nmy ($p, $count) = 10,0;\nBREAK: for @untouchable -> \\n {\n   $count++;\n   if (n > $p) {\n      printf \"%6d untouchable numbers were found  ≤ %7d\\n\", $count-1, $p;\n      last BREAK if limit == ($p *= 10)\n   }\n}\nprintf \"%6d untouchable numbers were found  ≤ %7d\\n\", +@untouchable, limit\n\n```\n\nOutput:\n\n```\n     2      5     52     88     96    120    124    146    162    188\n   206    210    216    238    246    248    262    268    276    288\n   290    292    304    306    322    324    326    336    342    372\n   406    408    426    430    448    472    474    498    516    518\n   520    530    540    552    556    562    576    584    612    624\n   626    628    658    668    670    708    714    718    726    732\n   738    748    750    756    766    768    782    784    792    802\n   804    818    836    848    852    872    892    894    896    898\n   902    926    934    936    964    966    976    982    996   1002\n  1028   1044   1046   1060   1068   1074   1078   1080   1102   1116\n  1128   1134   1146   1148   1150   1160   1162   1168   1180   1186\n  1192   1200   1212   1222   1236   1246   1248   1254   1256   1258\n  1266   1272   1288   1296   1312   1314   1316   1318   1326   1332\n  1342   1346   1348   1360   1380   1388   1398   1404   1406   1418\n  1420   1422   1438   1476   1506   1508   1510   1522   1528   1538\n  1542   1566   1578   1588   1596   1632   1642   1650   1680   1682\n  1692   1716   1718   1728   1732   1746   1758   1766   1774   1776\n  1806   1816   1820   1822   1830   1838   1840   1842   1844   1852\n  1860   1866   1884   1888   1894   1896   1920   1922   1944   1956\n  1958   1960   1962   1972   1986   1992\n\nList of untouchable numbers ≤ 2,000 : 196\n\n     2 untouchable numbers were found  ≤      10\n     5 untouchable numbers were found  ≤     100\n    89 untouchable numbers were found  ≤    1000\n  1212 untouchable numbers were found  ≤   10000\n 13863 untouchable numbers were found  ≤  100000\n\n```"}]}
{"messages": [{"role": "user", "content": "Sometimes it is useful to run code with inputs from untrusted users, untrusted code, etc. Explain and demonstrate the features your language uses for dealing with untrusted input and untrusted code. Explain possible compromises, weaknesses and exploits that may be available through the language (for example forcing execution of something outside of the application) as a result of using untrusted data sources.\n\nThe intention is that the definition is to be interpreted broadly; different languages will solve this task in very different ways and with (generally) incomparable results."}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku doesn't really provide a high security mode for untrusted environments. By default, Raku is sort of a walled garden. It is difficult to access memory directly, especially in locations not controlled by the Raku interpreter, so unauthorized memory access is unlikely to be a threat with default Raku commands and capabilities.\n\nIt is possible (and quite easy) to run Raku with a restricted setting which will disable many IO commands that can be used to access or modify things outside of the Raku interpreter. However, a determined bad actor could theoretically work around the restrictions, especially if the nativecall interface is available. The nativecall interface allows directly calling in to and executing code from C libraries so anything possible in C is now possible in Raku. This is great for all of the power it provides, but along with that comes the responsibility and inherent security risk.\n\nReally, if you want to lock down a Raku instance so it is \"safe\" for unauthenticated, untrusted, general access, you are better off running it in some kind of locked down virtual machine or sandbox managed by the operating system rather than trying to build an ad hoc \"safe\" environment."}]}
{"messages": [{"role": "user", "content": "Goal\n\nConvert UPC bar codes to decimal.\n\nSpecifically:\n\nThe UPC standard is actually a collection of standards -- physical standards, data format standards, product reference standards...\n\nHere,   in this task,   we will focus on some of the data format standards,   with an imaginary physical+electrical implementation which converts physical UPC bar codes to ASCII   (with spaces and   **#**   characters representing the presence or absence of ink).\n\nSample input\n\nBelow, we have a representation of ten different UPC-A bar codes read by our imaginary bar code reader:\n\n```\n         # #   # ##  #  ## #   ## ### ## ### ## #### # # # ## ##  #   #  ##  ## ###  # ##  ## ### #  # #       \n        # # #   ##   ## # #### #   # ## #   ## #   ## # # # ###  # ###  ##  ## ###  # #  ### ###  # # #         \n         # #    # # #  ###  #   #    # #  #   #    # # # # ## #   ## #   ## #   ##   # # #### ### ## # #         \n       # # ##  ## ##  ##   #  #   #  # ###  # ##  ## # # #   ## ##  #  ### ## ## #   # #### ## #   # #        \n         # # ### ## #   ## ## ###  ##  # ##   #   # ## # # ### #  ## ##  #    # ### #  ## ##  #      # #          \n          # #  #   # ##  ##  #   #   #  # ##  ##  #   # # # # #### #  ##  # #### #### # #  ##  # #### # #         \n         # #  #  ##  ##  # #   ## ##   # ### ## ##   # # # #  #   #   #  #  ### # #    ###  # #  #   # #        \n        # # #    # ##  ##   #  # ##  ##  ### #   #  # # # ### ## ## ### ## ### ### ## #  ##  ### ## # #         \n         # # ### ##   ## # # #### #   ## # #### # #### # # #   #  # ###  #    # ###  # #    # ###  # # #       \n        # # # #### ##   # #### # #   ## ## ### #### # # # #  ### # ###  ###  # # ###  #    # #  ### # #         \n\n```\n\nSome of these were entered upside down,   and one entry has a timing error.\n\nTask\n\nImplement code to find the corresponding decimal representation of each, rejecting the error.\n\nExtra credit for handling the rows entered upside down   (the other option is to reject them).\n\nNotes\n\nEach digit is represented by 7 bits:\n\n```\n    0:  0 0 0 1 1 0 1\n    1:  0 0 1 1 0 0 1\n    2:  0 0 1 0 0 1 1\n    3:  0 1 1 1 1 0 1\n    4:  0 1 0 0 0 1 1\n    5:  0 1 1 0 0 0 1\n    6:  0 1 0 1 1 1 1\n    7:  0 1 1 1 0 1 1\n    8:  0 1 1 0 1 1 1\n    9:  0 0 0 1 0 1 1\n\n```\n\nOn the left hand side of the bar code a space represents a **0** and a **#** represents a **1**.\n  \nOn the right hand side of the bar code, a **#** represents a **0** and a space represents a **1**\n  \nAlternatively (for the above):   spaces always represent zeros and **#** characters always represent ones, but the representation is logically negated -- **1**s and **0**s are flipped -- on the right hand side of the bar code.\n\nThe UPC-A bar code structure\n:   :   * It begins with at least 9 spaces   (which our imaginary bar code reader unfortunately doesn't always reproduce properly),\n        * then has a      **# #**      sequence marking the start of the sequence,\n        * then has the six \"left hand\" digits,\n        * then has a    **# #**    sequence in the middle,\n        * then has the six \"right hand digits\",\n        * then has another    **# #**    (end sequence),   and finally,\n        * then ends with nine trailing spaces   (which might be eaten by wiki edits, and in any event, were not quite captured correctly by our imaginary bar code reader).\n\nFinally, the last digit is a checksum digit which may be used to help detect errors.\n\nVerification\n\nMultiply each digit in the represented 12 digit sequence by the corresponding number in   (3,1,3,1,3,1,3,1,3,1,3,1)   and add the products.\n\nThe sum (mod 10) must be **0**   (must have a zero as its last digit)   if the UPC number has been read correctly."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub decode_UPC ( Str $line ) {\n    constant @patterns1 = '   ## #', '  ##  #', '  #  ##', ' #### #', ' #   ##',\n                          ' ##   #', ' # ####', ' ### ##', ' ## ###', '   # ##';\n    constant @patterns2 = @patterns1».trans( '#' => ' ', ' ' => '#' );\n\n    constant %pattern_to_digit_1 = @patterns1.antipairs;\n    constant %pattern_to_digit_2 = @patterns2.antipairs;\n\n    constant $re = / ^  '# #'  (@patterns1) ** 6\n                       ' # # ' (@patterns2) ** 6\n                        '# #'                     $ /;\n\n    $line.trim ~~ $re\n        orelse return;\n\n    my @digits = flat %pattern_to_digit_1{ $0».Str },\n                      %pattern_to_digit_2{ $1».Str };\n\n    return unless ( @digits Z* ( |(3,1) xx * ) ).sum %% 10;\n\n    return @digits.join;\n}\n\nmy @lines =\n    '         # #   # ##  #  ## #   ## ### ## ### ## #### # # # ## ##  #   #  ##  ## ###  # ##  ## ### #  # #       ',\n     '        # # #   ##   ## # #### #   # ## #   ## #   ## # # # ###  # ###  ##  ## ###  # #  ### ###  # # #      ',\n    '         # #    # # #  ###  #   #    # #  #   #    # # # # ## #   ## #   ## #   ##   # # #### ### ## # #       ',\n      '       # # ##  ## ##  ##   #  #   #  # ###  # ##  ## # # #   ## ##  #  ### ## ## #   # #### ## #   # #        ',\n    '         # # ### ## #   ## ## ###  ##  # ##   #   # ## # # ### #  ## ##  #    # ### #  ## ##  #      # #       ',\n   '          # #  #   # ##  ##  #   #   #  # ##  ##  #   # # # # #### #  ##  # #### #### # #  ##  # #### # #    ',\n    '         # #  #  ##  ##  # #   ## ##   # ### ## ##   # # # #  #   #   #  #  ### # #    ###  # #  #   # #     ',\n     '        # # #    # ##  ##   #  # ##  ##  ### #   #  # # # ### ## ## ### ## ### ### ## #  ##  ### ## # #      ',\n    '         # # ### ##   ## # # #### #   ## # #### # #### # # #   #  # ###  #    # ###  # #    # ###  # # #       ',\n     '        # # # #### ##   # #### # #   ## ## ### #### # # # #  ### # ###  ###  # # ###  #    # #  ### # #      ',\n;\nfor @lines -> $line {\n    say decode_UPC($line)\n     // decode_UPC($line.flip)\n     // 'Invalid';\n}\n\n```\n\nOutput:\n\n```\n924773271019\n403944441050\n834999676706\n939825158811\nInvalid\n316313718717\n214575875608\n818778841813\n706466743030\n653483540435\n```"}]}
{"messages": [{"role": "user", "content": "We have a configuration file as follows:\n\n```\n# This is a configuration file in standard configuration file format\n#\n# Lines begininning with a hash or a semicolon are ignored by the application\n# program. Blank lines are also ignored by the application program.\n\n# The first word on each non comment line is the configuration option.\n# Remaining words or numbers on the line are configuration parameter\n# data fields.\n\n# Note that configuration option names are not case sensitive. However,\n# configuration parameter data is case sensitive and the lettercase must\n# be preserved.\n\n# This is a favourite fruit\nFAVOURITEFRUIT banana\n\n# This is a boolean that should be set\nNEEDSPEELING\n\n# This boolean is commented out\n; SEEDSREMOVED\n\n# How many bananas we have\nNUMBEROFBANANAS 48\n\n```\n\nThe task is to manipulate the configuration file as follows:\n\n* Disable the needspeeling option (using a semicolon prefix)\n* Enable the seedsremoved option by removing the semicolon and any leading whitespace\n* Change the numberofbananas parameter to 1024\n* Enable (or create if it does not exist in the file) a parameter for numberofstrawberries with a value of 62000\n\nNote that configuration option names are not case sensitive. This means that changes should be effected, regardless of the case.\n\nOptions should always be disabled by prefixing them with a semicolon.\n\nLines beginning with hash symbols should not be manipulated and left unchanged in the revised file.\n\nIf a configuration option does not exist within the file (in either enabled or disabled form), it should be added during this update. Duplicate configuration option names in the file should be removed, leaving just the first entry.\n\nFor the purpose of this task, the revised file should contain appropriate entries, whether enabled or not for needspeeling,seedsremoved,numberofbananas and numberofstrawberries.)\n\nThe update should rewrite configuration option names in capital letters. However lines beginning with hashes and any parameter data must not be altered (eg the banana for favourite fruit must not become capitalized). The update process should also replace double semicolon prefixes with just a single semicolon (unless it is uncommenting the option, in which case it should remove all leading semicolons).\n\nAny lines beginning with a semicolon or groups of semicolons, but no following option should be removed, as should any leading or trailing whitespace on the lines. Whitespace between the option and parameters should consist only of a single\nspace, and any non-ASCII extended characters, tabs characters, or control codes\n(other than end of line markers), should also be removed.\n\nRelated tasks\n\n* Read a configuration file"}, {"role": "assistant", "content": "(formerly Perl 6)\nImplemented as a command-line script which can make arbitrary in-place updates to such config files.\n\nAssuming that the script is saved as conf-update and the config file as test.cfg, the four changes required by the task description could be performed with the command:\n\n```\nconf-update --/needspeeling --seedsremoved --numberofbananas=1024 --numberofstrawberries=62000 test.cfg\n```\n\nThe script:\n\n```\nuse File::Temp;\n\nmy ($tmpfile, $out) = tempfile;\n\nsub MAIN ($file, *%changes) {\n    %changes.=map({; .key.uc => .value });\n    my %seen;\n\n    for $file.IO.lines {\n        when /:s ^ ('#' .* | '') $/ {\n            say $out: ~$0;\n        }\n        when /:s ^ (';'+)? [(\\w+) (\\w+)?]? $/ {\n            next if !$1 or %seen{$1.uc}++;\n            my $new = %changes{$1.uc}:delete;\n            say $out: format-line $1, |( !defined($new)  ?? ($2, !$0)  !!\n                                         $new ~~ Bool    ?? ($2, $new) !! ($new, True) );\n        }\n        default {\n            note \"Malformed line: $_\\nAborting.\";\n            exit 1;\n        }\n    }\n\n    say $out: format-line .key, |(.value ~~ Bool ?? (Nil, .value) !! (.value, True))\n        for %changes;\n\n    $out.close;\n\n    copy $tmpfile, $file;\n}\n\nsub format-line ($key, $value, $enabled) {\n    (\"; \" if !$enabled) ~ $key.uc ~ (\" $value\" if defined $value);\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "An upside-down number is a positive base 10 integer whose ***i***-th leftmost and ***i***-th rightmost digits are complements, i.e., their sum is 10.\n\nFor example\n\n```\n   7165493 is an upside-down number.\n   7 + 3 = 10\n   1 + 9 = 10\n   6 + 4 = 10\n   5 + 5 = 10\n\n```\n\nFrom that definition it follows that an upside-down number cannot contain any zeros, and if there is an odd number of digits, then the center digit must be a 5.\n\nTask\n\n* Write a routine to find (or generate) upside-down numbers.\n* Find and show the first 50 upside-down numbers.\n* Find and show the five hundredth upside-down number.\n* Find and show the five thousandth upside-down number.\n\nStretch\n\n* Find and show the fifty thousandth, five hundred thousandth, five millionth upside-down number.\n\nSee also\n\n* Numbers-A-Plenty: Upside-down number * OEIS:A299539 - Upside-down numbers"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\n\nsub udgen (@r) {\n    my @u = @r.hyper.map: { next if .contains: 0; ($_, (10 «-« .flip.comb).join) };\n    @u».join, @u».join(5)\n}\n\nmy @upside-downs = lazy flat 5, (^∞).map({ udgen exp($_,10) .. exp(1+$_,10) });\n\nsay \"First fifty upside-downs:\\n\" ~ @upside-downs[^50].batch(10)».fmt(\"%4d\").join: \"\\n\";\n\nsay '';\n\nfor 5e2, 5e3, 5e4, 5e5, 5e6 {\n    say \"{.Int.&ordinal.tc}: \" ~ comma @upside-downs[$_-1]\n}\n\n```\n\nOutput:\n\n```\nFirst fifty upside-downs:\n   5   19   28   37   46   55   64   73   82   91\n 159  258  357  456  555  654  753  852  951 1199\n1289 1379 1469 1559 1649 1739 1829 1919 2198 2288\n2378 2468 2558 2648 2738 2828 2918 3197 3287 3377\n3467 3557 3647 3737 3827 3917 4196 4286 4376 4466\n\nFive hundredth: 494,616\nFive thousandth: 56,546,545\nFifty thousandth: 6,441,469,664\nFive hundred thousandth: 729,664,644,183\nFive millionth: 82,485,246,852,682\n```"}]}
{"messages": [{"role": "user", "content": "This task   (the reverse of   URL encoding   and distinct from   URL parser)   is to provide a function\nor mechanism to convert an URL-encoded string into its original unencoded form.\n\nTest cases\n\n* The encoded string   \"`http%3A%2F%2Ffoo%20bar%2F`\"   should be reverted to the unencoded form   \"`http://foo bar/`\".\n\n* The encoded string   \"`google.com/search?q=%60Abdu%27l-Bah%C3%A1`\"   should revert to the unencoded form   \"`google.com/search?q=`Abdu'l-Bahá`\".\n\n* The encoded string   \"`%25%32%35`\"   should revert to the unencoded form   \"`%25`\" and **not** \"`%`\"."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy @urls = < http%3A%2F%2Ffoo%20bar%2F\n             google.com/search?q=%60Abdu%27l-Bah%C3%A1 >;\n\nsay .subst( :g,\n    / [ '%' ( <xdigit> ** 2 ) ]+ / ,\n    { Blob.new((:16(~$_) for $0)).decode }\n    ) for @urls;\n\n```\n\nOutput:\n\n```\nhttp://foo bar/\ngoogle.com/search?q=`Abdu'l-Bahá\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nProvide a function or mechanism to convert a provided string into URL encoding representation.\n\nIn URL encoding, special characters, control characters and extended characters\nare converted into a percent symbol followed by a two digit hexadecimal code,\nSo a space character encodes into %20 within the string.\n\nFor the purposes of this task, every character except 0-9, A-Z and a-z requires conversion, so the following characters all require conversion by default:\n\n* ASCII control codes (Character ranges 00-1F hex (0-31 decimal) and 7F (127 decimal).\n* ASCII symbols (Character ranges 32-47 decimal (20-2F hex))\n* ASCII symbols (Character ranges 58-64 decimal (3A-40 hex))\n* ASCII symbols (Character ranges 91-96 decimal (5B-60 hex))\n* ASCII symbols (Character ranges 123-126 decimal (7B-7E hex))\n* Extended characters with character codes of 128 decimal (80 hex) and above.\n\nExample\n\nThe string \"`http://foo bar/`\" would be encoded as \"`http%3A%2F%2Ffoo%20bar%2F`\".\n\nVariations\n\n* Lowercase escapes are legal, as in \"`http%3a%2f%2ffoo%20bar%2f`\".\n* Special characters have different encodings for different standards:\n  + RFC 3986, *Uniform Resource Identifier (URI): Generic Syntax*, section 2.3, says to preserve \"-.\\_~\".\n  + HTML 5, section 4.10.22.5 URL-encoded form data, says to preserve \"-.\\_\\*\", and to encode space \" \" to \"+\".\n  + encodeURI function in Javascript will preserve \"-.\\_~\" (RFC 3986) and \";,/?:@&=+$!\\*'()#\".\n\nOptions\n\nIt is permissible to use an exception string (containing a set of symbols\nthat do not need to be converted).\nHowever, this is an optional feature and is not a requirement of this task.\n\nRelated tasks\n\n* URL decoding\n* URL parser"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $url = 'http://foo bar/';\n\nsay $url.subst(/<-alnum>/, *.ord.fmt(\"%%%02X\"), :g);\n\n```\n\nOutput:\n\n```\nhttp%3A%2F%2Ffoo%20bar%2F\n```"}]}
{"messages": [{"role": "user", "content": "URLs are strings with a simple syntax:\n\n```\n  scheme://[username:password@]domain[:port]/path?query_string#fragment_id\n\n```\n\nTask\n\nParse a well-formed URL to retrieve the relevant information:   **scheme**, **domain**, **path**, ...\n\nNote:   this task has nothing to do with URL encoding or URL decoding.\n\nAccording to the standards, the characters:\n\n:   :   :   :   ! \\* ' ( ) ; : @ & = + $ , / ? % # [ ]\n\nonly need to be percent-encoded   (**%**)   in case of possible confusion.\n\nAlso note that the **path**, **query** and **fragment** are case sensitive, even if the **scheme** and **domain** are not.\n\nThe way the returned information is provided (set of variables, array, structured, record, object,...)\nis language-dependent and left to the programmer, but the code should be clear enough to reuse.\n\nExtra credit is given for clear error diagnostics.\n\n* Here is the official standard:     https://tools.ietf.org/html/rfc3986,\n* and here is a simpler   BNF:     http://www.w3.org/Addressing/URL/5\\_URI\\_BNF.html.\n\nTest cases\n\nAccording to T. Berners-Lee\n\n**foo://example.com:8042/over/there?name=ferret#nose**     should parse into:\n\n:   :   * scheme = foo\n        * domain = example.com\n        * port = :8042\n        * path = over/there\n        * query = name=ferret\n        * fragment = nose\n\n**urn:example:animal:ferret:nose**     should parse into:\n\n:   :   * scheme = urn\n        * path = example:animal:ferret:nose\n\n**other URLs that must be parsed include:**\n\n:   * jdbc:mysql://test\\_user:ouupppssss@localhost:3306/sakila?profileSQL=true\n    * ftp://ftp.is.co.za/rfc/rfc1808.txt\n    * http://www.ietf.org/rfc/rfc2396.txt#header1\n    * ldap://[2001:db8::7]/c=GB?objectClass=one&objectClass=two\n    * mailto:John.Doe@example.com\n    * news:comp.infosystems.www.servers.unix\n    * tel:+1-816-555-1212\n    * telnet://192.0.2.16:80/\n    * urn:oasis:names:specification:docbook:dtd:xml:4.1.2"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-11-02\n\nUses the URI library which implements a Raku grammar based on the RFC 3986 BNF grammar.\n\n```\nuse URI;\nuse URI::Escape;\n\nmy @test-uris = <\n    foo://example.com:8042/over/there?name=ferret#nose\n    urn:example:animal:ferret:nose\n    jdbc:mysql://test_user:ouupppssss@localhost:3306/sakila?profileSQL=true\n    ftp://ftp.is.co.za/rfc/rfc1808.txt\n    http://www.ietf.org/rfc/rfc2396.txt#header1\n    ldap://[2001:db8::7]/c=GB?objectClass?one\n    mailto:John.Doe@example.com\n    news:comp.infosystems.www.servers.unix\n    tel:+1-816-555-1212\n    telnet://192.0.2.16:80/\n    urn:oasis:names:specification:docbook:dtd:xml:4.1.2\n    ssh://alice@example.com\n    https://bob:pass@example.com/place\n    http://example.com/?a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64\n>;\n\nmy $u = URI.new;\n\nfor @test-uris -> $uri {\n    say \"URI:\\t\", $uri;\n        $u.parse($uri);\n        for <scheme host port path query frag> -> $t {\n           my $token = try {$u.\"$t\"()} || '';\n           say \"$t:\\t\", uri-unescape $token.Str if $token;\n        }\n    say '';\n}\n\n```\n\nOutput:\n\n```\nURI:\tfoo://example.com:8042/over/there?name=ferret#nose\nscheme:\tfoo\nhost:\texample.com\nport:\t8042\npath:\t/over/there\nquery:\tname=ferret\nfrag:\tnose\n\nURI:\turn:example:animal:ferret:nose\nscheme:\turn\npath:\texample:animal:ferret:nose\n\nURI:\tjdbc:mysql://test_user:ouupppssss@localhost:3306/sakila?profileSQL=true\nscheme:\tjdbc\npath:\tmysql://test_user:ouupppssss@localhost:3306/sakila\nquery:\tprofileSQL=true\n\nURI:\tftp://ftp.is.co.za/rfc/rfc1808.txt\nscheme:\tftp\nhost:\tftp.is.co.za\nport:\t21\npath:\t/rfc/rfc1808.txt\n\nURI:\thttp://www.ietf.org/rfc/rfc2396.txt#header1\nscheme:\thttp\nhost:\twww.ietf.org\nport:\t80\npath:\t/rfc/rfc2396.txt\nfrag:\theader1\n\nURI:\tldap://[2001:db8::7]/c=GB?objectClass?one\nscheme:\tldap\nhost:\t[2001:db8::7]\nport:\t389\npath:\t/c=GB\nquery:\tobjectClass?one\n\nURI:\tmailto:John.Doe@example.com\nscheme:\tmailto\npath:\tJohn.Doe@example.com\n\nURI:\tnews:comp.infosystems.www.servers.unix\nscheme:\tnews\nport:\t119\npath:\tcomp.infosystems.www.servers.unix\n\nURI:\ttel:+1-816-555-1212\nscheme:\ttel\npath:\t 1-816-555-1212\n\nURI:\ttelnet://192.0.2.16:80/\nscheme:\ttelnet\nhost:\t192.0.2.16\nport:\t80\npath:\t/\n\nURI:\turn:oasis:names:specification:docbook:dtd:xml:4.1.2\nscheme:\turn\npath:\toasis:names:specification:docbook:dtd:xml:4.1.2\n\nURI:\tssh://alice@example.com\nscheme:\tssh\nhost:\texample.com\nport:\t22\npath:\t\n\nURI:\thttps://bob:pass@example.com/place\nscheme:\thttps\nhost:\texample.com\nport:\t443\npath:\t/place\n\nURI:\thttp://example.com/?a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64\nscheme:\thttp\nhost:\texample.com\nport:\t80\npath:\t/\nquery:\ta=1&b=2 2&c=3&c=4&d=encoded\n```"}]}
{"messages": [{"role": "user", "content": "The job of a URL shortener is to take a long URL (e.g. \"https://www.cockroachlabs.com/docs/stable/build-a-go-app-with-cockroachdb.html\") and turn it into something shorter (e.g. \"https://bit.ly/2QLUQIu\").\n\nA simple URL shortener with no special rules is very simple and consists of 2 endpoints:\n\n* One to generate a short version of a URL given a long version of a URL.\n* One to handle a call to the short version of a URL and redirect the user to the long (original) version of the URL.\n\nCreate a simple URL shortening API with the following endpoints:\n\n**POST /**\n\nA POST endpoint that accepts a JSON body describing the URL to shorten. Your URL shortener should generate a short version of the URL and keep track of the mapping between short and long URLs. For example:\n\n```\n   $ curl -X POST 'localhost:8080' \\\n   -H 'Content-Type: application/json' \\\n   -d '{\n       \"long\": \"https://www.cockroachlabs.com/docs/stable/build-a-go-app-with-cockroachdb.html\"\n   }'\n\n```\n\nShould returning something similar to:\n\n```\n   http://localhost:8080/9eXmFnuj\n\n```\n\n**GET /:short**\n\nA GET endpoint that accepts a short version of the URL in the URL path and redirects the user to the original URL. For example:\n\n```\n   $ curl -L http://localhost:3000/9eXmFnuj\n\n```\n\nShould redirect the user to the original URL:\n\n```\n   <!DOCTYPE html>\n   <html lang=\"en\">\n   ...\n\n```\n\n**Rules**:\n\n* Store the short -> long mappings in any way you like. In-memory is fine.\n* There are no auth requirements. Your API can be completely open."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.11\n\nAs there is no requirement to obfuscate the shortened urls, I elected to just use a simple base 36 incremental counter starting at \"0\" to \"shorten\" the urls.\n\nSets up a micro web service on the local computer at port 10000. Run the service, then access it with any web browser at address localhost:10000 . Any saved urls will be displayed with their shortened id. Enter a web address in the text field to assign a shortened id. Append that id to the web address to automatically be redirected to that url. The url of **this** page is entered as id 0, so the address: \" localhost:10000/0 \" will redirect to here, to this page.\n\nThe next saved address would be accessible at localhost:10000/1 . And so on.\n\nSaves the shortened urls in a local json file called urls.json so saved urls will be available from session to session. No provisions to edit or delete a saved url. If you want to edit the saved urls, edit the urls.json file directly with some third party editor then restart the service.\n\nThere is **NO** security or authentication on this minimal app. Not recommended to run this as-is on a public facing server. It would not be too difficult to *add* appropriate security, but it isn't a requirement of this task. Very minimal error checking and recovery.\n\n```\n# Persistent URL storage\nuse JSON::Fast;\n\nmy $urlfile = './urls.json'.IO;\nmy %urls = ($urlfile.e and $urlfile.f and $urlfile.s) ??\n  ( $urlfile.slurp.&from-json ) !!\n  ( index => 1, url => { 0 => 'http://rosettacode.org/wiki/URL_shortener#Raku' } );\n\n$urlfile.spurt(%urls.&to-json);\n\n# Setup parameters\nmy $host = 'localhost';\nmy $port = 10000;\n\n# Micro HTTP service\nuse Cro::HTTP::Router;\nuse Cro::HTTP::Server;\n\nmy $application = route {\n    post -> 'add_url' {\n        redirect :see-other, '/';\n        request-body -> (:$url) {\n            %urls<url>{ %urls<index>.base(36) } = $url;\n            ++%urls<index>;\n            $urlfile.spurt(%urls.&to-json);\n        }\n    }\n\n    get -> {\n        content 'text/html', qq:to/END/;\n        <form action=\"http://$host:$port/add_url\" method=\"post\">\n        URL to add:</br><input type=\"text\" name=\"url\"></br>\n        <input type=\"submit\" value=\"Submit\"></form></br>\n        Saved URLs:\n        <div style=\"background-color:#eeeeee\">\n        { %urls<url>.sort( +(*.key.parse-base(36)) ).join: '</br>' }\n        </div>\n        END\n    }\n\n    get -> $short {\n        if my $link = %urls<url>{$short} {\n            redirect :permanent, $link\n        }\n        else {\n            not-found\n        }\n    }\n}\n\nmy Cro::Service $shorten = Cro::HTTP::Server.new:\n    :$host, :$port, :$application;\n\n$shorten.start;\n\nreact whenever signal(SIGINT) { $shorten.stop; exit; }\n\n```"}]}
{"messages": [{"role": "user", "content": "This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.\n\nThis task is inverse to the task Call foreign language function. Consider the following C program:\n\n```\n#include <stdio.h>\n\nextern int Query (char * Data, size_t * Length);\n\nint main (int argc, char * argv [])\n{\n   char     Buffer [1024];\n   size_t   Size = sizeof (Buffer);\n   \n   if (0 == Query (Buffer, &Size))\n   {\n      printf (\"failed to call Query\\n\");\n   }\n   else\n   {\n      char * Ptr = Buffer;\n      while (Size-- > 0) putchar (*Ptr++);\n      putchar ('\\n');\n   }\n}\n\n```\n\nImplement the missing `Query` function in your language, and let this C program call it. The function should place the string *Here am I* into the buffer which is passed to it as the parameter `Data`. The buffer size in bytes is passed as the parameter `Length`. When there is no room in the buffer, `Query` shall return 0. Otherwise it overwrites the beginning of `Buffer`, sets the number of overwritten bytes into `Length` and returns 1."}, {"role": "assistant", "content": "(formerly Perl 6)\nThis SO answer, by JJ Merelo, explained the difficulty on providing a simple solution.  So this attempt takes the same approach as PicoLisp by summoning the interpreter at run time.\n\n**Translation of**: PicoLisp\n\nquery.raku\n\n```\n#!/usr/bin/env raku\n\nsub MAIN (Int :l(:len(:$length))) {\n   my Str $String = \"Here am I\";\n   $*OUT.print: $String if $String.codes ≤ $length\n}\n\n```\n\nquery.c\n\n```\n#include<stdio.h>\n#include<stddef.h>\n#include<string.h>\n\nint Query(char *Data, size_t *Length) {\n   FILE *fp;\n   char buf[64];\n\n   sprintf(buf, \"/home/user/query.raku --len=%zu\", *Length);\n   if (!(fp = popen(buf, \"r\")))\n      return 0;\n   fgets(Data, *Length, fp);\n   *Length = strlen(Data);\n   return pclose(fp) >= 0 && *Length != 0;\n}\n\n```\n\nOutput:\n\n```\ngcc -Wall -o main main.c query.c\n./main\nHere am I\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nShowcase an instruction or function built into the language, that is made redundant by another instruction also built into the language. It can be limited to a specific way that function is used, e.g. printing a null string, but try not to make it that obvious.\n\n`NOP` and any instructions or functions that are intended to do nothing do not count."}, {"role": "assistant", "content": "I disagree with the whole premise. There are pretty darn few instructions that are completely useless in *any* language unless *you are using them in ways not intended*, or are *deliberately structuring them to be useless*; and most of the existing examples point that out.\n\n.oO( This chainsaw is crap at driving screws in... ) Well duh.\n\n.oO( I've multiplied this numeric value by 1 millions of times and it still hasn't changed! ) Thanks for your contribution, Captain Oblivious.\n\nRedundant instructions / operations on the other hand... Syntactically different operations that *can* be used to achieve the same result abound in higher level languages. In general they are intended to be used in slightly different circumstances, or are just syntactic sugar to condense a multi-step operation down to a more compact representation. Raku is just **full** of syntactic sugar operations.\n\nProgramming languages aren't for computers, they are for people. If they were for computers, we would be programming in binary code. Having an expressive language that helps the programmer transform his thoughts into code leads to \"redundancies\" due to allowing for shades of meaning that make sense to people though may be insignificant to computers.\n\nSome examples: Say you have a variable $x that holds an integer, and you want to add 1 to it.\n\n```\nmy $x = 1;\n\n$x = $x + 1;  # classic\n$x += 1;      # classic abbreviated\n++$x;         # pre-increment\n$x++;         # post-increment\n$x.=succ;     # method, find successor\n\n```\n\n*Raku is by no means unique in that regard.* Each one of those nominally accomplishes the same thing, though they go about it in slightly different ways, and are intended for slightly different purposes. Redundant on the face of it, but different reasons for each.\n\nThere may be different operations that essentially perform the same function that have been retained for historical compatibility and / or ease for crossover programmers. the `for next` construct really only exists in Raku for programmer convenience. Internally it is converted to a map operation. Programmers can use map directly, but if they come from a language that doesn't provide map, and aren't used to it, `for next` is a easy stepping stone.\n\n```\nfor 1..10 { next if $_ %% 2; say '_' x $_ };  # for next\nmap { next if $_ %% 2; say '_' x $_ }, 1..10; # equivalent map\n\n```\n\nSyntactic sugar (typically) replaces some longer expression with a shorter, more easily typed one. Raku abounds with them.\n\n```\nmy @a1 = Q:w[one two three]; # list of strings using the Q sublanguage\nmy @a2 = <one two three>;    # syntactic sugar for the same operation\n\nsay (1,2,3,4,5,6,7).reduce(&infix:<*>); # multiply all of the items in a list together \nsay [*] (1,2,3,4,5,6,7);                # same operation, sweeter syntax\n\n```"}]}
{"messages": [{"role": "user", "content": "If the language supports operator definition, then:\n\n* create \"user defined\" the equivalents of the Unix shell \"<\", \"|\", \">\", \"<<\", \">>\" and $(cmd) operators.\n* Provide simple equivalents of: cat, tee, grep, & uniq, but as filters/procedures native to the specific language.\n* Replicate the below sample shell script, but in the specific language\n* Specifically *do not* cache the entire stream before the subsequent filter/procedure starts. Pass each record on as soon as available through each of the filters/procedures in the chain.\n\n**Alternately:** if the language does not support operator definition then replace with:\n\n* define the procedures: input(cmd,stream), pipe(stream,cmd), output(stream, stream), whereis(array), append(stream)\n\nFor bonus Kudos: Implement the shell \"&\" concept as a dyadic operator in the specific language. e.g.:\n\n```\n( head x & tail x & wait ) | grep test\n\n```\n\n**Sample shell script:** *¢ draft - pending a better (more interesting) suggestion ¢*\n\n```\naa=\"$(\n  (\n    head -4 < List_of_computer_scientists.lst;\n    cat List_of_computer_scientists.lst | grep ALGOL | tee ALGOL_pioneers.lst;\n    tail -4 List_of_computer_scientists.lst\n  ) | sort | uniq | tee the_important_scientists.lst | grep aa\n);\necho \"Pioneer: $aa\"\n\n```\n\n**Input Records:**\n\nA test sample of scientists from wikipedia's \"List of computer scientists\"\n\n| Name | Areas of interest |\n| --- | --- |\n| Wil van der Aalst | business process management, process mining, Petri nets |\n| Hal Abelson | intersection of computing and teaching |\n| Serge Abiteboul | database theory |\n| Samson Abramsky | game semantics |\n| Leonard Adleman | RSA, DNA computing |\n| Manindra Agrawal | polynomial-time primality testing |\n| Luis von Ahn | human-based computation |\n| Alfred Aho | compilers book, the 'a' in AWK |\n| Stephen R. Bourne | Bourne shell, portable ALGOL 68C compiler |\n| Kees Koster | ALGOL 68 |\n| Lambert Meertens | ALGOL 68, ABC (programming language) |\n| Peter Naur | BNF, ALGOL 60 |\n| Guido van Rossum | Python (programming language) |\n| Adriaan van Wijngaarden | Dutch pioneer; ARRA, ALGOL |\n| Dennis E. Wisnosky | Integrated Computer-Aided Manufacturing (ICAM), IDEF |\n| Stephen Wolfram | Mathematica |\n| William Wulf | compilers |\n| Edward Yourdon | Structured Systems Analysis and Design Method |\n| Lotfi Zadeh | fuzzy logic |\n| Arif Zaman | Pseudo-random number generator |\n| Albert Zomaya | Australian pioneer of scheduling in parallel and distributed systems |\n| Konrad Zuse | German pioneer of hardware and software |\n\nThese records can be declared in any format appropriate to the specific language. eg table, array, list, table or text file etc.\n\n**Output:**\n\n```\nPioneer: Adriaan van Wijngaarden - Dutch pioneer; ARRA, ALGOL\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\nImplementing cat, redirect(<), head, tail and tee. I share the same general lack of enthusiasm as the Perl example author to implement the other shell ops. Many of the ops already exist in some form in Raku, though they may have slightly different syntax and precedence as the shell ops. I didn't bother implementing pipe (|) as Raku pretty much has chaining semantics built in.\n\nThe less than '<' operator is very low level in Raku and would be troublesome to override, so is implemented as 'redirect'. The sort and unique directives don't really have any effect on the final result string, it would be the same without them, but it is following the task example.\n\nThis assumes that the data is in a tab separated file \"List\\_of\\_computer\\_scientists.lst\" in the current directory.\n\n```\nsub cat ($fname) { lazy $fname.IO.lines };\nsub head ($count, @positional) { @positional.head($count) }\nsub redirect ($fname) { cat($fname) }\nsub tail (Int $count, Str $fname) { $fname.IO.lines.tail($count) }\nsub infix:<tee> ($stream, $fname) {\n    # need to reify the lazy list to write to a file\n    my @values = @$stream[^Inf].grep: *.defined;\n    # meh. not really going to write the files\n    # $fname.IO.put @values.join(\"\\n\")\n    # just pass the reified values along\n    @values.List\n}\n\nmy $aa = ((\n    (head 4, redirect 'List_of_computer_scientists.lst'),\n    cat('List_of_computer_scientists.lst') .grep( /'ALGOL'/ ) tee 'ALGOL_pioneers.lst',\n    tail 4, 'List_of_computer_scientists.lst'\n).flat .sort .unique tee 'the_important_scientists.lst') .grep: /'aa'/;\n\nsay \"Pioneer: $aa\";\n\n```\n\nOutput:\n\n```\nPioneer: Adriaan van Wijngaarden\tDutch pioneer; ARRA, ALGOL\n```"}]}
{"messages": [{"role": "user", "content": "In this task, the goal is to input a string and the integer 75000, from graphical user interface.\n\nSee also: User input/Text"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Library:** GTK\n\n```\nuse GTK::Simple;\nuse GTK::Simple::App;\n\nmy GTK::Simple::App $app .= new( title => 'User Interaction' );\n\n$app.border-width = 20;\n\n$app.set-content(\n    GTK::Simple::VBox.new(\n        my $        = GTK::Simple::Label.new( text => 'Enter a string.' ),\n        my $str     = GTK::Simple::Entry.new,\n        my $string  = GTK::Simple::Label.new,\n        my $        = GTK::Simple::Label.new( text => 'Enter the number 75000' ),\n        my $val     = GTK::Simple::Entry.new,\n        my $correct = GTK::Simple::Label.new,\n    )\n);\n\n$str.changed.tap: {\n    $string.text = \"You entered: { $str.text }\"\n}\n\n$val.changed.tap: {\n    $correct.text = \"That's { 'not' unless $val.text ~~ / ^^ <ws> 75000 <ws> $$ / } 75000!\"\n}\n\n$app.run;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nInput a string and the integer   **75000**   from the text console.\n\nSee also: User input/Graphical\n\nWhy doesn't syntax highlighting work on this page ?\n\nCurrently, there is a limit on how many <syntaxhighlight> tags can appear on a page, so only the first few languages get highlighting, the rest are shown in monochrome.  \nYou could try \"manual highlighting\", possibly using one of the highlighters on Syntax highlighting using Mediawiki formatting or something similar."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $str = prompt(\"Enter a string: \");\nmy $int = prompt(\"Enter a integer: \");\n```"}]}
{"messages": [{"role": "user", "content": "Display a piece of text and produce spoken output via a speech engine.\n\nAs each word is being spoken, highlight the word on the display.\n\nIn languages where cursor control and highlighting are not possible, it is permissible to output each word as it is spoken.\n\nRelated task\n:   * speech synthesis"}, {"role": "assistant", "content": "**Translation of**: Go\n\n```\n# 20200826 Raku programming solution\n\nmy \\s = \"Actions speak louder than words.\";\nmy \\prev = $ = \"\";\nmy \\prevLen = $ = 0;\nmy \\bs = $ = \"\";\n\nfor s.split(' ', :skip-empty) {\n   run \"/usr/bin/espeak\", $_ or die;\n   bs = \"\\b\" x prevLen if prevLen > 0;\n   printf \"%s%s%s \", bs, prev, $_.uc;\n   prev = \"$_ \";\n   prevLen = $_.chars + 1\n}\n\nprintf \"%s%s\\n\", \"\\b\" x prevLen, prev;\n\n```"}]}
{"messages": [{"role": "user", "content": "As described in UTF-8 and in Wikipedia, UTF-8 is a popular encoding of (multi-byte) Unicode code-points into eight-bit octets.\n\nThe goal of this task is to write a encoder that takes a unicode code-point (an integer representing a unicode character) and returns a sequence of 1–4 bytes representing that character in the UTF-8 encoding.\n\nThen you have to write the corresponding decoder that takes a sequence of 1–4 UTF-8 encoded bytes and return the corresponding unicode character.\n\nDemonstrate the functionality of your encoder and decoder on the following five characters:\n\n```\nCharacter   Name                                  Unicode    UTF-8 encoding (hex)\n---------------------------------------------------------------------------------\nA           LATIN CAPITAL LETTER A                U+0041     41\nö           LATIN SMALL LETTER O WITH DIAERESIS   U+00F6     C3 B6\nЖ           CYRILLIC CAPITAL LETTER ZHE           U+0416     D0 96\n€           EURO SIGN                             U+20AC     E2 82 AC\n𝄞           MUSICAL SYMBOL G CLEF                 U+1D11E    F0 9D 84 9E\n\n```\n\nProvided below is a reference implementation in Common Lisp."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.02\n\nPretty much all built in to the language.\n\n```\nsay sprintf(\"%-18s %-36s|%8s| %7s |%14s | %s\\n\", 'Character|', 'Name', 'Ordinal', 'Unicode', 'UTF-8 encoded', 'decoded'), '-' x 100;\n\nfor < A ö Ж € 𝄞 😜 👨‍👩‍👧‍👦> -> $char {\n    printf \"   %-5s | %-43s | %6s | %-7s | %12s  |%4s\\n\", $char, $char.uninames.join(','), $char.ords.join(' '),\n      ('U+' X~ $char.ords».base(16)).join(' '), $char.encode('UTF8').list».base(16).Str, $char.encode('UTF8').decode;\n}\n\n```\n\nOutput:\n\n```\nCharacter|         Name                                | Ordinal| Unicode | UTF-8 encoded | decoded\n----------------------------------------------------------------------------------------------------\n   A     | LATIN CAPITAL LETTER A                      |     65 | U+41    |           41  |   A\n   ö     | LATIN SMALL LETTER O WITH DIAERESIS         |    246 | U+F6    |        C3 B6  |   ö\n   Ж    | CYRILLIC CAPITAL LETTER ZHE                 |   1046 | U+416   |        D0 96  |   Ж\n   €     | EURO SIGN                                   |   8364 | U+20AC  |     E2 82 AC  |   €\n   𝄞     | MUSICAL SYMBOL G CLEF                       | 119070 | U+1D11E |  F0 9D 84 9E  |   𝄞\n   😜    | FACE WITH STUCK-OUT TONGUE AND WINKING EYE  | 128540 | U+1F61C |  F0 9F 98 9C  |   😜\n   👨‍👩‍👧‍👦    | MAN,ZERO WIDTH JOINER,WOMAN,ZERO WIDTH JOINER,GIRL,ZERO WIDTH JOINER,BOY | 128104 8205 128105 8205 128103 8205 128102 | U+1F468 U+200D U+1F469 U+200D U+1F467 U+200D U+1F466 | F0 9F 91 A8 E2 80 8D F0 9F 91 A9 E2 80 8D F0 9F 91 A7 E2 80 8D F0 9F 91 A6  |   👨‍👩‍👧‍👦\n\n```"}]}
{"messages": [{"role": "user", "content": "An International Securities Identification Number (ISIN) is a unique international identifier for a financial security such as a stock or bond.\n\nTask\n\nWrite a function or program that takes a string as input, and checks whether it is a valid ISIN.\n\nIt is only valid if it has the correct format,   *and*   the embedded checksum is correct.\n\nDemonstrate that your code passes the test-cases listed below.\n\nDetails\n\nThe format of an ISIN is as follows:\n\n┌───────────── a 2-character ISO country code (A-Z)\n\n│ ┌─────────── a 9-character security code (A-Z, 0-9)\n\n│ │        ┌── a checksum digit (0-9)\n\nAU0000XVGZA3\n\nFor this task, you may assume that any 2-character alphabetic sequence is a valid country code.\n\nThe checksum can be validated as follows:\n\n1. **Replace letters with digits**, by converting each character from base 36 to base 10, e.g. `AU0000XVGZA3` →`1030000033311635103`.\n2. **Perform the Luhn test on this base-10 number.**  \n   There is a separate task for this test: *Luhn test of credit card numbers*.  \n   You don't have to replicate the implementation of this test here   ───   you can just call the existing function from that task.   (Add a comment stating if you did this.)\n\nTest cases\n\n:   :   :   :   | ISIN | Validity | Comment |\n                | --- | --- | --- |\n                | US0378331005 | valid |  |\n                | US0373831005 | not valid | The transposition typo is caught by the checksum constraint. |\n                | U50378331005 | not valid | The substitution typo is caught by the format constraint. |\n                | US03378331005 | not valid | The duplication typo is caught by the format constraint. |\n                | AU0000XVGZA3 | valid |  |\n                | AU0000VXGZA3 | valid | Unfortunately, not *all* transposition typos are caught by the checksum constraint. |\n                | FR0000988040 | valid |  |\n\n(The comments are just informational.   Your function should simply return a Boolean result.   See #Raku for a reference solution.)\n\nRelated task:\n\n* Luhn test of credit card numbers\n\nAlso see\n\n* Interactive online ISIN validator\n* Wikipedia article: International Securities Identification Number"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nUsing the luhn-test function from the *Luhn test of credit card numbers* task.\n\n```\nmy $ISIN = /\n    ^ <[A..Z]>**2 <[A..Z0..9]>**9 <[0..9]> $\n    <?{ luhn-test $/.comb.map({ :36($_) }).join }>\n/;\n\nsub luhn-test ($number --> Bool) {\n    my @digits = $number.comb.reverse;\n    my $sum = @digits[0,2...*].sum\n            + @digits[1,3...*].map({ |($_ * 2).comb }).sum;\n    return $sum %% 10;\n}\n\n# Testing:\n\nsay \"$_ is { m/$ISIN/ ?? \"valid\" !! \"not valid\"}\" for <\nUS0378331005\nUS0373831005\nU50378331005\nUS03378331005\nAU0000XVGZA3\nAU0000VXGZA3\nFR0000988040\n>;\n\n```\n\nOutput:\n\n```\nUS0378331005 is valid\nUS0373831005 is not valid\nU50378331005 is not valid\nUS03378331005 is not valid\nAU0000XVGZA3 is valid\nAU0000VXGZA3 is valid\nFR0000988040 is valid\n\n```"}]}
{"messages": [{"role": "user", "content": "A vampire number is a natural decimal number with an even number of digits,   that can be factored into two integers.\n\nThese two factors are called the   *fangs*,   and must have the following properties:\n\n:   :   * they each contain half the number of the decimal digits of the original number\n        * together they consist of exactly the same decimal digits as the original number\n        * at most one of them has a trailing zero\n\nAn example of a vampire number and its fangs:    `1260 : (21, 60)`\n\nTask\n\n1. Print the first   **25**   vampire numbers and their fangs.\n2. Check if the following numbers are vampire numbers and,   if so,   print them and their fangs:\n\n`16758243290880, 24959017348650, 14593825548650`\n\nNote that a vampire number can have more than one pair of fangs.\n\nSee also\n\n* numberphile.com.\n* vampire search algorithm\n* vampire numbers on OEIS"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nuse Prime::Factor;\n\nsub is_vampire (Int $num) {\n    return Empty unless $num % 9 == 0|4;\n    my $digits = $num.comb.sort;\n    my @fangs;\n    my @divs = $num.&divisors(:s).grep({.chars == $num.chars div 2});\n    return Empty unless @divs >= 2;\n    @divs.map: -> $this {\n         my $that = $num div $this;\n         next if $this %% 10 && $that %% 10;\n         last if $this > $that;\n         @fangs.push(\"$this x $that\") if ($this ~ $that).comb.sort eq $digits;\n    }\n    @fangs\n}\n\nconstant @vampires = flat (3..*).map: -> $s, $e {\n    (flat (10**$s div 9 .. 10**$e div 9).map({my $v = $_ * 9, $v + 4})).hyper.map: -> $n {\n        next unless my @fangs = is_vampire($n);\n        \"$n: { @fangs.join(', ') }\"\n    }\n}\n\nsay \"\\nFirst 25 Vampire Numbers:\\n\";\n\n.say for @vampires[^25];\n\nsay \"\\nIndividual tests:\\n\";\n\n.say for (16758243290880, 24959017348650, 14593825548650).hyper(:1batch).map: {\n    \"$_: \" ~ (is_vampire($_).join(', ') || 'is not a vampire number.')\n}\n\n```\n\n```\nFirst 25 Vampire Numbers:\n\n1260: 21 x 60\n1395: 15 x 93\n1435: 35 x 41\n1530: 30 x 51\n1827: 21 x 87\n2187: 27 x 81\n6880: 80 x 86\n102510: 201 x 510\n104260: 260 x 401\n105210: 210 x 501\n105264: 204 x 516\n105750: 150 x 705\n108135: 135 x 801\n110758: 158 x 701\n115672: 152 x 761\n116725: 161 x 725\n117067: 167 x 701\n118440: 141 x 840\n120600: 201 x 600\n123354: 231 x 534\n124483: 281 x 443\n125248: 152 x 824\n125433: 231 x 543\n125460: 204 x 615, 246 x 510\n125500: 251 x 500\n\nIndividual tests:\n\n16758243290880: 1982736 x 8452080, 2123856 x 7890480, 2751840 x 6089832, 2817360 x 5948208\n24959017348650: 2947050 x 8469153, 2949705 x 8461530, 4125870 x 6049395, 4129587 x 6043950, 4230765 x 5899410\n14593825548650: is not a vampire number.\n```"}]}
{"messages": [{"role": "user", "content": "When counting integers in binary, if you put a (binary) point to the right of the count then the column immediately to the left denotes a digit with a multiplier of \n\n2\n\n0\n{\\displaystyle {\\displaystyle 2^{0}}}\n; the digit in the next column to the left has a multiplier of \n\n2\n\n1\n{\\displaystyle {\\displaystyle 2^{1}}}\n; and so on.\n\nSo in the following table:\n\n```\n  0.\n  1.\n 10.\n 11.\n ...\n```\n\nthe binary number \"`10`\" is \n\n1\n×\n\n2\n\n1\n+\n0\n×\n\n2\n\n0\n{\\displaystyle {\\displaystyle 1\\times 2^{1}+0\\times 2^{0}}}\n.\n\nYou can also have binary digits to the right of the “point”, just as in the decimal number system. In that case, the digit in the place immediately to the right of the point has a weight of \n\n2\n\n−\n1\n{\\displaystyle {\\displaystyle 2^{-1}}}\n, or \n\n1\n\n/\n2\n{\\displaystyle {\\displaystyle 1/2}}\n.\nThe weight for the second column to the right of the point is \n\n2\n\n−\n2\n{\\displaystyle {\\displaystyle 2^{-2}}}\n or \n\n1\n\n/\n4\n{\\displaystyle {\\displaystyle 1/4}}\n. And so on.\n\nIf you take the integer binary count of the first table, and *reflect* the digits about the binary point, you end up with **the van der Corput sequence of numbers in base 2**.\n\n```\n  .0\n  .1\n  .01\n  .11\n  ...\n```\n\nThe third member of the sequence, binary `0.01`, is therefore \n\n0\n×\n\n2\n\n−\n1\n+\n1\n×\n\n2\n\n−\n2\n{\\displaystyle {\\displaystyle 0\\times 2^{-1}+1\\times 2^{-2}}}\n or \n\n1\n\n/\n4\n{\\displaystyle {\\displaystyle 1/4}}\n.\n\nDistribution of 2500 points each: Van der Corput (top) vs pseudorandom\n\nMembers of the sequence lie within the interval\n\n0\n≤\nx\n<\n1\n{\\displaystyle {\\displaystyle 0\\leq x<1}}\n\n. Points within the sequence tend to be evenly distributed which is a useful trait to have for Monte Carlo simulations.\n\nThis sequence is also a superset of the numbers representable by the \"fraction\" field of an old IEEE floating point standard. In that standard, the \"fraction\" field represented the fractional part of a binary number beginning with \"1.\" e.g. 1.101001101.\n\n**Hint**\n\nA *hint* at a way to generate members of the sequence is to modify a routine used to change the base of an integer:\n\n```\n>>> def base10change(n, base):\n\tdigits = []\n\twhile n:\n\t\tn,remainder = divmod(n, base)\n\t\tdigits.insert(0, remainder)\n\treturn digits\n\n>>> base10change(11, 2)\n[1, 0, 1, 1]\n\n```\n\nthe above showing that `11` in decimal is \n\n1\n×\n\n2\n\n3\n+\n0\n×\n\n2\n\n2\n+\n1\n×\n\n2\n\n1\n+\n1\n×\n\n2\n\n0\n{\\displaystyle {\\displaystyle 1\\times 2^{3}+0\\times 2^{2}+1\\times 2^{1}+1\\times 2^{0}}}\n.  \nReflected this would become `.1101` or \n\n1\n×\n\n2\n\n−\n1\n+\n1\n×\n\n2\n\n−\n2\n+\n0\n×\n\n2\n\n−\n3\n+\n1\n×\n\n2\n\n−\n4\n{\\displaystyle {\\displaystyle 1\\times 2^{-1}+1\\times 2^{-2}+0\\times 2^{-3}+1\\times 2^{-4}}}\n\nTask description\n\n* Create a function/method/routine that given *n*, generates the *n'*th term of the van der Corput sequence in base 2.\n* Use the function to compute *and display* the first ten members of the sequence. (The first member of the sequence is for *n*=0).\n\n* As a stretch goal/extra credit, compute and show members of the sequence for bases other than 2.\n\nSee also\n\n* The Basic Low Discrepancy Sequences\n* Non-decimal radices/Convert\n* Van der Corput sequence"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.08.1\n\nFirst a cheap implementation in base 2, using string operations.\n\n```\nconstant VdC = map { :2(\"0.\" ~ .base(2).flip) }, ^Inf;\n.say for VdC[^16];\n\n```\n\nHere is a more elaborate version using the polymod built-in integer method:\n\n```\nsub VdC($base = 2) {\n    map {\n        [+] $_ && .polymod($base xx *) Z/ [\\*] $base xx *\n    }, ^Inf\n}\n\n.say for VdC[^10];\n\n```\n\nOutput:\n\n```\n0\n0.5\n0.25\n0.75\n0.125\n0.625\n0.375\n0.875\n0.0625\n0.5625\n```\n\nHere is a fairly standard imperative version in which we mutate three variables in parallel:\n\n```\nsub vdc($num, $base = 2) {\n    my $n = $num;\n    my $vdc = 0;\n    my $denom = 1;\n    while $n {\n        $vdc += $n mod $base / ($denom *= $base);\n        $n div= $base;\n    }\n    $vdc;\n}\n\nfor 2..5 -> $b {\n    say \"Base $b\";\n    say ( vdc($_,$b).Rat.nude.join('/') for ^10 ).join(', ');\n    say '';\n}\n\n```\n\nOutput:\n\n```\nBase 2\n0, 1/2, 1/4, 3/4, 1/8, 5/8, 3/8, 7/8, 1/16, 9/16\n\nBase 3\n0, 1/3, 2/3, 1/9, 4/9, 7/9, 2/9, 5/9, 8/9, 1/27\n\nBase 4\n0, 1/4, 1/2, 3/4, 1/16, 5/16, 9/16, 13/16, 1/8, 3/8\n\nBase 5\n0, 1/5, 2/5, 3/5, 4/5, 1/25, 6/25, 11/25, 16/25, 21/25\n```\n\nHere is a functional version that produces the same output:\n\n```\nsub vdc($value, $base = 2) {\n    my @values = $value, { $_ div $base } ... 0;\n    my @denoms = $base,  { $_  *  $base } ... *;\n    [+] do for (flat @values Z @denoms) -> $v, $d {\n        $v mod $base / $d;\n    }\n}\n\n```\n\nWe first define two sequences, one finite, one infinite.\nWhen we zip those sequences together, the finite sequence terminates the loop (which, since a Raku loop returns all its values, is merely another way of writing a map).\nWe then sum with [+], a reduction of the + operator.\n(We could have in-lined the sequences or used a traditional map operator, but this way seems more readable than the typical FP solution.)\nThe do is necessary to introduce a statement where a term is expected, since Raku distinguishes \"sentences\" from \"noun phrases\" as a natural language might."}]}
{"messages": [{"role": "user", "content": "The sequence is generated by following this pseudo-code:\n\n```\nA:  The first term is zero.\n    Repeatedly apply:\n        If the last term is *new* to the sequence so far then:\nB:          The next term is zero.\n        Otherwise:\nC:          The next term is how far back this last term occured previously.\n\n```\n\nExample\n\nUsing A:\n\n:   `0`\n\nUsing B:\n\n:   `0 0`\n\nUsing C:\n\n:   `0 0 1`\n\nUsing B:\n\n:   `0 0 1 0`\n\nUsing C: (zero last occurred two steps back - before the one)\n\n:   `0 0 1 0 2`\n\nUsing B:\n\n:   `0 0 1 0 2 0`\n\nUsing C: (two last occurred two steps back - before the zero)\n\n:   `0 0 1 0 2 0 2 2`\n\nUsing C: (two last occurred one step back)\n\n:   `0 0 1 0 2 0 2 2 1`\n\nUsing C: (one last appeared six steps back)\n\n:   `0 0 1 0 2 0 2 2 1 6`\n\n...\n\nTask\n\n1. Create a function/procedure/method/subroutine/... to generate the Van Eck sequence of numbers.\n2. Use it to display here, on this page:\n\n:   1. The first ten terms of the sequence.\n    2. Terms 991 - to - 1000 of the sequence.\n\nReferences\n\n* Don't Know (the Van Eck Sequence) - Numberphile video.\n* Wikipedia Article: Van Eck's Sequence.\n* OEIS sequence: A181391."}, {"role": "assistant", "content": "(formerly Perl 6)\nThere is not **a** Van Eck sequence, rather a series of related sequences that differ in their starting value. This task is nominally for the sequence starting with the value 0. This Raku implementation will handle any integer starting value.\n\nSpecifically handles:\n\n* OEIS:A181391 - Van Eck sequence starting with 0\n* OEIS:A171911 - Van Eck sequence starting with 1\n* OEIS:A171912 - Van Eck sequence starting with 2\n* OEIS:A171913 - Van Eck sequence starting with 3\n* OEIS:A171914 - Van Eck sequence starting with 4\n* OEIS:A171915 - Van Eck sequence starting with 5\n* OEIS:A171916 - Van Eck sequence starting with 6\n* OEIS:A171917 - Van Eck sequence starting with 7\n* OEIS:A171918 - Van Eck sequence starting with 8\n\namong others.\n\nImplemented as lazy, extendable lists.\n\n```\nsub n-van-ecks ($init) {\n    $init, -> $i, {\n        state %v;\n        state $k;\n        $k++;\n        my $t  = %v{$i}.defined ?? $k - %v{$i} !! 0;\n        %v{$i} = $k;\n        $t\n    } ... *\n}\n\nfor <\n    A181391 0\n    A171911 1\n    A171912 2\n    A171913 3\n    A171914 4\n    A171915 5\n    A171916 6\n    A171917 7\n    A171918 8\n> -> $seq, $start {\n\n    my @seq = n-van-ecks($start);\n\n    # The task\n    put qq:to/END/\n\n    Van Eck sequence OEIS:$seq; with the first term: $start\n            First 10 terms: {@seq[^10]}\n    Terms 991 through 1000: {@seq[990..999]}\n    END\n}\n\n```\n\nOutput:\n\n```\nVan Eck sequence OEIS:A181391; with the first term: 0\n        First 10 terms: 0 0 1 0 2 0 2 2 1 6\nTerms 991 through 1000: 4 7 30 25 67 225 488 0 10 136\n\n\nVan Eck sequence OEIS:A171911; with the first term: 1\n        First 10 terms: 1 0 0 1 3 0 3 2 0 3\nTerms 991 through 1000: 0 6 53 114 302 0 5 9 22 71\n\n\nVan Eck sequence OEIS:A171912; with the first term: 2\n        First 10 terms: 2 0 0 1 0 2 5 0 3 0\nTerms 991 through 1000: 8 92 186 0 5 19 41 413 0 5\n\n\nVan Eck sequence OEIS:A171913; with the first term: 3\n        First 10 terms: 3 0 0 1 0 2 0 2 2 1\nTerms 991 through 1000: 5 5 1 17 192 0 6 34 38 179\n\n\nVan Eck sequence OEIS:A171914; with the first term: 4\n        First 10 terms: 4 0 0 1 0 2 0 2 2 1\nTerms 991 through 1000: 33 410 0 6 149 0 3 267 0 3\n\n\nVan Eck sequence OEIS:A171915; with the first term: 5\n        First 10 terms: 5 0 0 1 0 2 0 2 2 1\nTerms 991 through 1000: 60 459 0 7 13 243 0 4 10 211\n\n\nVan Eck sequence OEIS:A171916; with the first term: 6\n        First 10 terms: 6 0 0 1 0 2 0 2 2 1\nTerms 991 through 1000: 6 19 11 59 292 0 6 6 1 12\n\n\nVan Eck sequence OEIS:A171917; with the first term: 7\n        First 10 terms: 7 0 0 1 0 2 0 2 2 1\nTerms 991 through 1000: 11 7 2 7 2 2 1 34 24 238\n\n\nVan Eck sequence OEIS:A171918; with the first term: 8\n        First 10 terms: 8 0 0 1 0 2 0 2 2 1\nTerms 991 through 1000: 16 183 0 6 21 10 249 0 5 48\n```"}]}
{"messages": [{"role": "user", "content": "A decidely non-challenging task to highlight a potential difference between programming languages.\n\nUsing a straightforward longhand loop as in the JavaScript and Phix examples below, show the locations of elements which are identical to the immediately preceding element in {1,2,2,3,4,4,5}. The (non-blank) results may be 2,5 for zero-based or 3,6 if one-based.   \nThe purpose is to determine whether variable declaration (in block scope) resets the contents on every iteration.  \nThere is no particular judgement of right or wrong here, just a plain-speaking statement of subtle differences.  \nShould your first attempt bomb with \"unassigned variable\" exceptions, feel free to code it as (say)\n\n```\n // int prev // crashes with unassigned variable\n    int prev = -1 // predictably no output\n\n```\n\nIf your programming language does not support block scope (eg assembly) it should be omitted from this task."}, {"role": "assistant", "content": "By default, Raku variables need a prefix sigil indicating the storage / interface, and a scope declarator to indicate the variables' accessibility. The vast majority of the time, variables are declared with a \"my\" scope declarator that constrains them to the present block and any enclosed sub blocks. When a 'my' variable is declared inside a loop (block), a new independent instance of the variable is instantiated every time through.\n\n```\nmy @s = 1, 2, 2, 3, 4, 4, 5;\nloop (my $i = 0; $i < 7; $i += 1) {\n    my $curr = @s[$i];\n    my $prev;\n    if $i > 1 and $curr == $prev {\n        say $i;\n    }\n    $prev = $curr;\n}\n\n```\n\nYields:\n\n```\nUse of uninitialized value of type Any in numeric context\n  in block <unit> at var.p6 line 5\nUse of uninitialized value of type Any in numeric context\n  in block <unit> at var.p6 line 5\nUse of uninitialized value of type Any in numeric context\n  in block <unit> at var.p6 line 5\nUse of uninitialized value of type Any in numeric context\n  in block <unit> at var.p6 line 5\nUse of uninitialized value of type Any in numeric context\n  in block <unit> at var.p6 line 5\n```\n\nLots of warnings but nothing else. If we suppress the warnings:\n\n```\nmy @s = 1, 2, 2, 3, 4, 4, 5;\nquietly loop (my $i = 0; $i < 7; $i += 1) {\n    my $curr = @s[$i];\n    my $prev;\n    if $i > 1 and $curr == $prev {\n        say $i;\n    }\n    $prev = $curr;\n}\n\n```\n\nNo output.\n\nWe can however, declare the variable with an \"our\" scope, which effectively makes it a package global. Use of 'our' scoping is discouraged except in a few very specific situations. It \"works\" (for some value of works), but pollutes the namespace. The 'our' variable will trample any other instance of a variable with that name anywhere in the program in any other scope.\n\n```\nmy @s = 1, 2, 2, 3, 4, 4, 5;\nloop (my $i = 0; $i < 7; $i += 1) {\n    my $curr = @s[$i];\n    our $prev;\n    if $i > 1 and $curr == $prev {\n        say $i;\n    }\n    $prev = $curr;\n}\n\n```\n\nYields:\n\n```\n2\n5\n```\n\nA better solution is to declare a state variable. A 'state' variable is essentially scoped similar to a 'my' variable (visible only inside the block), but is persistent across calls.\n\n```\nmy @s = 1, 2, 2, 3, 4, 4, 5;\nloop (my $i = 0; $i < 7; $i += 1) {\n    my $curr = @s[$i];\n    state $prev;\n    if $i > 1 and $curr == $prev {\n        say $i;\n    }\n    $prev = $curr;\n}\n\n```\n\nYields:\n\n```\n2\n5\n```\n\nIf you really want to run fast and loose, and bypass all the protections Raku builds in, you can turn off strict scoping with a pragma. This is ***heavily*** discouraged. Anyone trying to release code with strictures turned off will receive some degree of side-eye... but just because something is a bad idea in general doesn't mean Raku forbids it. The Raku mindset is \"Make it difficult to make casual mistakes but make it possible to bypass those protections if you have the need.\"\n\nNo scope declarators at all. Every variable is a global. Bad idea. Do not do this casually.\n\n```\nno strict;\n@s = 1, 2, 2, 3, 4, 4, 5;\nloop ($i = 0; $i < 7; $i += 1) {\n    $curr = @s[$i];\n    if $i > 1 and $curr == $prev {\n        say $i;\n    }\n    $prev = $curr;\n}\n\n```\n\nYields:\n\n```\n2\n5\n```"}]}
{"messages": [{"role": "user", "content": "Demonstrate how to get the size of a variable.\n\nSee also: Host introspection"}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku tries to avoid generic terms such as \"size\" and \"length\", instead providing methods that are expressed in terms of the units appropriate to the abstraction level.\n\n```\n# Textual strings are measured in characters (graphemes)\nmy $string = \"abc\";\n\n# Arrays are measured in elements.\nsay $string.chars;     # 3\nmy @array = 1..5;\nsay @array.elems;      # 5\n\n# Buffers may be viewed either as a byte-string or as an array of elements.\nmy $buffer = '#56997; means \"four dragons\".'.encode('utf8');\nsay $buffer.bytes;     # 26\nsay $buffer.elems;     # 26\n\n```\n\nRaku's Int type is arbitrary sized, and therefore the abstract size of the integer depends on how many bits are needed to represent it. While the internal representation is likely to be \"chunky\" by 32 or 64 bits, this is considered an implementation detail and is not revealed to the programmer.\n\nNative types such as int64 or num32 are of fixed size; Raku supports representational polymorphism of such types (and compositions of such types) through a pluggable meta-object protocol providing \"knowhow\" objects for the various representations. Currently the NativeHOW knowhow may be interrogated for the bit sizes of native types, but this is officially outside the purview of the language itself (so far)."}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate how to specify the minimum size of a variable or a data type."}, {"role": "assistant", "content": "(formerly Perl 6)\nIn Raku, normal user-facing types (Int, Rat, Str, Array, Hash) are all auto-sizing, so there is no need to specify a minimum size for them. (Floating point, known as \"Num\", defaults to a machine double.) For storage declarations, native storage types (starting with a lowercase letter) may also be specified, in which case the required bit size is part of the type name: int16, uint8 (aka \"byte\"), num32 (a \"float\"), complex64 (made of two num64's), etc. More generally, such types are created through an API supporting representational polymorphism, in this case, the NativeHOW representation, when provides methods to set the size of a type; the actual allocation calculation happens when such generic types are composed into a class instance representing the semantics of the effective type to the compiler and run-time system. But mostly this is not something users will concern themselves with directly.\n\nBy spec, arrays may be declared with dimensions of fixed size, but as of this writing, such arrays not yet implemented. An array of fixed size that returns elements of a native type will be stored compactly, and uses exactly the memory you'd think it should, (modulo alignment constraints between elements and any slop at the end due to your memory allocator)."}]}
{"messages": [{"role": "user", "content": "Implement some operations on variable-length quantities, at least including conversions from a normal number in the language to the binary representation of the variable-length quantity for that number, and *vice versa*. Any variants are acceptable.\n\nTask\n\nWith above operations,\n\n* convert these two numbers 0x200000 (2097152 in decimal) and 0x1fffff (2097151 in decimal) into sequences of octets (an eight-bit byte);\n* display these sequences of octets;\n* convert these sequences of octets back to numbers, and check that they are equal to original numbers."}, {"role": "assistant", "content": "(formerly Perl 6)\nvlq\\_encode() returns a string of encoded octets. vlq\\_decode() takes a string and returns a decimal number.\n\n```\nsub vlq_encode ($number is copy) {\n    my @vlq = (127 +& $number).fmt(\"%02X\");\n    $number +>= 7;\n    while ($number) {\n       @vlq.push: (128 +| (127 +& $number)).fmt(\"%02X\");\n       $number +>= 7; \n    }\n    @vlq.reverse.join: ':';\n}\n\nsub vlq_decode ($string) {\n    sum $string.split(':').reverse.map: {(:16($_) +& 127) +< (7 × $++)}\n}\n\n#test encoding and decoding\nfor (\n    0,   0xa,   123,   254,   255,   256,\n    257, 65534, 65535, 65536, 65537, 0x1fffff,\n    0x200000\n ) -> $testcase {\n    printf \"%8s %12s %8s\\n\", $testcase,\n      my $encoded = vlq_encode($testcase),\n      vlq_decode($encoded);\n}\n\n```\n\nOutput:\n\n```\n       0           00        0\n      10           0A       10\n     123           7B      123\n     254        81:7E      254\n     255        81:7F      255\n     256        82:00      256\n     257        82:01      257\n   65534     83:FF:7E    65534\n   65535     83:FF:7F    65535\n   65536     84:80:00    65536\n   65537     84:80:01    65537\n 2097151     FF:FF:7F  2097151\n 2097152  81:80:80:00  2097152\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nDemonstrate a language's methods of:\n\n:   :   :   * variable declaration\n            * initialization\n            * assignment\n            * datatypes\n            * scope\n            * referencing,     and\n            * other variable related facilities"}, {"role": "assistant", "content": "(formerly Perl 6)\nMuch of what is true for Perl 5 is also true for Raku. Some exceptions:\n\nThere are no typeglobs in Raku.\n\nAssigning an array to a scalar variable now makes that scalar variable a reference to the array:\n\n```\nmy @y = <A B C D>; # Array of strings 'A', 'B', 'C', and 'D'\nsay @y[2]; # the @-sigil requires the container to implement the role Positional\n@y[1,2] = 'x','y'; # that's where subscripts and many other things come from\nsay @y; # OUTPUT«[A x y D]␤» # we start to count at 0 btw.\n\nmy $x = @y; # $x is now a reference for the array @y\n\nsay $x[1]; # prints 'x' followed by a newline character\n\nmy Int $with-type-check; # type checks are enforced by the compiler\n\nmy Int:D $defined-i = 10; # definedness can also be asked for and default values are required in that case\n\nmy Int:D $after-midnight where * > 24 = 25; # SQL is fun and so is Raku\n\nmy \\bad = 'good'; # if you don't like sigils\nsay bad; # you don't have to use them\nsay \"this is quite bad\"; # but then string interpolation\nsay \"this is quite {bad}\" # becomes more wordy\n```\n\nLaziness is a big topic in Raku. Sometimes Raku programmers are so lazy, they can't even be bothered with giving variables names.\n\n```\nsay ++$; # this is an anonymous state variable\nsay ++$; # this is a different anonymous state variable, prefix:<++> forces it into numerical context and defaults it to 0\nsay $+=2 for 1..10; # here we do something useful with another anonymous variable\n\nsub foo { $^a * $^b } # for positional arguments we often can't be bothered to declare them or to give them fancy names\nsay foo 3, 4;\n```\n\nOutput:\n\n```\n1\n1\n2\n4\n6\n12\n```\n\n(Includes code modified from http://design.raku.org/S02.html#Built-In\\_Data\\_Types. See this reference for more details.)"}]}
{"messages": [{"role": "user", "content": "A fixed-point combinator is a higher order function \n\nfix\n{\\displaystyle {\\displaystyle \\operatorname {fix} }}\n that returns the fixed point of its argument function. If the function \n\nf\n{\\displaystyle {\\displaystyle f}}\n has one or more fixed points, then \n\nfix\n⁡\nf\n=\nf\n(\nfix\n⁡\nf\n)\n{\\displaystyle {\\displaystyle \\operatorname {fix} f=f(\\operatorname {fix} f)}}\n.\n\nYou can extend a fixed-point combinator to find the fixed point of the i-th function out of n given functions: \n\nfix\n\ni\n,\nn\n⁡\n\nf\n\n1\n…\n\nf\n\nn\n=\n\nf\n\ni\n(\n\nfix\n\n1\n,\nn\n⁡\n\nf\n\n1\n…\n\nf\n\nn\n)\n…\n(\n\nfix\n\nn\n,\nn\n⁡\n\nf\n\n1\n…\n\nf\n\nn\n)\n{\\displaystyle {\\displaystyle \\operatorname {fix} \\_{i,n}f\\_{1}\\dots f\\_{n}=f\\_{i}(\\operatorname {fix} \\_{1,n}f\\_{1}\\dots f\\_{n})\\dots (\\operatorname {fix} \\_{n,n}f\\_{1}\\dots f\\_{n})}}\n\nTask\n\nYour task is to implement a variadic fixed-point combinator \n\nfix\n\n∗\n{\\displaystyle {\\displaystyle \\operatorname {fix} ^{\\*}}}\n that finds and returns the fixed points of all given functions: \n\nfix\n\n∗\n⁡\n\nf\n\n1\n…\n\nf\n\nn\n=\n⟨\n\nfix\n\n1\n,\nn\n⁡\n\nf\n\n1\n…\n\nf\n\nn\n,\n…\n,\n\nfix\n\nn\n,\nn\n⁡\n\nf\n\n1\n…\n\nf\n\nn\n⟩\n{\\displaystyle {\\displaystyle \\operatorname {fix} ^{\\*}f\\_{1}\\dots f\\_{n}=\\langle \\operatorname {fix} \\_{1,n}f\\_{1}\\dots f\\_{n},\\dots ,\\operatorname {fix} \\_{n,n}f\\_{1}\\dots f\\_{n}\\rangle }}\n\nThe variadic input and output may be implemented using any feature of the language (e.g. using lists).\n\nIf possible, try not to use explicit recursion and implement the variadic fixed-point combinator using a fixed-point combinator like the Y combinator.\n\nAlso try to come up with examples where \n\nfix\n\n∗\n{\\displaystyle {\\displaystyle \\operatorname {fix} ^{\\*}}}\n could actually be somewhat useful.\n\nRelated tasks\n\n* Y combinator\n* Variadic function\n\nSee also\n\n* Mayer Goldberg: A Variadic Extension of Curry’s Fixed-Point Combinator"}, {"role": "assistant", "content": "**Translation of**: Julia\n\n**Translation of**: Python\n\n```\n# 20240726 Raku programming solution\n\nmy &Y = -> \\a { a.map: -> \\f { -> &x { -> { x(Y(a)) } }(f) } }\n             \nmy \\even_odd_fix = -> \\f { -> \\n { n == 0  or f[1]()(n - 1) } },\n                   -> \\f { -> \\n { n != 0 and f[0]()(n - 1) } };\n\nmy \\collatz_fix = -> \\f { -> \\n, \\d { n == 1 ?? d !! f[(n % 2)+1]()(n, d+1) } },\n                  -> \\f { -> \\n, \\d { f[0]()( n div 2, d ) } }, \n                  -> \\f { -> \\n, \\d { f[0]()(   3*n+1, d ) } };\n\nmy \\even_odd = Y(even_odd_fix).map: -> &f { f() }; # or { $_() }\nmy &collatz  = Y(collatz_fix)[0]();\n\nfor 1..10 -> \\i {\n   my ( \\e, \\o, \\c ) = even_odd[0](i), even_odd[1](i), collatz(i, 0);\n   printf \"%2d: Even: %s  Odd: %s  Collatz: %s\\n\", i, e, o, c\n}\n\n```\n\nYou may Attempt This Online!"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a function which takes in a variable number of arguments and prints each one on its own line.\n\nAlso show, if possible in your language, how to call the function on a list of arguments constructed at runtime.\n\nFunctions of this type are also known as Variadic Functions.\n\nRelated task\n\n* Call a function"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version #25 \"Minneapolis\"\n\nIf a subroutine has no formal parameters but mentions the variables `@_` or `%_` in its body, it will accept arbitrary positional or keyword arguments, respectively. You can even use both in the same function.\n\n```\nsub foo {\n   .say for @_;\n   say .key, ': ', .value for %_;\n}\n\nfoo 1, 2, command => 'buckle my shoe',\n    3, 4, order => 'knock at the door';\n```\n\nThis prints:\n\n```\n1\n2\n3\n4\ncommand: buckle my shoe\norder: knock at the door\n```\n\nRaku also supports slurpy arrays and hashes, which are formal parameters that consume extra positional and keyword arguments like `@_` and `%_`. You can make a parameter slurpy with the `*` twigil. This implementation of `&foo` works just like the last:\n\n```\nsub foo (*@positional, *%named) {\n   .say for @positional;\n   say .key, ': ', .value for %named;\n}\n```\n\nUnlike in Perl 5, arrays and hashes aren't flattened automatically. Use the `|` operator to flatten:\n\n```\nfoo |@ary, |%hsh;\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a Vector class (or a set of functions) that models a Physical Vector. The four basic operations and a *pretty print* function should be implemented.\n\nThe Vector may be initialized in any reasonable way.\n\n* Start and end points, and direction\n* Angular coefficient and value (length)\n\nThe four operations to be implemented are:\n\n* Vector  **+**  Vector addition\n* Vector  **-**  Vector subtraction\n* Vector  **\\***  scalar multiplication\n* Vector  **/**  scalar division"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nclass Vector {\n    has Real $.x;\n    has Real $.y;\n\n    multi submethod BUILD (:$!x!, :$!y!) {\n        *\n    }\n    multi submethod BUILD (:$length!, :$angle!) {\n        $!x = $length * cos $angle;\n        $!y = $length * sin $angle;\n    }\n    multi submethod BUILD (:from([$x1, $y1])!, :to([$x2, $y2])!) {\n        $!x = $x2 - $x1;\n        $!y = $y2 - $y1;\n    }\n    \n    method length { sqrt $.x ** 2 + $.y ** 2 }\n    method angle  { atan2 $.y, $.x }\n    \n    method add      ($v) { Vector.new(x => $.x + $v.x,  y => $.y + $v.y) }\n    method subtract ($v) { Vector.new(x => $.x - $v.x,  y => $.y - $v.y) }\n    method multiply ($n) { Vector.new(x => $.x * $n,    y => $.y * $n  ) }\n    method divide   ($n) { Vector.new(x => $.x / $n,    y => $.y / $n  ) }\n    \n    method gist { \"vec[$.x, $.y]\" }\n}\n\nmulti infix:<+>  (Vector $v, Vector $w) is export { $v.add: $w }\nmulti infix:<->  (Vector $v, Vector $w) is export { $v.subtract: $w }\nmulti prefix:<-> (Vector $v)            is export { $v.multiply: -1 }\nmulti infix:<*>  (Vector $v, $n)        is export { $v.multiply: $n }\nmulti infix:</>  (Vector $v, $n)        is export { $v.divide: $n }\n\n\n#####[ Usage example: ]#####\n\nsay my $u = Vector.new(x => 3, y => 4);                #: vec[3, 4]\nsay my $v = Vector.new(from => [1, 0], to => [2, 3]);  #: vec[1, 3]\nsay my $w = Vector.new(length => 1, angle => pi/4);    #: vec[0.707106781186548, 0.707106781186547]\n\nsay $u.length;                                         #: 5\nsay $u.angle * 180/pi;                                 #: 53.130102354156\n\nsay $u + $v;                                           #: vec[4, 7]\nsay $u - $v;                                           #: vec[2, 1]\nsay -$u;                                               #: vec[-3, -4]\nsay $u * 10;                                           #: vec[30, 40]\nsay $u / 2;                                            #: vec[1.5, 2]\n\n```"}]}
{"messages": [{"role": "user", "content": "A vector is defined as having three dimensions as being represented by an ordered collection of three numbers:   (X, Y, Z).\n\nIf you imagine a graph with the   **x**   and   **y**   axis being at right angles to each other and having a third,   **z**   axis coming out of the page, then a triplet of numbers,   (X, Y, Z)   would represent a point in the region,   and a vector from the origin to the point.\n\nGiven the vectors:\n\n```\n        A = (a1,  a2,  a3) \n        B = (b1,  b2,  b3) \n        C = (c1,  c2,  c3) \n\n```\n\nthen the following common vector products are defined:\n\n* **The dot product**       (a scalar quantity)\n\n:   :   :   :   A • B = a1b1   +   a2b2   +   a3b3\n\n* **The cross product**       (a vector quantity)\n\n:   :   :   :   A x B = (a2b3  -   a3b2,     a3b1   -   a1b3,     a1b2   -   a2b1)\n\n* **The scalar triple product**       (a scalar quantity)\n\n:   :   :   :   A • (B x C)\n\n* **The vector triple product**       (a vector quantity)\n\n:   :   :   :   A x (B x C)\n\nTask\n\nGiven the three vectors:\n\n```\n        a = ( 3,    4,    5)\n        b = ( 4,    3,    5)\n        c = (-5,  -12,  -13)\n\n```\n\n1. Create a named function/subroutine/method to compute the dot product of two vectors.\n2. Create a function to compute the cross product of two vectors.\n3. Optionally create a function to compute the scalar triple product of three vectors.\n4. Optionally create a function to compute the vector triple product of three vectors.\n5. Compute and display: `a • b`\n6. Compute and display: `a x b`\n7. Compute and display: `a • (b x c)`, the scalar triple product.\n8. Compute and display: `a x (b x c)`, the vector triple product.\n\nReferences\n\n* A starting page on Wolfram MathWorld is   Vector Multiplication .\n* Wikipedia   dot product.\n* Wikipedia   cross product.\n* Wikipedia   triple product.\n\nRelated tasks\n\n* Dot product\n* Quaternion type"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-11-24\n\n```\nsub infix:<⋅> { [+] @^a »*« @^b }\n\nsub infix:<⨯>([$a1, $a2, $a3], [$b1, $b2, $b3]) {\n    [ $a2*$b3 - $a3*$b2,\n      $a3*$b1 - $a1*$b3,\n      $a1*$b2 - $a2*$b1 ];\n}\n\nsub scalar-triple-product { @^a ⋅ (@^b ⨯ @^c) }\nsub vector-triple-product { @^a ⨯ (@^b ⨯ @^c) }\n\nmy @a = <3 4 5>;\nmy @b = <4 3 5>;\nmy @c = <-5 -12 -13>;\n\nsay (:@a, :@b, :@c);\nsay \"a ⋅ b = { @a ⋅ @b }\";\nsay \"a ⨯ b = <{ @a ⨯ @b }>\";\nsay \"a ⋅ (b ⨯ c) = { scalar-triple-product(@a, @b, @c) }\";\nsay \"a ⨯ (b ⨯ c) = <{ vector-triple-product(@a, @b, @c) }>\";\n\n```\n\nOutput:\n\n```\n(\"a\" => [\"3\", \"4\", \"5\"], \"b\" => [\"4\", \"3\", \"5\"], \"c\" => [\"-5\", \"-12\", \"-13\"])\na ⋅ b = 49\na ⨯ b = <5 5 -7>\na ⋅ (b ⨯ c) = 6\na ⨯ (b ⨯ c) = <-267 204 -3>\n```"}]}
{"messages": [{"role": "user", "content": "Description\n\nThe Verhoeff algorithm is a checksum formula for error detection developed by the Dutch mathematician Jacobus Verhoeff and first published in 1969. It was the first decimal check digit algorithm which detects all single-digit errors, and all transposition errors involving two adjacent digits, which was at the time thought impossible with such a code.\n\nAs the workings of the algorithm are clearly described in the linked Wikipedia article they will not be repeated here.\n\nTask\n\nWrite routines, methods, procedures etc. in your language to generate a Verhoeff checksum digit for non-negative integers of any length and to validate the result. A combined routine is also acceptable.\n\nThe more mathematically minded may prefer to generate the 3 tables required from the description provided rather than to hard-code them.\n\nWrite your routines in such a way that they can optionally display digit by digit calculations as in the Wikipedia example.\n\nUse your routines to calculate check digits for the integers: **236**, **12345** and **123456789012** and then validate them. Also attempt to validate the same integers if the check digits in all cases were **9** rather than what they actually are.\n\nDisplay digit by digit calculations for the first two integers but not for the third.\n\nRelated task\n\n* Damm algorithm"}, {"role": "assistant", "content": "Generate the tables rather than hard coding, They're not all that complex.\n\n```\nmy @d = [^10] xx 5;\n@d[$_][^5].=rotate($_), @d[$_][5..*].=rotate($_) for 1..4;\npush @d: [@d[$_].reverse] for flat 1..4, 0;\n\nmy @i = 0,4,3,2,1,5,6,7,8,9;\n\nmy %h = flat (0,1,5,8,9,4,2,7,0).rotor(2 =>-1).map({.[0]=>.[1]}), 6=>3, 3=>6;\nmy @p = [^10],;\n@p.push: [@p[*-1].map: {%h{$_}}] for ^7;\n\nsub checksum (Int $int where * ≥ 0, :$verbose = True ) {\n    my @digits = $int.comb;\n    say \"\\nCheckdigit calculation for $int:\";\n    say \" i  ni  p(i, ni)  c\" if $verbose;\n    my ($i, $p, $c) = 0 xx 3;\n    say \" $i   0      $p     $c\" if $verbose;\n    for @digits.reverse {\n        ++$i;\n        $p = @p[$i % 8][$_];\n        $c = @d[$c; $p];\n        say \"{$i.fmt('%2d')}   $_      $p     $c\" if $verbose;\n    }\n    say \"Checkdigit: {@i[$c]}\";\n    +($int ~ @i[$c]);\n}\n\nsub validate (Int $int where * ≥ 0, :$verbose = True) {\n    my @digits = $int.comb;\n    say \"\\nValidation calculation for $int:\";\n    say \" i  ni  p(i, ni)  c\" if $verbose;\n    my ($i, $p, $c) = 0 xx 3;\n    for @digits.reverse {\n        $p = @p[$i % 8][$_];\n        $c = @d[$c; $p];\n        say \"{$i.fmt('%2d')}   $_      $p     $c\" if $verbose;\n        ++$i;\n    }\n    say \"Checkdigit: {'in' if $c}correct\";\n}\n\n## TESTING\n\nfor 236, 12345, 123456789012 -> $int {\n    my $check = checksum $int, :verbose( $int.chars < 8 );\n    validate $check, :verbose( $int.chars < 8 );\n    validate +($check.chop ~ 9), :verbose( $int.chars < 8 );\n}\n\n```\n\nOutput:\n\n```\nCheckdigit calculation for 236:\n i  ni  p(i, ni)  c\n 0   0      0     0\n 1   6      3     3\n 2   3      3     1\n 3   2      1     2\nCheckdigit: 3\n\nValidation calculation for 2363:\n i  ni  p(i, ni)  c\n 0   3      3     3\n 1   6      3     1\n 2   3      3     4\n 3   2      1     0\nCheckdigit: correct\n\nValidation calculation for 2369:\n i  ni  p(i, ni)  c\n 0   9      9     9\n 1   6      3     6\n 2   3      3     8\n 3   2      1     7\nCheckdigit: incorrect\n\nCheckdigit calculation for 12345:\n i  ni  p(i, ni)  c\n 0   0      0     0\n 1   5      8     8\n 2   4      7     1\n 3   3      6     7\n 4   2      5     2\n 5   1      2     4\nCheckdigit: 1\n\nValidation calculation for 123451:\n i  ni  p(i, ni)  c\n 0   1      1     1\n 1   5      8     9\n 2   4      7     2\n 3   3      6     8\n 4   2      5     3\n 5   1      2     0\nCheckdigit: correct\n\nValidation calculation for 123459:\n i  ni  p(i, ni)  c\n 0   9      9     9\n 1   5      8     1\n 2   4      7     8\n 3   3      6     2\n 4   2      5     7\n 5   1      2     5\nCheckdigit: incorrect\n\nCheckdigit calculation for 123456789012:\nCheckdigit: 0\n\nValidation calculation for 1234567890120:\nCheckdigit: correct\n\nValidation calculation for 1234567890129:\nCheckdigit: incorrect\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite a function to determine whether a given set of frequency counts could plausibly have come from a uniform distribution by using the\nχ\n2\n{\\displaystyle {\\displaystyle \\chi ^{2}}}\ntest with a significance level of 5%.\n\nThe function should return a boolean that is true if and only if the distribution is one that a uniform distribution (with appropriate number of degrees of freedom) may be expected to produce.\n\nNote: normally a two-tailed test would be used for this kind of problem.\n\nReference\n:   * an entry at the MathWorld website:   chi-squared distribution.\n\nRelated task\n:   * Statistics/Chi-squared\\_distribution"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nFor the incomplete gamma function we use a series expansion related to Kummer's confluent hypergeometric function\n(see http://en.wikipedia.org/wiki/Incomplete\\_gamma\\_function#Evaluation\\_formulae). The gamma function is calculated\nin closed form, as we only need its value at integers and half integers.\n\n```\nsub incomplete-γ-series($s, $z) {\n    my \\numers = $z X** 1..*;\n    my \\denoms = [\\*] $s X+ 1..*;\n    my $M = 1 + [+] (numers Z/ denoms) ... * < 1e-6;\n    $z**$s / $s * exp(-$z) * $M;\n}\n \nsub postfix:<!>(Int $n) { [*] 2..$n }\n \nsub Γ-of-half(Int $n where * > 0) {\n    ($n %% 2) ?? (($_-1)!                            given  $n    div 2)\n              !! ((2*$_)! / (4**$_ * $_!) * sqrt(pi) given ($n-1) div 2);\n}\n \n# degrees of freedom constrained due to numerical limitations\nsub chi-squared-cdf(Int $k where 1..200, $x where * >= 0) {\n    my $f = $k < 20 ?? 20 !! 10;\n    given $x {\n        when 0                    { 0.0 }\n        when * < $k + $f*sqrt($k) { incomplete-γ-series($k/2, $x/2) / Γ-of-half($k) }\n        default                   { 1.0 }\n    }\n}\n \nsub chi-squared-test(@bins, :$significance = 0.05) {\n    my $n = +@bins;\n    my $N = [+] @bins;\n    my $expected = $N / $n;\n    my $chi-squared = [+] @bins.map: { ($^bin - $expected)**2 / $expected }\n    my $p-value = 1 - chi-squared-cdf($n-1, $chi-squared);\n    return (:$chi-squared, :$p-value, :uniform($p-value > $significance));\n}\n \nfor [< 199809 200665 199607 200270 199649 >],\n    [< 522573 244456 139979  71531  21461 >]\n    -> $dataset\n{\n    my %t = chi-squared-test($dataset);\n    say 'data: ', $dataset;\n    say \"χ² = {%t<chi-squared>}, p-value = {%t<p-value>.fmt('%.4f')}, uniform = {%t<uniform>}\";\n}\n\n```\n\nOutput:\n\n```\ndata: 199809 200665 199607 200270 199649\nχ² = 4.14628, p-value = 0.3866, uniform = True\ndata: 522573 244456 139979 71531 21461\nχ² = 790063.27594, p-value = 0.0000, uniform = False\n```"}]}
{"messages": [{"role": "user", "content": "This task is an adjunct to Seven-sided dice from five-sided dice.\n\nTask\n\nCreate a function to check that the random integers returned from a small-integer generator function have uniform distribution.\n\nThe function should take as arguments:\n\n* The function (or object) producing random integers.\n* The number of times to call the integer generator.\n* A 'delta' value of some sort that indicates how close to a flat distribution is close enough.\n\nThe function should produce:\n\n* Some indication of the distribution achieved.\n* An 'error' if the distribution is not flat enough.\n\nShow the distribution checker working when the produced distribution is flat enough and when it is not. (Use a generator from Seven-sided dice from five-sided dice).\n\nSee also:\n\n* Verify distribution uniformity/Chi-squared test"}, {"role": "assistant", "content": "(formerly Perl 6)\nSince the tested function is rolls of a 7 sided die, the test numbers are magnitudes of 10x bumped up to the closest multiple of 7. This reduces spurious error from there not being an integer expected value.\n\n```\nmy $d7 = 1..7;\nsub roll7 { $d7.roll };\n\nmy $threshold = 3;\n\nfor 14, 105, 1001, 10003, 100002, 1000006 ->  $n\n  { dist( $n, $threshold,  &roll7 ) };\n\n\nsub dist ( $n is copy, $threshold, &producer ) {\n    my @dist;\n    my $expect = $n / 7;\n    say \"Expect\\t\",$expect.fmt(\"%.3f\");\n    \n    loop ($_ = $n; $n; --$n) { @dist[&producer()]++; }\n     \n    for @dist.kv -> $i, $v is copy {\n        next unless $i;\n        $v //= 0;\n        my $pct = ($v - $expect)/$expect*100;\n        printf \"%d\\t%d\\t%+.2f%% %s\\n\", $i, $v, $pct,\n          ($pct.abs > $threshold ?? '- skewed' !! '');\n    }\n    say '';\n}\n\n```\n\nSample output:\n\n```\nExpect  2.000\n1       2       +0.00%\n2       3       +50.00% - skewed\n3       2       +0.00%\n4       2       +0.00%\n5       3       +50.00% - skewed\n6       0       -100.00% - skewed\n7       2       +0.00%\n\nExpect  15.000\n1       15      +0.00%\n2       17      +13.33% - skewed\n3       13      -13.33% - skewed\n4       16      +6.67% - skewed\n5       14      -6.67% - skewed\n6       16      +6.67% - skewed\n7       14      -6.67% - skewed\n\nExpect  143.000\n1       134     -6.29% - skewed\n2       142     -0.70%\n3       141     -1.40%\n4       137     -4.20% - skewed\n5       142     -0.70%\n6       170     +18.88% - skewed\n7       135     -5.59% - skewed\n\nExpect  1429.000\n1       1396    -2.31%\n2       1468    +2.73%\n3       1405    -1.68%\n4       1442    +0.91%\n5       1453    +1.68%\n6       1417    -0.84%\n7       1422    -0.49%\n\nExpect  14286.000\n1       14222   -0.45%\n2       14320   +0.24%\n3       14326   +0.28%\n4       14425   +0.97%\n5       14140   -1.02%\n6       14275   -0.08%\n7       14294   +0.06%\n\nExpect  142858.000\n1       142510  -0.24%\n2       142436  -0.30%\n3       142438  -0.29%\n4       143152  +0.21%\n5       142905  +0.03%\n6       143232  +0.26%\n7       143333  +0.33%\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n:   :   1. Draw at least 20 rectangles with a common center, to be more precise, the circumcenter of all the rectangles must coincide. None of the rectangles must touch or intersect any other rectangle.\n        2. Animate the colours of the rectangles by *fading in* the colour from the outermost rectangle to the innermost.\n        3. The animation loop can continue for a definite number of iterations or forever.\n\nCreate Vibrating rectangles"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.06\n\n### ANSI graphics\n\nOk. The task description is essentially non-existent. In looking at the reference implementation (Ring) it seems like we are supposed to draw a series of concentric rectangles and then alter the colors step-wise. No actual vibration apparent.\n\nCould fire up a GUI but WTH, let's try it at a command line with ANSI.\n\nDraws a series of concentric rectangles then rotates through the color palette. Every three seconds, chooses new random palette colors and reverses rotation direction.\n\n```\n# box drawing characters\nmy %r = :tl<┌>, :h<─>, :tr<┐>, :v<│>, :bl<└>, :br<┘>;\n\nmy @colors = « \\e[1;31m \\e[1;94m \\e[1;33m \\e[1;35m \\e[1;36m \\e[1;32m \\e[1;34m »;\n\n# color palette\nmy @c = flat @colors[0] xx 12, @colors[3] xx 12, @colors[2] xx 12;\n\nprint \"\\e[?25l\"; # hide the cursor\n\nsignal(SIGINT).tap: {\n    print \"\\e[0H\\e[0J\\e[?25h\"; # clean up on exit\n    exit;\n}\n\nmy $rot = 1;\n\nmy @vibe;\n\nloop {\n    rect($_, 31-$_) for ^15;\n    display @vibe;\n    @c.=rotate($rot);\n    if ++$ %% 30 {\n        @c = |@colors.pick(3);\n        @c = sort(flat @c xx 12);\n        $rot *= -1;\n    }\n    sleep .1;\n}\n\nsub rect ($b, $e) {\n    @vibe[$b;$b..$e] = @c[$b % @c]~%r<tl>, |((%r<h>) xx ($e - $b - 1)), %r<tr>~\"\\e[0m\";\n    @vibe[$e;$b..$e] = @c[$b % @c]~%r<bl>, |((%r<h>) xx ($e - $b - 1)), %r<br>~\"\\e[0m\";\n    ($b ^..^ $e).map: { @vibe[$_;$b] = @vibe[$_;$e] = @c[$b % @c]~%r<v>~\"\\e[0m\" }\n}\n\nsub display (@rect) {\n    print \"\\e[0H\\e[0J\\n\\n\";\n    for @rect -> @row {\n        print \"\\t\\t\\t\";\n        print $_ // ' ' for @row;\n        print \"\\n\";\n    }\n}\n\n```\n\nSee: Vibrating rectangles (.gif image)\n\n### SDL Animation\n\nFully animated SDL2 graphics lib version. Will adjust rendered rectangles to fill resized windows. Hit the space bar to toggle palette rotation direction.\n\n```\nuse SDL2::Raw;\n\nmy $width  = 1200;\nmy $height = 800;\n\nSDL_Init(VIDEO);\n\nmy $window = SDL_CreateWindow(\n    'Vibrating rectangles',\n    SDL_WINDOWPOS_CENTERED_MASK,\n    SDL_WINDOWPOS_CENTERED_MASK,\n    $width, $height,\n    RESIZABLE\n);\n\nmy $render = SDL_CreateRenderer($window, -1, ACCELERATED +| PRESENTVSYNC);\n\nmy $event = SDL_Event.new;\n\nenum KEY_CODES (\n    K_SPACE  => 44,\n);\n\nmy $num = 80;\nmy @rgb = palette($num);\nmy ($cx, $cy);\nmy $dir = 1;\n\nmain: loop {\n    while SDL_PollEvent($event) {\n        my $casted_event = SDL_CastEvent($event);\n        given $casted_event {\n            when *.type == QUIT { last main }\n            when *.type == WINDOWEVENT {\n                if .event == 5 {\n                    $width  = .data1;\n                    $height = .data2;\n                }\n            }\n            when *.type == KEYDOWN {\n                if KEY_CODES(.scancode) -> $comm {\n                    given $comm {\n                        when 'K_SPACE'  { $dir *= -1; }\n                    }\n                }\n                #say .scancode; # unknown key pressed\n            }\n        }\n    }\n    ($cx, $cy) = $width div 2, $height div 2;\n\n    for 1..^$num {\n        my ($x, $y) = ($cx - ($width/2/$num*$_), $cy - ($height/2/$num*$_))».round;\n        my ($w, $h) = ($width/$num*$_, $height/$num*$_)».round;\n        SDL_SetRenderDrawColor($render, |@rgb[$_], 255);\n        SDL_RenderDrawRect($render, SDL_Rect.new(:x($x), :y($y), :w($w), :h($h)));\n    }\n    @rgb.=rotate($dir);\n    SDL_RenderPresent($render);\n    SDL_SetRenderDrawColor($render, 0, 0, 0, 0);\n    SDL_RenderClear($render);\n}\n\nSDL_Quit();\n\nsub palette ($l) { (^$l).map: { hsv2rgb(($_ * 360/$l % 360)/360, 1, 1).list } };\n\nsub hsv2rgb ( $h, $s, $v ){ # inputs normalized 0-1\n    my $c = $v * $s;\n    my $x = $c * (1 - abs( (($h*6) % 2) - 1 ) );\n    my $m = $v - $c;\n    my ($r, $g, $b) = do given $h {\n        when   0..^(1/6) { $c, $x, 0 }\n        when 1/6..^(1/3) { $x, $c, 0 }\n        when 1/3..^(1/2) { 0, $c, $x }\n        when 1/2..^(2/3) { 0, $x, $c }\n        when 2/3..^(5/6) { $x, 0, $c }\n        when 5/6..1      { $c, 0, $x }\n    }\n    ( $r, $g, $b ).map: ((*+$m) * 255).Int\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "The task is to demonstrate how to switch video display modes within the language. A brief description of the supported video modes would be useful."}, {"role": "assistant", "content": "(formerly Perl 6)\nRaku runs on several different operating systems over many different architectures so can not easily assume direct control over hardware. Instead, like most modern programming languages, it relies on the current OS and windowing system to provide APIs.\n\nHere is an example which will work for most Debian based Linuxs (and probably others) running some variant of X11 with a single active monitor.\n\n**Works with**: Rakudo version 2018.05\n\n```\nmy @info = QX('xrandr -q').lines;\n\n@info[0] ~~ /<?after 'current '>(\\d+) ' x ' (\\d+)/;\nmy $current = \"$0x$1\";\n\nmy @resolutions;\n@resolutions.push: $0 if $_ ~~ /^\\s+(\\d+'x'\\d+)/ for @info;\n\nQX(\"xrandr -s @resolutions[*-1]\");\nsay \"Current resolution {@resolutions[*-1]}.\";\nfor 9 ... 1 {\n    print \"\\rChanging back in $_ seconds...\";\n    sleep 1;\n}\nQX(\"xrandr -s $current\");\nsay \"\\rResolution returned to {$current}.     \";\n\n```"}]}
{"messages": [{"role": "user", "content": "Recreate the vidir utility in your favorite programming language.\n\nVidir is a bulk file renaming utility included in the moreutils package available for Linux and Linux-like operating systems.\n\nBasic operation involves:\n\n* Reading the file names from a directory into a text file.\n* Editing the text file with a third party editor to make bulk changes to file names (modify,delete).\n* Using the edited text file to then apply the desired changes to the file system.\n\nIn general, the filenames are typically written to the text file, one to a line with an identifying label (a unique integer in the originals case). The text file is edited as desired; file names changed, files moved, files removed, files added. Then the edited text file is used to apply the changes to the file system.\n\nIt is not required to support multiple operating systems. Make a note of which one(s) are supported.\n\nThere are many possible ways to enhance the utility but that is the basic functionality.\n\nSome possible enhancements:\n\n* Operate on directories other than the current directory.\n* Recursive directory search.\n* File input filtering.\n* File/Directory permissions detection.\n* Allow creation of files / directories.\n* Verbose operation.\n* Text editor selectable from the command line.\n* First party text editing.\n* Support multiple operating systems\n\nAt a minimum support file name modification and file removal in the current directory. Add as many enhancements as desired.\n\nSee also\n\n* Linux.com article covering moreutils / vidir"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.05\n\nThis is a fairly faithful recreation of the vidir utility with some extra \"enhancements\". It is set up to work seamlessly with Linux, OSX and most unix-like operating systems. Probably could be adapted for Windows too but won't work there as is.\n\nTakes several positional and/or named command line parameters:\n\n**Positionals:**\n\n* **path**, string, optional, defaults to the present directory (relative './').\n* **filter**, string, optional, defaults to none. A regex assertion you can use to filter the returned file names. E.G. **\\.txt$** (filenames ending with .txt extension)\n\n**Named:**\n\n* **-r** or **--recurse**, flag, optional, default False. Recurse into nested directories and process those files as well.\n* **-v** or **--verbose**, flag, optional, default False. Be chatty about what is going on when making changes.\n* **--e=whatever** or **--editor=whatever**, string, optional, defaults the default text editor. Pass in a command name to specify a specific editor: (E.G. **--editor=vim**)\n\nWill get a list of all file names from the specified director(y|ies), put them in a temporary file and open the text file with the default (or specified) text editor.\n\nEdit the file names or directory names in the text editor: add, remove, modify file names, then save the text file; all of the modifications made to the text file will be applied to the file system.\n\n**To edit a file name:** Just edit the file name, extension, whatever. **Warning!** There is nothing preventing you from using characters in the file name which will make it difficult to open, modify or delete the file. You can screw yourself quite easily if you make an effort. With great power comes great responsibility. The foot cannon is primed and loaded.\n\nIf you add a forward solidus (directory separator: **/**) to a filename, it will treat anything between separators as a directory name and **WILL CREATE** non-existent directories.\n\n**To move a file:** Edit the directory path. The file will be moved to the new path. Non-existing directories will be created.\n\n**To delete a file:** Delete the entire line (file name and identifier) in the text file.\n\n**To add a file:** Add a new line with a unique integer (need not be in any order), one or more tabs, then the new file path/name. May be a relative or absolute path.\n\nNotice that all of the above operations will fail to apply if you lack sufficient permissions for the affected files or directories.\n\n```\nuse Sort::Naturally;\nuse File::Temp;\n\nmy %*SUB-MAIN-OPTS = :named-anywhere;\n\nunit sub MAIN (\n    Str $path         = '.',    #= default $path\n    Str $filter       = '',     #= default file filter\n    Bool :r(:$recurse)= False,  #= recursion flag\n    Bool :v(:$verbose)= False,  #= verbose mode\n    Str :e(:$editor)  = $*DISTRO ~~ /'Darwin'/ ?? \"open\" !! \"xdg-open\"; #= default editor\n);\n\nmy $dir = $path;\n\n# fix up path if necessary\n$dir ~= '/' unless $dir.substr(*-1) eq '/';\n\n# check that path is reachable\ndie \"Can not find directory $dir\" unless $dir.IO.d;\n\n\nmy @files;\n\n# get files from that path\ngetdir( $dir, $filter );\n\n@files.= sort( &naturally );\n\n# set up a temp file and file handle\nmy ($filename, $filehandle) = tempfile :suffix('.vidir');\n\n# write the filenames to the tempfile\n@files.kv.map: { $filehandle.printf(\"%s\\t%s\\n\", $^k, $^v) };\n\n# flush the buffer to make sure all of the filenames have been written\n$filehandle.flush;\n\n# editor command\nmy $command = \"$editor $filename\";\n\n# start text editor; suppress STDERR, some editors complain about open files being deleted\nshell(\"$command 2> /dev/null\");\n\nreact {\n    # watch for file changes\n    whenever IO::Notification.watch-path($filename) {\n        # allow a short interval for the file to finish writing\n        sleep .1;\n\n        # read in changed file\n        my %changes = $filename.IO.lines.map( { my ($k, $v) = .split(/\\t+/); \"{$k.trim}\" => $v} );\n\n        # walk the filenames and make the desired changes\n        for ^@files -> $k {\n            if %changes{\"$k\"}:exists {\n                # name has changed, rename the file on disk\n                if (%changes{\"$k\"}) ne @files[$k] {\n                    # check to see that the desired directory exists\n                    checkdir %changes{\"$k\"};\n                    # notify and do it\n                    say \"Renaming: {@files[$k]} to \" ~ %changes{\"$k\"} if $verbose;\n                    rename @files[$k], %changes{\"$k\"} orelse .die;\n                }\n                %changes{\"$k\"}:delete;\n            }\n            else {\n                # name is gone, delete the file\n                # notify and do it\n                say \"Deleting: {@files[$k]}\" if $verbose;\n                @files[$k].unlink orelse .die;\n            }\n        }\n        for %changes.kv -> $k, $v {\n            # a new name is added, add an empty file with that name\n            # check to see that the desired directory exists\n            checkdir $v;\n            # notify and do it\n            say \"Adding: $v\" if $verbose;\n            shell(\"touch $v\") orelse .die;\n        }\n        # clean up when done\n        done;\n        exit;\n    };\n    # watch for CTRL-C, cleanup and exit\n    whenever signal(SIGINT) {\n        print \"\\b\\b\";\n        done;\n        exit;\n    }\n}\n\n# get the files in a specified directory matching the filter parameter\nsub files ( $dir, $filter = '' ) {\n    if $filter.chars {\n        $dir.IO.dir.grep( *.f ).grep( *.basename.contains(/<$filter>/) );\n    } else {\n        $dir.IO.dir.grep( *.f );\n    }\n}\n\n# get the files in the present directory and recurse if desired\nsub getdir ($dir, $filter) {\n    if $recurse {\n        @files.append: files($dir, $filter);\n        getdir( $_, $filter ) for $dir.IO.dir.grep( *.d );\n    } else {\n        @files = files($dir, $filter);\n    }\n}\n\n# check for existence of a directory and create it if not found\nsub checkdir ($dir) {\n    unless $dir.IO.dirname.IO.e {\n        # if not, create it\n        my @path = $dir.IO.dirname.split('/');\n        for 1 .. @path {\n            my $thispath = @path[^$_].join('/');\n            unless $thispath.IO.e {\n                say \"Creating new directory $thispath\" if $verbose;\n                mkdir($thispath);\n            }\n        }\n    }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement a   Vigenère cypher,   both encryption and decryption.\n\nThe program should handle keys and text of unequal length,\nand should capitalize everything and discard non-alphabetic characters.   \n(If your program handles non-alphabetic characters in another way,\nmake a note of it.)\n\nRelated tasks\n\n* Caesar cipher\n* Rot-13\n* Substitution Cipher"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015-11-14\n\n```\nsub s2v ($s) { $s.uc.comb(/ <[ A..Z ]> /)».ord »-» 65 }\nsub v2s (@v) { (@v »%» 26 »+» 65)».chr.join }\n\nsub blacken ($red, $key) { v2s(s2v($red) »+» s2v($key)) }\nsub redden  ($blk, $key) { v2s(s2v($blk) »-» s2v($key)) }\n\nmy $red = \"Beware the Jabberwock, my son! The jaws that bite, the claws that catch!\";\nmy $key = \"Vigenere Cipher!!!\";\n\nsay $red;\nsay my $black = blacken($red, $key);\nsay redden($black, $key);\n\n```\n\nOutput:\n\n```\nBeware the Jabberwock, my son! The jaws that bite, the claws that catch!\nWMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY\nBEWARETHEJABBERWOCKMYSONTHEJAWSTHATBITETHECLAWSTHATCATCH\n```\n\nThis is a natural job for hyperoperators, which can vectorize any operator.\nFor infix operators the pointy end indicates which side to \"dwim\", repeating\nelements on that side until the other side runs out. In particular, repeating\nthe key naturally falls out of this cyclic dwimmery, as does repeating the various constants to be applied with any of several operations to every element of the list. Factoring out the canonicalization and decanonicalization lets us see quite clearly that the only difference between encryption and decryptions is the sign of the vector addition/subtraction. Since hyperops are inherently parallelizable, this algorithm might run well in your GPU."}]}
{"messages": [{"role": "user", "content": "Given some text you suspect has been encrypted with a Vigenère cipher, extract the key and plaintext. There are several methods for doing this. See the Wikipedia entry for more information. Use the following encrypted text:\n\n```\nMOMUD EKAPV TQEFM OEVHP AJMII CDCTI FGYAG JSPXY ALUYM NSMYH\nVUXJE LEPXJ FXGCM JHKDZ RYICU HYPUS PGIGM OIYHF WHTCQ KMLRD\nITLXZ LJFVQ GHOLW CUHLO MDSOE KTALU VYLNZ RFGBX PHVGA LWQIS\nFGRPH JOOFW GUBYI LAPLA LCAFA AMKLG CETDW VOELJ IKGJB XPHVG\nALWQC SNWBU BYHCU HKOCE XJEYK BQKVY KIIEH GRLGH XEOLW AWFOJ\nILOVV RHPKD WIHKN ATUHN VRYAQ DIVHX FHRZV QWMWV LGSHN NLVZS\nJLAKI FHXUF XJLXM TBLQV RXXHR FZXGV LRAJI EXPRV OSMNP KEPDT\nLPRWM JAZPK LQUZA ALGZX GVLKL GJTUI ITDSU REZXJ ERXZS HMPST\nMTEOE PAPJH SMFNB YVQUZ AALGA YDNMP AQOWT UHDBV TSMUE UIMVH\nQGVRW AEFSP EMPVE PKXZY WLKJA GWALT VYYOB YIXOK IHPDS EVLEV\nRVSGB JOGYW FHKBL GLXYA MVKIS KIEHY IMAPX UOISK PVAGN MZHPW\nTTZPV XFCCD TUHJH WLAPF YULTB UXJLN SIJVV YOVDJ SOLXG TGRVO\nSFRII CTMKO JFCQF KTINQ BWVHG TENLH HOGCS PSFPV GJOKM SIFPR\nZPAAS ATPTZ FTPPD PORRF TAXZP KALQA WMIUD BWNCT LEFKO ZQDLX\nBUXJL ASIMR PNMBF ZCYLV WAPVF QRHZV ZGZEF KBYIO OFXYE VOWGB\nBXVCB XBAWG LQKCM ICRRX MACUO IKHQU AJEGL OIJHH XPVZW JEWBA\nFWAML ZZRXJ EKAHV FASMU LVVUT TGK\n\n```\n\nLetter frequencies for English can be found here.\n\nSpecifics for this task:\n\n* Take only the ciphertext as input. You can assume it's all capitalized and has no punctuation, but it might have whitespace.\n* Assume the plaintext is written in English.\n* Find and output the key.\n* Use that key to decrypt and output the original plaintext. Maintaining the whitespace from the ciphertext is optional.\n* The algorithm doesn't have to be perfect (which may not be possible) but it should work when given enough ciphertext. The example above is fairly long, and should be plenty for any algorithm."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\n# from Wikipedia\nconstant %English-letter-freq = (\n     E => 12.70,  L => 4.03,  Y => 1.97,  P => 1.93,  T => 9.06,  A => 8.17,  O => 7.51,  I => 6.97,  N => 6.75,\n     S =>  6.33,  H => 6.09,  R => 5.99,  D => 4.25,  C => 2.78,  U => 2.76,  M => 2.41,  W => 2.36,  F => 2.23,\n     G =>  2.02,  B => 1.29,  V => 0.98,  K => 0.77,  J => 0.15,  X => 0.15,  Q => 0.10,  Z => 0.07\n);\nconstant @alphabet = %English-letter-freq.keys.sort;\nconstant max_key_lengths = 5; # number of keylengths to try\n\nsub myguess ($text) {\n    my ($seqtext, @spacing, @factors, $pos, %freq, %Keys);\n\n    # Kasiski examination\n    $seqtext = $text;\n    while ($seqtext ~~ /$<sequence>=[...].*$<sequence>/) {\n        $seqtext = substr($seqtext, 1+index($seqtext, $<sequence>));\n        push @spacing, 1 + index($seqtext, $<sequence>);\n    }\n    for @spacing -> $j {\n        %freq{$_}++ for grep { $j %% $_ }, 2..$j;\n    }\n\n    # discard very short keys, and test only the most likely remaining key lengths\n    (%freq.keys.grep(* > 3).sort({%freq{$_}}).tail(max_key_lengths)).race(:1batch).map: -> $keylen {\n        my $key-guess = '';\n        loop (my $i = 0; $i < $keylen; $i++) {\n            my ($mykey, %chi-square, $best-guess);\n            loop (my $j = 0; $j < $text.chars; $j += $keylen) {\n                $mykey ~= substr($text, ($j+$i) % $text.chars, 1);\n            }\n\n            for @alphabet -> $subkey {\n                my $decrypted = mycrypt($mykey, $subkey);\n                my $length    = $decrypted.chars;\n                for @alphabet -> $char {\n                    my $expected = %English-letter-freq{$char} * $length / 100;\n                    my $observed = $decrypted.comb.grep(* eq $char).elems;\n                    %chi-square{$subkey} += ($observed - $expected)² / $expected if $observed;\n                }\n            }\n            %Keys{$keylen}{'score'} = %chi-square{@alphabet[0]};\n            for %chi-square.keys.sort -> $sk {\n                if (%chi-square{$sk} <= %Keys{$keylen}{'score'}) {\n                    $best-guess = $sk;\n                    %Keys{$keylen}{'score'} = %chi-square{$sk};\n                }\n            }\n            $key-guess ~= $best-guess;\n        }\n        %Keys{$keylen}{'key'} = $key-guess;\n    }\n    %Keys.keys.sort({ %Keys{$_}{'score'} }).map:{ %Keys{$_}{'key'} };\n}\n\nsub mycrypt ($text, $key) {\n    constant %values-numbers = @alphabet Z=> ^@alphabet;\n    constant %values-letters = %values-numbers.invert;\n\n    my ($new-text);\n    my $keylen = $key.chars;\n    loop (my $i = 0; $i < $text.chars; $i++) {\n        my $val =  -1 * %values-numbers{substr( $key, $i%$keylen, 1)} # negative shift for decode\n                 +      %values-numbers{substr($text, $i,         1)};\n        $new-text ~= %values-letters{ $val % @alphabet };\n    }\n    return $new-text;\n}\n\nmy $cipher-text = .uc.trans(@alphabet => '', :c) given q:to/EOD/;\n    MOMUD EKAPV TQEFM OEVHP AJMII CDCTI FGYAG JSPXY ALUYM NSMYH\n    VUXJE LEPXJ FXGCM JHKDZ RYICU HYPUS PGIGM OIYHF WHTCQ KMLRD\n    ITLXZ LJFVQ GHOLW CUHLO MDSOE KTALU VYLNZ RFGBX PHVGA LWQIS\n    FGRPH JOOFW GUBYI LAPLA LCAFA AMKLG CETDW VOELJ IKGJB XPHVG\n    ALWQC SNWBU BYHCU HKOCE XJEYK BQKVY KIIEH GRLGH XEOLW AWFOJ\n    ILOVV RHPKD WIHKN ATUHN VRYAQ DIVHX FHRZV QWMWV LGSHN NLVZS\n    JLAKI FHXUF XJLXM TBLQV RXXHR FZXGV LRAJI EXPRV OSMNP KEPDT\n    LPRWM JAZPK LQUZA ALGZX GVLKL GJTUI ITDSU REZXJ ERXZS HMPST\n    MTEOE PAPJH SMFNB YVQUZ AALGA YDNMP AQOWT UHDBV TSMUE UIMVH\n    QGVRW AEFSP EMPVE PKXZY WLKJA GWALT VYYOB YIXOK IHPDS EVLEV\n    RVSGB JOGYW FHKBL GLXYA MVKIS KIEHY IMAPX UOISK PVAGN MZHPW\n    TTZPV XFCCD TUHJH WLAPF YULTB UXJLN SIJVV YOVDJ SOLXG TGRVO\n    SFRII CTMKO JFCQF KTINQ BWVHG TENLH HOGCS PSFPV GJOKM SIFPR\n    ZPAAS ATPTZ FTPPD PORRF TAXZP KALQA WMIUD BWNCT LEFKO ZQDLX\n    BUXJL ASIMR PNMBF ZCYLV WAPVF QRHZV ZGZEF KBYIO OFXYE VOWGB\n    BXVCB XBAWG LQKCM ICRRX MACUO IKHQU AJEGL OIJHH XPVZW JEWBA\n    FWAML ZZRXJ EKAHV FASMU LVVUT TGK\nEOD\n\nfor myguess($cipher-text) -> $key {\n    say \"Key        $key\\n\" ~\n        \"Key length {$key.chars}\\n\" ~\n        \"Plaintext  {substr(mycrypt($cipher-text, $key), 0, 80)}...\\n\";\n}\n\n```\n\nOutput:\n\n```\nKey        THECHESHIRECAT\nKey length 14\nPlaintext  THISWASTHEPOEMTHATALICEREADJABBERWOCKYTWASBRILLIGANDTHESLITHYTOVESDIDGYREANDGIMB...\n\nKey        THECHESCIRECATTHECHESHIRECAT\nKey length 28\nPlaintext  THISWASYHEPOEMTHATALICEREADJABBERWOHKYTWASBRILLIGANDTHESLITHYTOAESDIDGYREANDGIMB...\n\nKey        TJGGAHET\nKey length 8\nPlaintext  TFGODXGHWMNKEYIVLMBJACIPPTXWTBBNFRADSITFHCOSMGOTFYPOXCASLGRDFQCJTABEDSNFPTOBYIQZ...\n\nKey        THECSAS\nKey length 7\nPlaintext  THISLESHIRRYENTHATPPIQFEGKDKABBEGAOQLLVGATBRILAMGOOQVRETLITHNXOJFFFSDHYREACHGWNO...\n\nKey        THEC\nKey length 4\nPlaintext  THISKXGYWOPOLYIMLODNHCIGPVZAABBEFTCHZITWHEQWTGOKFARSECAJLITHMQCATCDIKSNWPVQFFIQQ...\n```"}]}
{"messages": [{"role": "user", "content": "Description\n\nIn object oriented programming, the Visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying the structures.\n\nIt is one way to follow the open/closed principle which states that: \"software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification\".\n\nThe Visitor pattern is one of the twenty-three Gang of Four design patterns that facilitate the solution of recurring design problems in object-oriented software.\n\nOperation\n\nConsider two objects, each of some class type; one is termed the *element*, and the other is the *visitor*.\n\nThe visitor declares a *visit* method, which takes the element as an argument, for each class of element. Concrete visitors are derived from the visitor class and implement these visit methods, each of which implements part of the algorithm operating on the object structure. The state of the algorithm is maintained locally by the concrete visitor class.\n\nThe element declares an *accept* method to accept a visitor, taking the visitor as an argument. Concrete elements, derived from the element class, implement the accept method. Composite elements, which maintain a list of child objects, typically iterate over these, calling each child's accept method.\n\nHaving created the object structure, a program should first instantiate the concrete visitors. When an operation is to be performed which is implemented using the Visitor pattern, it should then call the accept method of the top-level element(s) passing the visitor(s) as arguments.\n\nExamples\n\nThe Wikipedia article contains examples of the Visitor pattern written in: C#, Smalltalk, Go (partial), Java, Common Lisp and Python.\n\nTask\n\nDemonstrate the workings of the Visitor pattern in your language by translating one (or more) of the Wikipedia examples. If your language is one of those for which an example already exists, try to translate one of the other examples.\n\nIf you don't know any of the example languages or prefer to use your own example, then this is also acceptable.\n\nIf your language does not support the object oriented paradigm at all (or only to a limited extent), then try to emulate the intent of the pattern with the tools it does have by writing a program which produces the same output as one of the Wikipedia examples.\n\nReferences\n\n* Wikipedia: Visitor pattern\n* Code Project - The Visitor Pattern Explained"}, {"role": "assistant", "content": "Raku implements multiple dispatch so the visitor pattern is perhaps not as useful/necessary there. That said, it can be done fairly easily.\n\n(Largely based on an example published by Johnathan Stowe.)\n\n```\nrole CarElementVisitor { ... }\n\nclass CarElement {\n    method accept(CarElementVisitor $visitor) {\n        $visitor.visit: self\n    }\n}\n\nclass Body is CarElement { }\n\nclass Engine is CarElement { }\n\nclass Wheel is CarElement {\n    has Str $.name is required;\n}\n\nclass Car is CarElement {\n    has CarElement @.elements = ( \n        Wheel.new(name => \"front left\"),\n        Wheel.new(name => \"front right\"),\n        Wheel.new(name => \"rear left\"),\n        Wheel.new(name => \"rear right\"),\n        Body.new,\n        Engine.new\n    );\n\n    method accept(CarElementVisitor $visitor) {\n        for @.elements -> $element { $element.accept: $visitor };\n        $visitor.visit: self;\n    }\n}\n\nrole CarElementVisitor {\n    method visit(CarElement $e) { ... }\n}\n\nclass CarElementDoVisitor does CarElementVisitor {\n    multi method visit(Body $e) {\n        say \"Moving my body.\";\n    }\n    multi method visit(Car $e) {\n        say \"Starting my car.\";\n    }\n    multi method visit(Wheel $e) {\n        say \"Kicking my { $e.name } wheel.\";\n    }\n    multi method visit(Engine $e) {\n        say \"Starting my engine.\";\n    }\n}\n\nclass CarElementPrintVisitor does CarElementVisitor {\n    multi method visit(Body $e) {\n        say \"Visiting body.\";\n    }\n    multi method visit(Car $e) {\n        say \"Visiting car.\";\n    }\n    multi method visit(Wheel $e) {\n        say \"Visiting { $e.name } wheel.\";\n    }\n    multi method visit(Engine $e) {\n        say \"Visiting engine.\";\n    }\n}\n\nmy Car $car = Car.new;\n\n$car.accept: CarElementPrintVisitor.new;\n$car.accept: CarElementDoVisitor.new;\n\n```\n\nOutput:\n\n```\nVisiting front left wheel.\nVisiting front right wheel.\nVisiting rear left wheel.\nVisiting rear right wheel.\nVisiting body.\nVisiting engine.\nVisiting car.\nKicking my front left wheel.\nKicking my front right wheel.\nKicking my rear left wheel.\nKicking my rear right wheel.\nMoving my body.\nStarting my engine.\nStarting my car.\n```"}]}
{"messages": [{"role": "user", "content": "A tree structure   (i.e. a rooted, connected acyclic graph)   is often used in programming.\n\nIt's often helpful to visually examine such a structure.\n\nThere are many ways to represent trees to a reader, such as:\n\n:   :   :   * indented text   (à la unix  `tree`  command)\n            * nested HTML tables\n            * hierarchical GUI widgets\n            * 2D   or   3D   images\n            * etc.\n\nTask\n\nWrite a program to produce a visual representation of some tree.\n\nThe content of the tree doesn't matter, nor does the output format, the only requirement being that the output is human friendly.\n\nMake do with the vague term \"friendly\" the best you can."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub visualize-tree($tree, &label, &children,\n                   :$indent = '',\n                   :@mid = ('├─', '│ '),\n                   :@end = ('└─', '  '),\n) {\n    sub visit($node, *@pre) {\n        | gather {\n            take @pre[0] ~ label($node);\n            my @children := children($node);\n            my $end = @children.end;\n            for @children.kv -> $_, $child {\n                when $end { take visit($child, (@pre[1] X~ @end)) }\n                default   { take visit($child, (@pre[1] X~ @mid)) }\n            }\n        }\n    }\n    visit($tree, $indent xx 2);\n}\n\n# example tree built up of pairs\nmy $tree = root=>[a=>[a1=>[a11=>[]]],b=>[b1=>[b11=>[]],b2=>[],b3=>[]]];\n\n.map({.join(\"\\n\")}).join(\"\\n\").say for visualize-tree($tree, *.key, *.value.list);\n\n```\n\nOutput:\n\n```\nroot\n├─a\n│ └─a1\n│   └─a11\n└─b\n  ├─b1\n  │ └─b11\n  ├─b2\n  └─b3\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at VList. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn computer science, the **VList** is a persistent data structure that combines the fast indexing of arrays with the easy extension of cons-based (or singly-linked) linked lists.\n\nLike arrays, VLists have constant-time lookup on average and are highly compact, requiring only O(log *n*) storage for pointers, allowing them to take advantage of locality of reference.\nLike singly-linked or cons-based lists, they are persistent, and elements can be added to or removed from the front in constant time. Length can also be found in O(log *n*) time.\n\nThe primary operations of a VList are:\n\n* Locate the *k*th element (O(1) average, O(log *n*) worst-case)\n* Add an element to the front of the VList (O(1) average, with an occasional allocation)\n* Obtain a new array beginning at the second element of an old array (O(1))\n* Compute the length of the list (O(log *n*))\n\nTask\n\nThe task is to demonstrate creation of a VList and how to perform the primary operations."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Go\n\n**Translation of**: Kotlin\n\n```\nclass vList {\n\n   subset vEle of Any; # or Str\n\n   class vSeg {\n      has      $.next is rw is default(Nil) ;\n      has vEle @.ele  is rw ;\n   }\n\n   has vSeg $.base   is rw is default(vSeg.new(ele=>()));\n   has Int  $.offset is rw is default(0) ;\n\n   method Index(Int $i is copy --> vEle) { # method to locate the kth element\n      if $i ≥ 0 {\n         loop ( $i += self.offset, $_ = self.base; $_.defined; $_ := $_.next) {\n            ($i < my $len = .ele.elems) ?? return .ele[$i] !! $i -= $len\n         }\n      }\n      die \"index out of range\"\n   }\n\n   method cons(vEle \\a --> vList) { # method to add an element to the front\n      if not self.base.ele.Bool {   # probably faster than .elems ?\n         self.base.ele.push: a ;\n         return self;\n      } elsif self.offset == 0 {\n         my \\L2offset = (self.base.ele.elems * 2) - 1 ;\n         my \\s = vSeg.new(next => self.base, ele => flat Nil xx L2offset, a);\n         return vList.new(base => s, offset => L2offset )\n      }\n      self.base.ele[--self.offset] = a;\n      return self\n   }\n\n   # obtain a new array beginning at the second element of an old array\n   method cdr(--> vList) {\n      die \"cdr on empty vList\" unless self.base.defined;\n      return self if ++self.offset < self.base.ele.elems;\n      return vList.new(base => self.base.next)\n   }\n\n   method Length(--> Int) { # method to  compute the length of the list\n      return 0 unless self.base.defined;\n      return self.base.ele.elems*2 - self.offset - 1\n   }\n\n   method gist { # (mis)used to create output similar to Go/Kotlin\n      return '[]' unless self.base.ele.Bool;\n      my @sl = self.base.ele[self.offset .. *];\n      loop ($_=self.base.next; $_.defined; $_:=$_.next) { @sl.append: .ele }\n      return  \"[\" ~ @sl.Str ~ \"]\"\n   }\n\n   method printStructure {  # One more method for demonstration purposes\n      say \"offset: \", self.offset;\n      loop ( $_ = self.base; $_.defined ; $_ := $_.next ) { .ele.say }\n   }\n}\n\nmy $v := vList.new;\nsay \"zero value for type.  empty vList: \", $v;\n$v.printStructure;\nsay \" \";\n$v := $v.cons($_.Str) for 6 … 1;\nsay \"demonstrate cons. 6 elements added: \", $v;\n$v.printStructure;\nsay \" \";\n$v := $v.cdr;\nsay \"demonstrate cdr. 1 element removed: \", $v;\n$v.printStructure;\nsay \" \";\nsay \"demonstrate length. length = \", $v.Length;\nsay \" \";\nsay \"demonstrate element access. v[3] = \", $v.Index(3) ;\nsay \" \";\n$v := $v.cdr.cdr;\nsay \"show cdr releasing segment. 2 elements removed: \", $v;\n$v.printStructure;\n\n```\n\nOutput:\n\n```\nzero value for type.  empty vList: []\noffset: 0\n[]\n\ndemonstrate cons. 6 elements added: [1 2 3 4 5 6]\noffset: 1\n[(vEle) 1 2 3]\n[4 5]\n[6]\n\ndemonstrate cdr. 1 element removed: [2 3 4 5 6]\noffset: 2\n[(vEle) 1 2 3]\n[4 5]\n[6]\n\ndemonstrate length. length = 5\n\ndemonstrate element access. v[3] = 5\n\nshow cdr releasing segment. 2 elements removed: [4 5 6]\noffset: 0\n[4 5]\n[6]\n\n```"}]}
{"messages": [{"role": "user", "content": "Vogel's Approximation Method (VAM) is a technique for finding a good initial feasible solution to an allocation problem.\n\nThe powers that be have identified 5 tasks that need to be solved urgently. Being imaginative chaps, they have called them “A”, “B”, “C”, “D”, and “E”. They estimate that:\n\n* A will require 30 hours of work,\n* B will require 20 hours of work,\n* C will require 70 hours of work,\n* D will require 30 hours of work, and\n* E will require 60 hours of work.\n\nThey have identified 4 contractors willing to do the work, called “W”, “X”, “Y”, and “Z”.\n\n* W has 50 hours available to commit to working,\n* X has 60 hours available,\n* Y has 50 hours available, and\n* Z has 50 hours available.\n\nThe cost per hour for each contractor for each task is summarized by the following table:\n\n```\n   A  B  C  D  E\nW 16 16 13 22 17\nX 14 14 13 19 15\nY 19 19 20 23 50\nZ 50 12 50 15 11\n\n```\n\nThe task is to use VAM to allocate contractors to tasks. It scales to large problems, so ideally keep sorts out of the iterative cycle. It works as follows:\n\n:   Step 1: Balance the given transportation problem if either (total supply>total demand) or (total supply<total demand)\n:   Step 2: Determine the penalty cost for each row and column by subtracting the lowest cell cost in the row or column from the next lowest cell cost in the same row or column.\n:   Step 3: Select the row or column with the highest penalty cost (breaking ties arbitrarily or choosing the lowest-cost cell).\n:   Step 4: Allocate as much as possible to the feasible cell with the lowest transportation cost in the row or column with the highest penalty cost.\n:   Step 5: Repeat steps 2, 3 and 4 until all requirements have been meet.\n:   Step 6: Compute total transportation cost for the feasible allocations.\n\nFor this task assume that the model is balanced.\n\nFor each task and contractor (row and column above) calculating the difference between the smallest two values produces:\n\n```\n        A       B       C       D       E       W       X       Y       Z\n1       2       2       0       4       4       3       1       0       1   E-Z(50)\n\n```\n\nDetermine the largest difference (D or E above). In the case of ties I shall choose the one with the lowest price (in this case E because the lowest price for D is Z=15, whereas for E it is Z=11). For your choice determine the minimum cost (chosen E above so Z=11 is chosen now). Allocate as much as possible from Z to E (50 in this case limited by Z's supply).\nAdjust the supply and demand accordingly. If demand or supply becomes 0 for a given task or contractor it plays no further part. In this case Z is out of it. If you choose arbitrarily, and chose D see here for the working.\n\nRepeat until all supply and demand is met:\n\n```\n2       2       2       0       3       2       3       1       0       -   C-W(50)\n3       5       5       7       4      35       -       1       0       -   E-X(10)\n4       5       5       7       4       -       -       1       0       -   C-X(20)\n5       5       5       -       4       -       -       0       0       -   A-X(30)\n6       -      19       -      23       -       -       -       4       -   D-Y(30)\n        -       -       -       -       -       -       -       -       -   B-Y(20)\n\n```\n\nFinally calculate the cost of your solution. In the example given it is £3100:\n\n```\n   A  B  C  D  E\nW       50\nX 30    20    10\nY    20    30\nZ             50\n\n```\n\nThe optimal solution determined by GLPK is £3100:\n\n```\n   A  B  C  D  E\nW       50\nX 10 20 20    10\nY 20       30\nZ             50\n\n```\n\nCf.\n\n* Transportation problem"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2019.03.1\n\n**Translation of**: Sidef\n\n```\nmy  %costs =\n    :W{:16A, :16B, :13C, :22D, :17E},\n    :X{:14A, :14B, :13C, :19D, :15E},\n    :Y{:19A, :19B, :20C, :23D, :50E},\n    :Z{:50A, :12B, :50C, :15D, :11E};\n\nmy %demand = :30A, :20B, :70C, :30D, :60E;\nmy %supply = :50W, :60X, :50Y, :50Z;\n\nmy @cols = %demand.keys.sort;\n\nmy %res;\nmy %g = (|%supply.keys.map: -> $x { $x => [%costs{$x}.sort(*.value)».key]}),\n   (|%demand.keys.map: -> $x { $x => [%costs.keys.sort({%costs{$_}{$x}})]});\n\nwhile (+%g) {\n    my @d = %demand.keys.map: -> $x\n      {[$x, my $z = %costs{%g{$x}[0]}{$x},%g{$x}[1] ?? %costs{%g{$x}[1]}{$x} - $z !! $z]}\n\n    my @s = %supply.keys.map: -> $x\n      {[$x, my $z = %costs{$x}{%g{$x}[0]},%g{$x}[1] ?? %costs{$x}{%g{$x}[1]} - $z !! $z]}\n\n    @d = |@d.grep({ (.[2] == max @d».[2]) }).&min: :by(*.[1]);\n    @s = |@s.grep({ (.[2] == max @s».[2]) }).&min: :by(*.[1]);\n\n    my ($t, $f) = @d[2] == @s[2] ?? (@s[1],@d[1]) !! (@d[2],@s[2]);\n    my ($d, $s) = $t > $f ?? (@d[0],%g{@d[0]}[0]) !! (%g{@s[0]}[0], @s[0]);\n\n    my $v = %supply{$s} min %demand{$d};\n\n    %res{$s}{$d} += $v;\n    %demand{$d} -= $v;\n\n    if (%demand{$d} == 0) {\n        %supply.grep( *.value != 0 )».key.map: -> $v\n          { %g{$v}.splice((%g{$v}.first: * eq $d, :k),1) };\n        %g{$d}:delete;\n        %demand{$d}:delete;\n    }\n\n    %supply{$s} -= $v;\n\n    if (%supply{$s} == 0) {\n        %demand.grep( *.value != 0 )».key.map: -> $v\n          { %g{$v}.splice((%g{$v}.first: * eq $s, :k),1) };\n        %g{$s}:delete;\n        %supply{$s}:delete;\n    }\n}\n\nsay join \"\\t\", flat '', @cols;\nmy $total;\nfor %costs.keys.sort -> $g {\n    print \"$g\\t\";\n    for @cols -> $col {\n        print %res{$g}{$col} // '-', \"\\t\";\n        $total += (%res{$g}{$col} // 0) * %costs{$g}{$col};\n    }\n    print \"\\n\";\n}\nsay \"\\nTotal cost: $total\";\n\n```\n\nOutput:\n\n```\n\tA\tB\tC\tD\tE\nW\t-\t-\t50\t-\t-\t\nX\t30\t-\t20\t-\t10\t\nY\t-\t20\t-\t30\t-\t\nZ\t-\t-\t-\t-\t50\t\n\nTotal cost: 3100\n```"}]}
{"messages": [{"role": "user", "content": "A Voronoi diagram is a diagram consisting of a number of sites.\n\nEach Voronoi site *s* also has a Voronoi cell consisting of all points closest to *s*.\n\nTask\n\nDemonstrate how to generate and display a Voroni diagram.\n\nSee algo K-means++ clustering."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.09\n\n**Translation of**: Python\n\nPerhaps \"Inspired by Python\" would be more accurate.\n\nGenerates a Euclidean, a Taxicab and a Minkowski Voronoi diagram using the same set of domain points and colors.\n\n```\nuse Image::PNG::Portable;\n\nmy @bars = '▁▂▃▅▆▇▇▆▅▃▂▁'.comb;\n\nmy %type = ( # Voronoi diagram type distance calculation\n    'Taxicab'   => sub ($px, $py, $x, $y) { ($px - $x).abs  + ($py - $y).abs  },\n    'Euclidean' => sub ($px, $py, $x, $y) { ($px - $x)²     + ($py - $y)²     },\n    'Minkowski' => sub ($px, $py, $x, $y) { ($px - $x)³.abs + ($py - $y)³.abs },\n);\n\nmy $width  = 400;\nmy $height = 400;\nmy $dots   = 30;\n\nmy @domains = map { Hash.new(\n    'x' => (5..$width-5).roll,\n    'y' => (5..$height-5).roll,\n    'rgb' => [(64..255).roll xx 3]\n) }, ^$dots;\n\nfor %type.keys -> $type {\n    print \"\\nGenerating $type diagram...    \", ' ' x @bars;\n    my $img = voronoi(@domains, :w($width), :h($height), :$type);\n    @domains.map: *.&dot($img);\n    $img.write: \"Voronoi-{$type}-perl6.png\";\n}\n\nsub voronoi (@domains, :$w, :$h, :$type) {\n    my $png = Image::PNG::Portable.new: :width($w), :height($h);\n    (^$w).race.map: -> $x {\n        print \"\\b\" x 2+@bars, @bars.=rotate(1).join , '  ';\n        for ^$h -> $y {\n            my ($, $i) = min @domains.map: { %type{$type}(%($_)<x>, %($_)<y>, $x, $y), $++ };\n            $png.set: $x, $y, |@domains[$i]<rgb>\n        }\n    }\n    $png\n}\n\nsub dot (%h, $png, $radius = 3) {\n    for (%h<x> X+ -$radius .. $radius) X (%h<y> X+ -$radius .. $radius) -> ($x, $y) {\n            $png.set($x, $y, 0, 0, 0) if ( %h<x> - $x + (%h<y> - $y) * i ).abs <= $radius;\n    }\n}\n\n```\n\nSee Euclidean, Taxicab & Minkowski Voronoi diagram example images."}]}
{"messages": [{"role": "user", "content": "Definition\n\nA *Wagstaff prime* is a prime number of the form *(2^p + 1)/3* where the exponent *p* is an odd prime.\n\nExample\n\n(2^5 + 1)/3 = 11 is a Wagstaff prime because both 5 and 11 are primes.\n\nTask\n\nFind and show here the first *10* Wagstaff primes and their corresponding exponents *p*.\n\nStretch (requires arbitrary precision integers)\n\nFind and show here the exponents *p* corresponding to the next *14* Wagstaff primes (not the primes themselves) and any more that you have the patience for.\n\nWhen testing for primality, you may use a method which determines that a large number is probably prime with reasonable certainty.\n\nNote\n\nIt can be shown (see talk page) that *(2^p + 1)/3* is always integral if *p* is odd. So there's no need to check for that prior to checking for primality.\n\nReferences\n\n* Wikipedia - Wagstaff prime\n* OEIS:A000979 - Wagstaff primes"}, {"role": "assistant", "content": "```\n# First 20\n\nmy @wagstaff = (^∞).grep: { .is-prime && ((1 + 1 +< $_)/3).is-prime };\n\nsay ++$ ~ \": $_ - {(1 + 1 +< $_)/3}\" for @wagstaff[^20];\n\nsay .fmt(\"\\nTotal elapsed seconds: (%.2f)\\n\") given (my $elapsed = now) - INIT now;\n\n# However many I have patience for\n\nmy atomicint $count = 20;\n\nhyper for @wagstaff[20] .. * {\n    next unless .is-prime;\n    say ++⚛$count ~ \": $_ ({sprintf \"%.2f\", now - $elapsed})\" and $elapsed = now if is-prime (1 + 1 +< $_)/3;\n}\n\n```\n\nOutput:\n\n*Turns out, \"however many I have patience for\" is 9 (29).*\n\n```\n1: 3 - 3\n2: 5 - 11\n3: 7 - 43\n4: 11 - 683\n5: 13 - 2731\n6: 17 - 43691\n7: 19 - 174763\n8: 23 - 2796203\n9: 31 - 715827883\n10: 43 - 2932031007403\n11: 61 - 768614336404564651\n12: 79 - 201487636602438195784363\n13: 101 - 845100400152152934331135470251\n14: 127 - 56713727820156410577229101238628035243\n15: 167 - 62357403192785191176690552862561408838653121833643\n16: 191 - 1046183622564446793972631570534611069350392574077339085483\n17: 199 - 267823007376498379256993682056860433753700498963798805883563\n18: 313 - 5562466239377370006237035693149875298444543026970449921737087520370363869220418099018130434731\n19: 347 - 95562442332919646317117537304253622533190207882011713489066201641121786503686867002917439712921903606443\n20: 701 - 3506757267698915671493993255253419110366893201882115906332187268712488102864720548075777690851725634151321979237452145142012954833455869242085209847101253899970149114085629732127775838589548478180862167823854251\n\nTotal elapsed seconds: (0.09)\n\n21: 1709 (0.87)\n22: 2617 (0.92)\n23: 3539 (2.03)\n24: 5807 (13.18)\n25: 10501 (114.14)\n26: 10691 (114.14)\n27: 11279 (48.13)\n28: 12391 (92.99)\n29: 14479 (179.87)\n^C\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWalk a given directory and print the *names* of files matching a given pattern.\n\n(How is \"pattern\" defined? substring match? DOS pattern? BASH pattern? ZSH pattern? Perl regular expression?)\n\n**Note:** This task is for non-recursive methods.   These tasks should read a *single directory*, not an entire directory tree.\n\n**Note:** Please be careful when running any code presented here.\n\nRelated task\n\n* Walk Directory Tree   (read entire directory tree)."}, {"role": "assistant", "content": "(formerly Perl 6)\nThe `dir` function takes the directory to traverse, and optionally a named parameter `test`, which is smart-matched against the basename of each file (so for example we can use a regex):\n\n```\n.say for dir \".\", :test(/foo/);\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWalk a given directory *tree* and print files matching a given pattern.\n\n**Note:** This task is for recursive methods.   These tasks should read an entire directory tree, not a *single directory*.\n\n**Note:** Please be careful when running any code examples found here.\n\nRelated task\n\n* Walk a directory/Non-recursively   (read a *single directory*)."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUsing the File::Find module:\n\n```\nuse File::Find;\n\n.say for find dir => '.', name => /'.txt' $/;\n\n```\n\nAlternatively, a custom solution that provides the same interface as the built-in (non-recursive) dir function, and uses gather/take to return a lazy sequence:\n\n```\nsub find-files ($dir, Mu :$test) {\n    gather for dir $dir -> $path {\n        if $path.basename ~~ $test { take $path }\n        if $path.d                 { .take for find-files $path, :$test };\n    }\n}\n \n.put for find-files '.', test => /'.txt' $/;\n\n```\n\nOr if you value performance over portability, here's a function that runs the GNU find program and returns a lazy sequence of the files it finds. Parameters are not subjected to shell expansion, and the null-byte (which cannot be present in file paths) is used as the path delimiter, so it should be pretty safe.\n\n```\nsub find-files ($dir, :$pattern) {\n    run('find', $dir, '-iname', $pattern, '-print0', :out, :nl«\\0»).out.lines;\n}\n\n.say for find-files '.', pattern => '*.txt';\n\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Walsh matrix. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nA **Walsh matrix** is a specific square matrix of dimensions 2*n*, where *n* is some particular natural number. The elements of the matrix are either **+1** or **−1** and its rows as well as columns are orthogonal, *i.e. dot product is zero*. Each row of a Walsh matrix corresponds to a Walsh function.\n\nWalsh matrices are a special case of Hadamard matrices. The *naturally ordered* Hadamard (Walsh) matrix is defined by the recursive formula below, and the *sequency-ordered* Hadamard (Walsh) matrix is formed by rearranging the rows so that the number of sign changes in a row is in increasing order.\n\nTo generate a naturally ordered Walsh matrix\n\nMatrices of dimension 2*k* for *k* ∈ *N* are given by the recursive formula:\n\n:   W\n\n    (\n\n    2\n\n    1\n    )\n\n\n    =\n\n\n    [\n\n    1\n\n    1\n\n\n    1\n\n    −\n    1\n    ]\n    ,\n\n\n    W\n\n    (\n\n    2\n\n    2\n    )\n\n\n    =\n\n\n    [\n\n    1\n\n    1\n\n    1\n\n    1\n\n\n    1\n\n    −\n    1\n\n    1\n\n    −\n    1\n\n\n    1\n\n    1\n\n    −\n    1\n\n    −\n    1\n\n\n    1\n\n    −\n    1\n\n    −\n    1\n\n    1\n    ]\n    ,\n    {\\displaystyle {\\displaystyle {\\begin{aligned}W\\left(2^{1}\\right)&={\\begin{bmatrix}1&1\\\\1&-1\\end{bmatrix}},\\\\W\\left(2^{2}\\right)&={\\begin{bmatrix}1&1&1&1\\\\1&-1&1&-1\\\\1&1&-1&-1\\\\1&-1&-1&1\\\\\\end{bmatrix}},\\end{aligned}}}}\n\nand in general\n\n:   W\n\n    (\n\n    2\n\n    k\n    )\n    =\n\n\n    [\n\n    W\n\n    (\n\n    2\n\n    k\n    −\n    1\n    )\n\n    W\n\n    (\n\n    2\n\n    k\n    −\n    1\n    )\n\n\n    W\n\n    (\n\n    2\n\n    k\n    −\n    1\n    )\n\n    −\n    W\n\n    (\n\n    2\n\n    k\n    −\n    1\n    )\n    ]\n    =\n    W\n    (\n    2\n    )\n    ⊗\n    W\n\n    (\n\n    2\n\n    k\n    −\n    1\n    )\n    ,\n    {\\displaystyle {\\displaystyle W\\left(2^{k}\\right)={\\begin{bmatrix}W\\left(2^{k-1}\\right)&W\\left(2^{k-1}\\right)\\\\W\\left(2^{k-1}\\right)&-W\\left(2^{k-1}\\right)\\end{bmatrix}}=W(2)\\otimes W\\left(2^{k-1}\\right),}}\n\nfor 2 ≤ *k* ∈ *N*, where ⊗ denotes the Kronecker product.\n\nTask\n\n* Write a routine that, given a natural number **k**, returns a **naturally ordered** Walsh matrix of order 2*k*. * Display a few sample generated matrices.\n:   :   *Traditionally, Walsh matrices use **1** & **-1** to denote the different cell values in text mode, or **green** and **red** blocks in image mode. You may use whichever display mode is most convenient for your particular language.*\n\nStretch\n\n* Also, optionally generate **sequency ordered** Walsh matrices.\n:   :   *A sequency ordered Walsh matrix has the rows sorted by number of sign changes.*\n\nSee also\n\n* Wikipedia: Walsh matrix * Related task: Kronecker product"}, {"role": "assistant", "content": "```\nsub walsh (\\m) { (map {$_?? -1 !! ' 1'}, map { :3(.base: 2) % 2 }, [X+&] ^2**m xx 2 ).batch: 2**m }\n\nsub natural (@row) { Same }\n\nsub sign-changes (@row) { sum (1..^@row).map: { 1 if @row[$_] !== @row[$_ - 1] } }\n\nuse SVG;\n\nfor &natural, 'natural', &sign-changes, 'sequency' -> &sort, $sort {\n    for 2,4,5 -> $order {\n        # ASCII text\n        .put for \"\\nWalsh matrix - order $order ({exp($order,2)} x {exp($order,2)}), $sort order:\", |walsh($order).sort: &sort;\n\n        # SVG image\n        my $side = 600;\n        my $scale = $side / 2**$order;\n        my $row = 0;\n        my @blocks;\n        my %C = ' 1' => '#0F0', '-1' => '#F00';\n\n        for walsh($order).sort: &sort -> @row {\n            my \\x = $row++ * $scale;\n            for @row.kv {\n                my \\y = $^k * $scale;\n                @blocks.push: (:rect[:x(x),:y(y),:width($scale),:height($scale),:fill(%C{$^v})]);\n            }\n        }\n\n        \"walsh-matrix--order-{$order}--{$sort}-sort-order--raku.svg\".IO.spurt:\n          SVG.serialize(:svg[:width($side),:height($side),:stroke<black>,:stroke-width<1>,|@blocks])\n    }\n}\n\n```\n\nOutput:\n\n```\nWalsh matrix - order 2 (4 x 4), natural order:\n 1  1  1  1\n 1 -1  1 -1\n 1  1 -1 -1\n 1 -1 -1  1\n\nWalsh matrix - order 4 (16 x 16), natural order:\n 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n 1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1\n 1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1\n 1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1\n 1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1\n 1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1\n 1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1\n 1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1\n 1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1\n 1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1\n 1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1\n 1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1\n 1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1\n 1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1\n 1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1\n 1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1\n\nWalsh matrix - order 5 (32 x 32), natural order:\n 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n 1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1\n 1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1\n 1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1\n 1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1\n 1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1\n 1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1\n 1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1\n 1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1\n 1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1\n 1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1\n 1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1\n 1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1\n 1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1\n 1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1\n 1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1\n 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1\n 1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1\n 1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1\n 1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1\n 1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1\n 1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1\n 1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1\n 1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1\n 1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1  1  1  1  1\n 1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1  1 -1  1 -1\n 1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1  1  1 -1 -1\n 1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1  1 -1 -1  1\n 1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1  1  1  1  1 -1 -1 -1 -1\n 1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1  1 -1  1 -1 -1  1 -1  1\n 1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1  1  1 -1 -1 -1 -1  1  1\n 1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1  1 -1 -1  1 -1  1  1 -1\n\nWalsh matrix - order 2 (4 x 4), sequency order:\n 1  1  1  1\n 1  1 -1 -1\n 1 -1 -1  1\n 1 -1  1 -1\n\nWalsh matrix - order 4 (16 x 16), sequency order:\n 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n 1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1\n 1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1\n 1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1\n 1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1\n 1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1\n 1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1\n 1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1\n 1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1\n 1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1\n 1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1\n 1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1\n 1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1\n 1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1\n 1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1\n 1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1\n\nWalsh matrix - order 5 (32 x 32), sequency order:\n 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1\n 1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1  1  1  1  1\n 1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1\n 1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1\n 1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1  1  1  1  1 -1 -1 -1 -1\n 1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1\n 1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1\n 1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1\n 1  1 -1 -1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1\n 1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1 -1 -1  1  1  1  1 -1 -1  1  1 -1 -1 -1 -1  1  1\n 1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1\n 1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1\n 1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1  1  1 -1 -1  1  1 -1 -1\n 1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1\n 1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1\n 1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1\n 1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1\n 1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1  1 -1 -1  1\n 1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1\n 1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1\n 1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1  1 -1 -1  1 -1  1  1 -1\n 1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1\n 1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1\n 1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1\n 1 -1  1 -1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1\n 1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1 -1  1 -1  1  1 -1  1 -1  1 -1  1 -1 -1  1 -1  1\n 1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1\n 1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1\n 1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1  1 -1  1 -1  1 -1  1 -1\n 1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1\n 1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1  1 -1\n```\n\n| Natural order | Sequency order |\n| --- | --- |\n| File:Walsh-matrix--order-2--natural-sort-order--raku.svg | File:Walsh-matrix--order-2--sign-changes-sort-order--raku.svg |\n| File:Walsh-matrix--order-4--natural-sort-order--raku.svg | File:Walsh-matrix--order-4--sign-changes-sort-order--raku.svg |\n| File:Walsh-matrix--order-5--natural-sort-order--raku.svg | File:Walsh-matrix--order-5--sign-changes-sort-order--raku.svg |"}]}
{"messages": [{"role": "user", "content": "War Card Game\n\nSimulate the card game War. Use the Bicycle playing card manufacturer's rules. Show a game as played. User input is optional.\n\nReferences:\n\n:   * Bicycle card company: War game site\n\n:   * Wikipedia: War (card game)\n\nRelated tasks:\n\n* Playing cards\n* Card shuffles\n* Deal cards for FreeCell\n* Poker hand\\_analyser\n* Go Fish"}, {"role": "assistant", "content": "The linked Bicycle cards site has slightly different rules for War! than how I used to play when I was but a lad. Implement it both ways.\n\nSome rules are not nailed down very well. Here is how I interpreted it:\n\n* The values of the cards 2-10 are face value; Jack, Queen, King and Ace may effectively be treated as: 11, 12, 13 & 14.\n* Each player plays one card face up. The player whose card is the highest value takes both of the played cards and adds them to the bottom of his deck.\n* When one player runs out of cards and is not able to place enough cards to finish a round, he loses.\n* If both players play a card of the same value, it is then War!\n  + **Bicycle rules:** each player then plays another card face down then another face up.\n  + **thundergnat rules:** each player then plays *three* cards face down then another face up. (Tends to make for shorter games.)\n  + If the final face-up cards are different, the player playing the higher value card takes all of the played cards and adds them to the bottom of his deck\n  + If they are the same, continue with rounds of War! until one player plays a higher value war card or a player runs out of cards.\n* When the winning player picks up his cards. the cards are randomized when added to the bottom of his deck. (Cuts a typical game from multi thousands of rounds to multi hundreds of rounds)\n\nPass in which variant you want to play 2 down, (Bicycle), `--war=2`, 4 down (thundergnat), (default), `--war=4` or 3 down (????) , `--war=3`. By default, there is a short delay (.1 seconds) between rounds so you can watch what is going on. Pass in a larger/smaller value to slow down or speed up how long the game takes. `--sleep=0` or whatever.\n\nIn glorious ANSI color! (The output loses much when pasted in as text so show output as screenshot images.)\n\n```\nunit sub MAIN (:$war where 2..4 = 4, :$sleep = .1);\n\nmy %c = ( # convenience hash of ANSI colors\n    red   => \"\\e[38;2;255;10;0m\",\n    blue  => \"\\e[38;2;05;10;200m\",\n    black => \"\\e[38;2;0;0;0m\"\n);\n\nmy @cards = flat (flat\n     <🂢 🂣 🂤 🂥 🂦 🂧 🂨 🂩 🂪 🂫 🂭 🂮 🂡\n      🃒 🃓 🃔 🃕 🃖 🃗 🃘 🃙 🃚 🃛 🃝 🃞 🃑>.map({ \"{%c<black>}$_\" }),\n     <🂲 🂳 🂴 🂵 🂶 🂷 🂸 🂹 🂺 🂻 🂽 🂾 🂱\n      🃂 🃃 🃄 🃅 🃆 🃇 🃈 🃉 🃊 🃋 🃍 🃎 🃁>.map({ \"{%c<red>}$_\" })\n).batch(13).map({ .flat Z 2..14 })».map: { .[1] but .[0] };\n\nmy $back = \"{%c<blue>}🂠\";\nmy @won  = <👈 👉>;\n\nsub shuffle (@cards) { @cards.pick: * }\nsub deal    (@cards) { [@cards[0,*+2 … *], @cards[1,*+2 … *]] }\n\nmy ($rows, $cols) = qx/stty size/.words».Int; # get the terminal size\nnote \"Terminal is only $cols characters wide, needs to be at least 80, 120 or more recommended.\"\n  and exit if $cols < 80;\n\nsub clean-up {\n    reset-scroll-region;\n    show-cursor;\n    print-at $rows, 1, '';\n    print \"\\e[0m\";\n    exit(0)\n}\n\nsignal(SIGINT).tap: { clean-up() }\n\nmy @index  = ($cols div 2 - 5, $cols div 2 + 4);\nmy @player = (deal shuffle @cards)».Array;\nmy $lose   = False;\n\nsub take (@player, Int $cards) {\n    if +@player >= $cards {\n        return @player.splice(0, $cards);\n    }\n    else {\n         $lose = True;\n         return @player.splice(0, +@player);\n    }\n}\n\nuse Terminal::ANSI;\n\nclear-screen;\nhide-cursor;\n# Set background color\nprint \"\\e[H\\e[J\\e[48;2;245;245;245m\", ' ' xx $rows * $cols + 1;\n\n# Add header\nprint-at 1, $cols div 2 - 1, \"{%c<red>}WAR!\";\nprint-at 2, 1, '━' x $cols;\n\nmy $row = 3;\nmy $height = $rows - $row - 2;\nset-scroll-region($row, $height);\n\n# footer\nprint-at $height + 1, 1, '━' x $cols;\n\nmy $round = 0;\nmy @round;\n\nloop {\n    @round = [@player[0].&take(1)], [@player[1].&take(1)] unless +@round;\n    print-at $row, $cols div 2, \"{%c<red>}┃\";\n    print-at $row, @index[0], @round[0;0] // ' ';\n    print-at $row, @index[1], @round[1;0] // ' ';\n    if $lose {\n        if @player[0] < @player[1] {\n            print-at $row, $cols div 2 + 1, @won[1] unless +@round[1] == 1;\n            print-at $height + 3, $cols div 2 - 10, \"{%c<red>} Player 1 is out of cards \"\n        } else {\n            print-at $row, $cols div 2 - 2, @won[0] unless +@round[0] == 1;\n            print-at $height + 3, $cols div 2 - 10, \"{%c<red>} Player 2 is out of cards \"\n        }\n\n    }\n    if (@round[0].tail // 0) > (@round[1].tail // 0) {\n        print-at $row, $cols div 2 - 2, @won[0];\n        @player[0].append: flat (|@round[0],|@round[1]).pick: *;\n        @round = ();\n    }\n    elsif (@round[0].tail // 0) < (@round[1].tail // 0) {\n        print-at $row, $cols div 2 + 1, @won[1];\n        @player[1].append: flat (|@round[0],|@round[1]).pick: *;\n        @round = ();\n    }\n    else {\n        @round[0].append: @player[0].&take($war);\n        @round[1].append: @player[1].&take($war);\n        print-at $row, @index[0] - $_ * 2, ($_ %% $war) ?? @round[0; $_] !! $back for ^@round[0];\n        print-at $row, @index[1] + $_ * 2, ($_ %% $war) ?? @round[1; $_] !! $back for ^@round[1];\n        next\n    }\n    last if $lose;\n    print-at $height + 2, $cols div 2 - 4,  \"{%c<blue>} Round {++$round} \";\n    print-at $height + 2, $cols div 2 - 40, \"{%c<blue>} Player 1: {+@player[0]} cards \";\n    print-at $height + 2, $cols div 2 + 21, \"{%c<blue>} Player 2: {+@player[1]} cards \";\n    sleep $sleep if +$sleep;\n    if $row >= $height { scroll-up } else { ++$row }\n}\n\n# game over\nprint-at $height + 2, $cols div 2 - 40, \"{%c<blue>} Player 1: {+@player[0] ?? '52' !! \"{%c<red>}0\"}{%c<blue>} cards \";\nprint-at $height + 2, $cols div 2 + 20, \"{%c<blue>} Player 2: {+@player[1] ?? '52' !! \"{%c<red>}0\"}{%c<blue>} cards \";\nclean-up;\n\n```\n\nSample outout Bicycle:\n\nPass in `:war=2` on the command line.\nSee Bicycle variation (offsite png image)\n\nSample outout using defaults:\n\nSee thundergnat variation (offsite png image)"}]}
{"messages": [{"role": "user", "content": "Definitions\n\nLet **n** be a positive integer and **l(n)** be the number of its digits in base **b**.\n\nExpress **n** as the product of its prime factors raised to the appropriate powers. Let **D(n)** be the total number of its base **b** digits in all its prime factors and in all their exponents that are greater than 1.\n\nThen **n** is defined to be:\n\n1. a wasteful (or extravagant) number if l(n) **<** D(n); or\n\n2. an equidigital number if l(n) **=** D(n); or\n\n3. a frugal (or economical) number if l(n) **>** D(n)\n\nin base **b**.\n\nBy convention, the number **1** is considered to be an **equidigital** number in **any** base even though it has no prime factors.\n\nFor the avoidance of any doubt, the number **0** is not a positive integer (and arguably not a natural number either) and so is excluded from all 3 categories.\n\nAn **economical** number is sometimes defined as being one for which l(n) **>=** D(n) though this usage won't be followed here.\n\nExamples\n\nIn base 10, the number 30 has a prime factorization of 2 x 3 x 5. The total number of digits is 3 (all exponents being 1) which is more than the 2 digits 30 has. So 30 is wasteful in base 10.\n\nIn base 10, the number 49 has a prime factorization of 7². The total number of digits, including those of the exponent, is 2 which is the same as the 2 digits 49 has. So 49 is equidigital in base 10.\n\nIn base 10, the number 125 has a prime factorization of 5³. The total number of digits, including those of the exponent, is 2 which is less than the 3 digits 125 has. So 125 is frugal in base 10.\n\nIn base 2, the number 100000 (32 decimal) has a prime factorization of 10^101 (2^5 decimal). The total number of binary digits, including those of the exponent, is 5 which is less than the 6 binary digits 100000 has. So 32 is frugal in base 2 (but equidigital in base 10).\n\nTask\n\nCompute and show here the first **50** and the **10,000th** number in base **10** for each of the three categories of number defined above.\n\nAlso compute and show how many numbers less than **1,000,000** fall into each of the three categories.\n\nBonus\n\nDo the same for base **11**, but show the results in base **10**.\n\nReferences\n\n* OEIS: A046760 - Wasteful numbers\n* OEIS: A046758 - Equidigital numbers\n* OEIS: A046759 - Economical numbers"}, {"role": "assistant", "content": "```\nuse Prime::Factor;\nuse Lingua::EN::Numbers;\n\nmy %cache;\n\nsub factor-char-sum ($n, $base = 10) { sum $n.&prime-factors.Bag.map: { .key.base($base).chars + (.value > 1 ?? .value.base($base).chars !! 0) } }\n\nsub economical  ($n, $base = 10) { ($n >  1) && $n.base($base).chars >  (%cache{$base}[$n] //= factor-char-sum $n, $base) }\nsub equidigital ($n, $base = 10) { ($n == 1) || $n.base($base).chars == (%cache{$base}[$n] //= factor-char-sum $n, $base) }\nsub extravagant ($n, $base = 10) {              $n.base($base).chars <  (%cache{$base}[$n] //= factor-char-sum $n, $base) }\n\n\nfor 10, 11 -> $base {\n    %cache{$base}[3e6] = Any; # preallocate to avoid concurrency issues\n    say \"\\nIn Base $base:\";\n    for &extravagant, &equidigital, &economical -> &sub {\n        say \"\\nFirst 50 {&sub.name} numbers:\";\n        say (^∞).grep( {.&sub($base)} )[^50].batch(10)».&comma».fmt(\"%6s\").join: \"\\n\";\n        say \"10,000th: \" ~ (^∞).hyper(:2000batch).grep( {.&sub($base)} )[9999].&comma;\n    }\n\n    my $upto = 1e6.Int;\n    my atomicint ($extravagant, $equidigital, $economical);\n    say \"\\nOf the positive integers up to {$upto.&cardinal}:\";\n    (1..^$upto).race(:5000batch).map: { .&extravagant($base) ?? ++⚛$extravagant !! .&equidigital($base) ?? ++⚛$equidigital !! ++⚛$economical };\n    say \" Extravagant: {comma $extravagant}\\n Equidigital: {comma $equidigital}\\n  Economical: {comma $economical}\";\n    %cache{$base} = Empty;\n}\n\n```\n\nOutput:\n\n```\nIn Base 10:\n\nFirst 50 extravagant numbers:\n     4      6      8      9     12     18     20     22     24     26\n    28     30     33     34     36     38     39     40     42     44\n    45     46     48     50     51     52     54     55     56     57\n    58     60     62     63     65     66     68     69     70     72\n    74     75     76     77     78     80     82     84     85     86\n10,000th: 14,346\n\nFirst 50 equidigital numbers:\n     1      2      3      5      7     10     11     13     14     15\n    16     17     19     21     23     25     27     29     31     32\n    35     37     41     43     47     49     53     59     61     64\n    67     71     73     79     81     83     89     97    101    103\n   105    106    107    109    111    112    113    115    118    119\n10,000th: 33,769\n\nFirst 50 economical numbers:\n   125    128    243    256    343    512    625    729  1,024  1,029\n 1,215  1,250  1,280  1,331  1,369  1,458  1,536  1,681  1,701  1,715\n 1,792  1,849  1,875  2,048  2,187  2,197  2,209  2,401  2,560  2,809\n 3,125  3,481  3,584  3,645  3,721  4,096  4,374  4,375  4,489  4,802\n 4,913  5,041  5,103  5,329  6,241  6,250  6,561  6,859  6,889  7,203\n10,000th: 1,953,125\n\nOf the positive integers up to one million:\n Extravagant: 831,231\n Equidigital: 165,645\n  Economical: 3,123\n\nIn Base 11:\n\nFirst 50 extravagant numbers:\n     4      6      8      9     10     12     18     20     22     24\n    26     28     30     33     34     36     38     39     40     42\n    44     45     46     48     50     51     52     54     55     56\n    57     58     60     62     63     65     66     68     69     70\n    72     74     75     76     77     78     80     82     84     85\n10,000th: 12,890\n\nFirst 50 equidigital numbers:\n     1      2      3      5      7     11     13     14     15     16\n    17     19     21     23     25     27     29     31     32     35\n    37     41     43     47     49     53     59     61     64     67\n    71     73     79     81     83     89     97    101    103    107\n   109    113    121    122    123    127    129    131    133    134\n10,000th: 33,203\n\nFirst 50 economical numbers:\n   125    128    243    256    343    512    625    729  1,024  1,331\n 1,369  1,458  1,536  1,681  1,701  1,715  1,792  1,849  1,875  2,048\n 2,187  2,197  2,209  2,401  2,560  2,809  3,072  3,125  3,481  3,584\n 3,645  3,721  4,096  4,374  4,375  4,489  4,802  4,913  5,041  5,103\n 5,120  5,329  6,241  6,250  6,561  6,859  6,889  7,168  7,203  7,921\n10,000th: 2,659,171\n\nOf the positive integers up to one million:\n Extravagant: 795,861\n Equidigital: 200,710\n  Economical: 3,428\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nIn a two-dimensional world, we begin with any bar-chart (or row of close-packed 'towers', each of unit width), and then it rains,\ncompletely filling all convex enclosures in the chart with water.\n\n```\n9               ██           9               ██    \n8               ██           8               ██    \n7     ██        ██           7     ██≈≈≈≈≈≈≈≈██    \n6     ██  ██    ██           6     ██≈≈██≈≈≈≈██    \n5 ██  ██  ██  ████           5 ██≈≈██≈≈██≈≈████    \n4 ██  ██  ████████           4 ██≈≈██≈≈████████    \n3 ██████  ████████           3 ██████≈≈████████    \n2 ████████████████  ██       2 ████████████████≈≈██\n1 ████████████████████       1 ████████████████████\n```\n\nIn the example above, a bar chart representing the values [5, 3, 7, 2, 6, 4, 5, 9, 1, 2] has filled, collecting 14 units of water.\n\nWrite a function, in your language, from a given array of heights, to the number of water units that can be held in this way, by a corresponding bar chart.\n\nCalculate the number of water units that could be collected by bar charts representing each of the following seven series:\n\n```\n   [[1, 5, 3, 7, 2],\n    [5, 3, 7, 2, 6, 4, 5, 9, 1, 2],\n    [2, 6, 3, 5, 2, 8, 1, 4, 2, 2, 5, 3, 5, 7, 4, 1],\n    [5, 5, 5, 5],\n    [5, 6, 7, 8],\n    [8, 7, 7, 6],\n    [6, 7, 10, 7, 6]]\n```\n\nSee, also:\n\n* Four Solutions to a Trivial Problem – a Google Tech Talk by Guy Steele\n* Water collected between towers on Stack Overflow, from which the example above is taken)\n* An interesting Haskell solution, using the Tardis monad, by Phil Freeman in a Github gist."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Haskell\n\n```\nsub max_l ( @a ) {  [\\max] @a }\nsub max_r ( @a ) { ([\\max] @a.reverse).reverse }\n\nsub water_collected ( @towers ) {\n    return 0 if @towers <= 2;\n\n    my @levels = max_l(@towers) »min« max_r(@towers);\n\n    return ( @levels »-« @towers ).grep( * > 0 ).sum;\n}\n\nsay map &water_collected,\n    [ 1, 5,  3, 7, 2 ],\n    [ 5, 3,  7, 2, 6, 4, 5, 9, 1, 2 ],\n    [ 2, 6,  3, 5, 2, 8, 1, 4, 2, 2, 5, 3, 5, 7, 4, 1 ],\n    [ 5, 5,  5, 5 ],\n    [ 5, 6,  7, 8 ],\n    [ 8, 7,  7, 6 ],\n    [ 6, 7, 10, 7, 6 ],\n;\n\n```\n\nOutput:\n\n```\n(2 14 35 0 0 0 0)\n```"}]}
{"messages": [{"role": "user", "content": "This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.\n\nThe **Wave Function Collapse** algorithm is a heuristic for generating tiled images.\n\nThe algorithm begins with a collection of equal sized image blocks and randomly places them, one at a time, within a grid subject to the tiling constraint and an entropy constraint, and it wraps (the top row of blocks in the grid is treated as *adjacent* to the bottom row of blocks, and similarly the left and right columns of blocks are treated as adjacent to each other).\n\nThe blocks are tiled within the grid. *Tiled* means they are placed with a one pixel overlap and the tiling constraint requires that the pixels overlapping border between two adjacent blocks match.\n\n*Entropy*, here, means the number of blocks eligible to be placed in an unassigned grid location. The entropy constraint here is that each block is placed in a grid location with minimum entropy. (Placing a block may constrain the entropy of its four nearest neighbors -- up, down, left, right.)\n\nFor this task, we start with five blocks of 3x3 pixels and place them in an 8x8 grid to form a 17x17 tile. A tile is a block which may be tiled with itself. Here, we show these five blocks adjacent but not *tiled*:\n\n|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| |  |  |  | | --- | --- | --- | |  |  |  | |  |  |  | |  |  |  | | |  |  |  | | --- | --- | --- | |  |  |  | |  |  |  | |  |  |  | | |  |  |  | | --- | --- | --- | |  |  |  | |  |  |  | |  |  |  | | |  |  |  | | --- | --- | --- | |  |  |  | |  |  |  | |  |  |  | | |  |  |  | | --- | --- | --- | |  |  |  | |  |  |  | |  |  |  | |\n\nNote that this algorithm sometimes does not succeed. If an unassigned grid location has an entropy of 0, the algorithm fails and returns an empty or null result. We'll ignore those failure cases for this task.\n\nReference WFC explained and another WFC explained"}, {"role": "assistant", "content": "**Translation of**: C\n\n```\n# 20220728 Raku programming solution\n\nmy @Blocks = ( [   <0 0 0>,  \n                   <0 0 0>,  \n\t\t   <0 0 0>    ],\n               [   <0 0 0>,  \n\t           <1 1 1>,  \n\t\t   <0 1 0>    ],\n               [   <0 1 0>, \n\t           <0 1 1>,\n\t       \t   <0 1 0>    ],\n               [   <0 1 0>,\n\t           <1 1 1>,\n\t       \t   <0 0 0>    ],\n               [   <0 1 0>,\n\t           <1 1 0>,\n\t       \t   <0 1 0>    ], );\n\nsub XY(\\row, \\col, \\width) { col+row*width }\nsub XYZ(\\page, \\row, \\col, \\height, \\width) {\n   XY( XY(page, row, height), col, width)\n}\n\nsub wfc(@blocks, @bdim, @tdim) {\n\n   my \\N  = [*] my (\\td0,\\td1) = @tdim[0,1]; \n   my @adj; # indices in R of the four adjacent blocks\n   for ^td0 X ^td1 -> (\\i,\\j) {                        # in a 3x3 grid\n      @adj[XYZ(i,j,0,td1,4)]= XY((i-1)%td0,j%td1,td1); # above (index 1) \n      @adj[XYZ(i,j,1,td1,4)]= XY(i%td0,(j-1)%td1,td1); # left  (index 3) \n      @adj[XYZ(i,j,2,td1,4)]= XY(i%td0,(j+1)%td1,td1); # right (index 5) \n      @adj[XYZ(i,j,3,td1,4)]= XY((i+1)%td0,j%td1,td1); # below (index 7) \n   }\n\n   my (\\bd0,\\bd1,\\bd2) = @bdim[0..2];\n   my @horz; # blocks which can sit next to each other horizontally \n   for ^bd0 X ^bd0 -> (\\i,\\j) {\n      @horz[XY(i,j,bd0)] = 1;\n      for ^bd1 -> \\k {\n         @horz[XY(i, j, bd0)]= 0 if @blocks[XYZ(i, k,     0, bd1, bd2)] !=\n\t                            @blocks[XYZ(j, k, bd2-1, bd1, bd2)]\n      }\n   }\n   \n   my @vert; # blocks which can sit next to each other vertically */\n   for  ^bd0 X ^bd0 -> (\\i,\\j) {\n      @vert[XY(i,j,bd0)] = 1;\n      for ^bd2 -> \\k {\n         if @blocks[XYZ(i,     0, k, bd1, bd2)] != \n\t    @blocks[XYZ(j, bd1-1, k, bd1, bd2)] {\n\t    @vert[XY(i, j, bd0)]= 0 andthen last;\n\t }\n      }\n   }\n\n   my @allow = 1 xx 4*(bd0+1)*bd0; # all block constraints, based on neighbors\n   for  ^bd0 X ^bd0 -> (\\i,\\j) {\n      @allow[XYZ(0, i, j, bd0+1, bd0)] = @vert[XY(j, i, bd0)]; # above (north)\n      @allow[XYZ(1, i, j, bd0+1, bd0)] = @horz[XY(j, i, bd0)]; # left  (west) \n      @allow[XYZ(2, i, j, bd0+1, bd0)] = @horz[XY(i, j, bd0)]; # right (east) \n      @allow[XYZ(3, i, j, bd0+1, bd0)] = @vert[XY(i, j, bd0)]; # below (south) \n   }\n\n   my (@R, @todo, @wave, @entropy, @indices, $min, @possible) = bd0 xx N;\n   loop {\n      my $c = 0;\n      for ^N { @todo[$c++] = $_ if bd0 == @R[$_] }   \n      last unless $c;\n      $min = bd0;\n      for ^$c -> \\i {\n         @entropy[i]= 0;\n         for ^bd0 -> \\j {\n            @entropy[i] += \n               @wave[XY(i, j, bd0)] =\n                  @allow[XYZ(0, @R[@adj[XY(@todo[i],0,4)]], j, bd0+1, bd0)] +& \n                  @allow[XYZ(1, @R[@adj[XY(@todo[i],1,4)]], j, bd0+1, bd0)] +&\n                  @allow[XYZ(2, @R[@adj[XY(@todo[i],2,4)]], j, bd0+1, bd0)] +&\n                  @allow[XYZ(3, @R[@adj[XY(@todo[i],3,4)]], j, bd0+1, bd0)]\n         }\n\t $min = @entropy[i] if @entropy[i] < $min\n      }\n      \n      unless $min { @R=[] andthen last } # original behaviour \n      #unless $min { @R = bd0 xx N andthen redo } # if failure is not an option\n\n      my $d = 0;\n      for ^$c { @indices[$d++] = $_ if $min == @entropy[$_] }\n      my \\ind = bd0 * my \\ndx = @indices[ ^$d .roll ];\n      $d = 0;\n      for ^bd0 { @possible[$d++] = $_ if @wave[ind+$_]  }\n      @R[@todo[ndx]] = @possible[ ^$d .roll ];\n   }\n\n   exit unless @R.Bool;\n\n   my @tile;\n   for ^td0 X ^bd1 X ^td1 X ^bd2 -> (\\i0,\\i1,\\j0,\\j1) {\n      @tile[XY(XY(j0, j1, bd2-1), XY(i0, i1, bd1-1), 1+td1*(bd2-1))] =\n         @blocks[XYZ(@R[XY(i0, j0, td1)], i1, j1, bd1, bd2)]\n   }\n\n   return @tile\n}\n\nmy (@bdims,@size) := (5,3,3), (8,8);\n\nmy @tile = wfc @Blocks».List.flat, @bdims, @size  ;\n\nsay .join.trans( [ '0', '1' ] => [ '  ', '# ' ] ) for @tile.rotor(17)\n\n```\n\nOutput:\n\n```\n          #           #   #\n# # # # # # # # # # # # # # # # #\n  #   #       #   #           #\n  # # # # # # #   # # # # # # #\n  #       #   #   #   #   #   #\n  # # # # #   # # #   # # # # #\n  #   #   #   #   #   #       #\n# #   # # # # #   # # #       # #\n  #   #       #   #   #       #\n# #   # # # # # # # # #       # #\n  #   #   #           #       #\n# #   # # #           # # # # # #\n  #   #   #           #   #\n# #   # # #           # # # # # #\n  #   #   #           #       #\n# # # # # #           # # # # # #\n          #           #   #\n\n```"}]}
{"messages": [{"role": "user", "content": "Analyse a given section of monophonic audio waveform, for average pitch and output one of the sol-fa trigraphs (like these, except each has three letters) corresponding to average pitch level: Doh, Ray, Mee, Fah, Soh, Lah, Tee, doh.\n\nOptionally, follow the trigraph with a plus or minus symbol, to indicate whether the note falls above or below the solfa. Extend the scale to cover 21 notes: DOH, RAY, MEE, FAH, SOH, LAH, TEE, Doh, Ray, Mee, Fah, Soh, Lah, Tee, doh, ray, mee, fah, soh, lah, tee.\n\nA calibration parameter can be provided to suit different voices. This can be provided as a variable defined within the code."}, {"role": "assistant", "content": "The input .wav file (notes.wav) is created by the [Musical Scale#Go] entry.\n\n**Translation of**: Go\n\n```\n# 20200721 Raku programming solution\n\nmy \\freqs = < 261.6 293.6 329.6 349.2 392.0 440.0 493.9 523.3 >;\nmy \\notes = < Doh Ray Mee Fah Soh Lah Tee doh >;\n\nsub getNote (\\freq) {\n   my $index = freqs;\n   for (0..^$index) { $index = $_ and last if freq ≤ freqs[$_] }\n   given $index {\n      when 0     { \"Doh-\" }\n      when freqs { \"doh+\" }\n      default    { freqs[$index] - freq ≤ freq - freqs[$index-1]\n                       ?? notes[$index] ~ \"-\" !! notes[$index-1] ~ \"+\" }\n   }\n}\n\nmy $file = slurp \"./notes.wav\", :bin or die;\n\n# http://www.topherlee.com/software/pcm-tut-wavformat.html\n# https://stackoverflow.com/a/49081648/3386748\n\nmy $sampleRate = Blob.new(@$file[24..27]).read-uint32(0,LittleEndian);\n# self-ref: [+] @$file[24..27].pairs.map: {$_.value*256**$_.key};\nsay \"Sample Rate    : \", $sampleRate;\n\nmy $dataLength = Blob.new(@$file[40..43]).read-uint32(0,LittleEndian);\n# self-ref: [+] @$file[40..43].pairs.map: {$_.value*256**$_.key};\nmy $duration = $dataLength / $sampleRate;\nsay \"Duration       : \", $duration;\n\nmy ( $sum, $sampleRateF )  =  ( 0, $sampleRate.Num ) ;\nmy $nbytes = 20;\n\nsay \"Bytes examined : \", $nbytes, \" per sample\";\n\nfor @$file[44..*].rotor($sampleRate) -> $data {\n   for (1..$nbytes) -> $k {\n      my $bf = @$data[$k] / 32;\n      $sum += $bf.asin × $sampleRateF / ( 2 × π × $k );\n   }\n}\n\nmy $cav = $sum / ( $duration * $nbytes );\nsay \"Computed average frequency = {$cav.fmt('%.1f')} Hz ({getNote($cav)})\";\n\nmy $aav = ([+] freqs) / freqs;\nsay \"Actual   average frequency = {$aav.fmt('%.1f')} Hz ({getNote($aav)})\";\n\n```\n\nOutput:\n\n```\ngo run Musical_scale.go\nfile notes.wav\nnotes.wav: RIFF (little-endian) data, WAVE audio, Microsoft PCM, 8 bit, mono 44100 Hz\n./Doh_ray_me.raku\nSample Rate    : 44100\nDuration       : 8\nBytes examined : 20 per sample\nComputed average frequency = 387.1 Hz (Soh-)\nActual   average frequency = 385.4 Hz (Soh-)\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a program that downloads the time from this URL:   http://tycho.usno.navy.mil/cgi-bin/timer.pl   and then prints the current UTC time by extracting just the UTC time from the web page's HTML. Alternatively, if the above url is not working, grab the first date/time off this page's talk page.\n\nIf possible, only use libraries that come at no *extra* monetary cost with the programming language and that are widely available and popular such as CPAN for Perl or Boost for C++."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\n# 20210301 Updated Raku programming solution\n\nuse HTTP::Client; # https://github.com/supernovus/perl6-http-client/\n\n#`[ Site inaccessible since 2019 ?\nmy $site = \"http://tycho.usno.navy.mil/cgi-bin/timer.pl\";\nHTTP::Client.new.get($site).content.match(/'<BR>'( .+? <ws> UTC )/)[0].say\n# ]\n\nmy $site = \"https://www.utctime.net/\";\nmy $matched = HTTP::Client.new.get($site).content.match(\n   /'<td>UTC</td><td>'( .*Z )'</td>'/\n)[0];\n\nsay $matched;\n#$matched = '12321321:412312312 123';\nwith DateTime.new($matched.Str) {\n   say 'The fetch result seems to be of a valid time format.'\n} else {\n   CATCH { put .^name, ': ', .Str }\n}\n\n```\n\nNote that the string between '<' and '>' refers to regex tokens, so to match a literal '<BR>' you need to quote it, while <ws> refers to the built-in token whitespace.\nAlso, whitespace is ignored by default in Raku regexes.\n\nOutput:\n\n```\n｢2021-03-01T17:02:37Z｣\nThe fetch result seems to be of a valid time format.\n\n```"}]}
{"messages": [{"role": "user", "content": "In number theory, a weird number is a natural number that is abundant but *not* semiperfect (and therefore not perfect either).\n\nIn other words, the sum of the proper divisors of the number (divisors including 1 but not itself) is greater than the number itself (the number is *abundant*), but no subset of those divisors sums to the number itself (the number is not *semiperfect*).\n\nFor example:\n\n* **12** is *not* a weird number.\n  + It is abundant; its proper divisors **1, 2, 3, 4, 6** sum to **16** (which *is* > 12),\n  + but it *is* semiperfect, e.g.:     **6 + 4 + 2 == 12**.\n* **70** *is* a weird number.\n  + It is abundant; its proper divisors **1, 2, 5, 7, 10, 14, 35** sum to **74** (which *is* > 70),\n  + and there is no subset of proper divisors that sum to **70**.\n\nTask\n\nFind and display, here on this page, the first **25** weird numbers.\n\nRelated tasks\n:   * Abundant, deficient and perfect number classifications\n    * Proper divisors\n\nSee also\n:   * OEIS: A006037 weird numbers\n    * Wikipedia: weird number\n    * MathWorld: weird number"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub abundant (\\x) {\n    my @l = x.is-prime ?? 1 !! flat\n    1, (2 .. x.sqrt.floor).map: -> \\d {\n         my \\y = x div d;\n         next if y * d !== x;\n         d !== y ?? (d, y) !! d\n    };\n    (my $s = @l.sum) > x ?? ($s, |@l.sort(-*)) !! ();\n}\n\nmy @weird = (2, 4, {|($_ + 4, $_ + 6)} ... *).map: -> $n {\n    my ($sum, @div) = $n.&abundant;\n    next unless $sum;        # Weird number must be abundant, skip it if it isn't.\n    next if $sum / $n > 1.1; # There aren't any weird numbers with a sum:number ratio greater than 1.08 or so.\n    if $n >= 10430 and ($n %% 70) and ($n div 70).is-prime {\n        # It's weird. All numbers of the form 70 * (a prime 149 or larger) are weird\n    } else {\n        my $next;\n        my $l = @div.shift;\n        ++$next and last if $_.sum == $n - $l for @div.combinations;\n        next if $next;\n    }\n    $n\n}\n\nput \"The first 25 weird numbers:\\n\", @weird[^25];\n\n```\n\nOutput:\n\n```\nThe first 25 weird numbers:\n70 836 4030 5830 7192 7912 9272 10430 10570 10792 10990 11410 11690 12110 12530 12670 13370 13510 13790 13930 14770 15610 15890 16030 16310\n```"}]}
{"messages": [{"role": "user", "content": "Given two lists of data, calculate the p-value used for Welch's t-test. This is meant to translate R's `t.test(vector1, vector2, alternative=\"two.sided\", var.equal=FALSE)` for calculation of the p-value.\n\n**Task Description**\n\nGiven two sets of data, calculate the p-value:\n\n```\n   x = {3.0,4.0,1.0,2.1}\n   y = {490.2,340.0,433.9}\n\n```\n\nYour task is to discern whether or not the difference in means between the two sets is statistically significant and worth further investigation. P-values are significance tests to gauge the probability that the difference in means between two data sets is significant, or due to chance. A threshold level, alpha, is usually chosen, 0.01 or 0.05, where p-values below alpha are worth further investigation and p-values above alpha are considered not significant. The p-value is not considered a final test of significance, only whether the given variable should be given further consideration.\n\nThere is more than one way of calculating the t-statistic, and you must choose which method is appropriate for you. Here we use Welch's t-test, which assumes that the variances between the two sets `x` and `y` are not equal. Welch's t-test statistic can be computed:\n\nt\n\n=\n\nX\n¯\n\n1\n−\n\nX\n¯\n\n2\n\ns\n\n1\n\n2\n\nN\n\n1\n\n+\n\ns\n\n2\n\n2\n\nN\n\n2\n\n{\\displaystyle {\\displaystyle t\\quad =\\quad {\\;{\\overline {X}}\\_{1}-{\\overline {X}}\\_{2}\\; \\over {\\sqrt {\\;{s\\_{1}^{2} \\over N\\_{1}}\\;+\\;{s\\_{2}^{2} \\over N\\_{2}}\\quad }}}}}\n\nwhere\n\nX\n¯\n\nn\n{\\displaystyle {\\displaystyle {\\overline {X}}\\_{n}}}\n is the mean of set \n\nn\n{\\displaystyle {\\displaystyle n}}\n,\n\nand\n\nN\n\nn\n{\\displaystyle {\\displaystyle N\\_{n}}}\n is the number of observations in set \n\nn\n{\\displaystyle {\\displaystyle n}}\n,\n\nand\n\ns\n\nn\n{\\displaystyle {\\displaystyle s\\_{n}}}\n is the square root of the unbiased sample variance of set \n\nn\n{\\displaystyle {\\displaystyle n}}\n, i.e.\n\ns\n\nn\n=\n\n1\n\n\nN\n\nn\n−\n1\n\n∑\n\ni\n=\n1\n\n\nN\n\nn\n\n\n(\n\n\nX\n\ni\n−\n\nX\n¯\n\nn\n)\n\n2\n{\\displaystyle {\\displaystyle s\\_{n}={\\sqrt {{\\frac {1}{N\\_{n}-1}}\\sum \\_{i=1}^{N\\_{n}}\\left(X\\_{i}-{\\overline {X}}\\_{n}\\right)^{2}}}}}\n\nand the degrees of freedom, \n\nν\n{\\displaystyle {\\displaystyle \\nu }}\n can be approximated:\n\nν\n\n≈\n\n(\n\ns\n\n1\n\n2\n\nN\n\n1\n\n+\n\ns\n\n2\n\n2\n\nN\n\n2\n\n)\n\n2\n\ns\n\n1\n\n4\n\n\nN\n\n1\n\n2\n(\n\nN\n\n1\n−\n1\n)\n\n+\n\ns\n\n2\n\n4\n\n\nN\n\n2\n\n2\n(\n\nN\n\n2\n−\n1\n)\n\n{\\displaystyle {\\displaystyle \\nu \\quad \\approx \\quad {{\\left(\\;{s\\_{1}^{2} \\over N\\_{1}}\\;+\\;{s\\_{2}^{2} \\over N\\_{2}}\\;\\right)^{2}} \\over {\\quad {s\\_{1}^{4} \\over N\\_{1}^{2}(N\\_{1}-1)}\\;+\\;{s\\_{2}^{4} \\over N\\_{2}^{2}(N\\_{2}-1)}\\quad }}}}\n\nThe two-tailed p-value, \n\np\n{\\displaystyle {\\displaystyle p}}\n, can be computed as a cumulative distribution function\n\np\n\n2\n−\nt\na\ni\nl\n=\n\nI\n\n\nν\n\n\nt\n\n2\n+\nν\n\n(\n\nν\n2\n,\n\n\n1\n2\n)\n{\\displaystyle {\\displaystyle p\\_{2-tail}=I\\_{\\frac {\\nu }{t^{2}+\\nu }}\\left({\\frac {\\nu }{2}},{\\frac {1}{2}}\\right)}}\n\nwhere I is the regularized incomplete beta function. This is the same as:\n\np\n\n2\n−\nt\na\ni\nl\n=\n\nB\n(\n\n\nν\n\n\nt\n\n2\n+\nν\n;\n\n\nν\n2\n,\n\n\n1\n2\n)\n\n\nB\n(\n\n\nν\n2\n,\n\n\n1\n2\n)\n{\\displaystyle {\\displaystyle p\\_{2-tail}={\\frac {\\mathrm {B} ({\\frac {\\nu }{t^{2}+\\nu }};{\\frac {\\nu }{2}},{\\frac {1}{2}})}{\\mathrm {B} ({\\frac {\\nu }{2}},{\\frac {1}{2}})}}}}\n\nKeeping in mind that\n\nB\n(\nx\n;\na\n,\nb\n)\n=\n\n∫\n\n0\n\nx\n\nr\n\na\n−\n1\n\n(\n1\n−\nr\n\n)\n\nb\n−\n1\n\n\nd\nr\n.\n\n{\\displaystyle {\\displaystyle \\mathrm {B} (x;a,b)=\\int \\_{0}^{x}r^{a-1}\\,(1-r)^{b-1}\\,\\mathrm {d} r.\\!}}\n\nand\n\nB\n(\nx\n,\ny\n)\n=\n\nΓ\n(\nx\n)\n\nΓ\n(\ny\n)\n\nΓ\n(\nx\n+\ny\n)\n=\nexp\n⁡\n(\nln\n⁡\n\nΓ\n(\nx\n)\n\nΓ\n(\ny\n)\n\nΓ\n(\nx\n+\ny\n)\n)\n=\nexp\n⁡\n(\n(\nln\n⁡\n(\nΓ\n(\nx\n)\n)\n+\nln\n⁡\n(\nΓ\n(\ny\n)\n)\n−\nln\n⁡\n(\nΓ\n(\nx\n+\ny\n)\n)\n)\n\n{\\displaystyle {\\displaystyle \\mathrm {B} (x,y)={\\dfrac {\\Gamma (x)\\,\\Gamma (y)}{\\Gamma (x+y)}}=\\exp(\\ln {\\dfrac {\\Gamma (x)\\,\\Gamma (y)}{\\Gamma (x+y)}})=\\exp((\\ln(\\Gamma (x))+\\ln(\\Gamma (y))-\\ln(\\Gamma (x+y)))\\!}}\n\np\n\n2\n−\nt\na\ni\nl\n{\\displaystyle {\\displaystyle p\\_{2-tail}}}\n can be calculated in terms of gamma functions and integrals more simply:\n\np\n\n2\n−\nt\na\ni\nl\n=\n\n∫\n\n0\n\n\nν\n\n\nt\n\n2\n+\nν\n\nr\n\nν\n2\n−\n1\n\n(\n1\n−\nr\n\n)\n\n−\n0.5\n\n\nd\nr\n\nexp\n⁡\n(\n(\nln\n⁡\n(\nΓ\n(\n\n\nν\n2\n)\n)\n+\nln\n⁡\n(\nΓ\n(\n0.5\n)\n)\n−\nln\n⁡\n(\nΓ\n(\n\n\nν\n2\n+\n0.5\n)\n)\n)\n{\\displaystyle {\\displaystyle p\\_{2-tail}={\\frac {\\int \\_{0}^{\\frac {\\nu }{t^{2}+\\nu }}r^{{\\frac {\\nu }{2}}-1}\\,(1-r)^{-0.5}\\,\\mathrm {d} r}{\\exp((\\ln(\\Gamma ({\\frac {\\nu }{2}}))+\\ln(\\Gamma (0.5))-\\ln(\\Gamma ({\\frac {\\nu }{2}}+0.5)))}}}}\n\nwhich simplifies to\n\np\n\n2\n−\nt\na\ni\nl\n=\n\n∫\n\n0\n\n\nν\n\n\nt\n\n2\n+\nν\n\nr\n\nν\n2\n−\n1\n\n1\n−\nr\n\n\nd\nr\n\nexp\n⁡\n(\n(\nln\n⁡\n(\nΓ\n(\n\n\nν\n2\n)\n)\n+\nln\n⁡\n(\nΓ\n(\n0.5\n)\n)\n−\nln\n⁡\n(\nΓ\n(\n\n\nν\n2\n+\n0.5\n)\n)\n)\n{\\displaystyle {\\displaystyle p\\_{2-tail}={\\frac {\\int \\_{0}^{\\frac {\\nu }{t^{2}+\\nu }}{\\frac {r^{{\\frac {\\nu }{2}}-1}}{\\sqrt {1-r}}}\\,\\mathrm {d} r}{\\exp((\\ln(\\Gamma ({\\frac {\\nu }{2}}))+\\ln(\\Gamma (0.5))-\\ln(\\Gamma ({\\frac {\\nu }{2}}+0.5)))}}}}\n\nThe definite integral can be approximated with Simpson's Rule but other methods are also acceptable.\n\nThe \n\nln\n⁡\n(\nΓ\n(\nx\n)\n)\n{\\displaystyle {\\displaystyle \\ln(\\Gamma (x))}}\n, or `lgammal(x)` function is necessary for the program to work with large `a` values, as Gamma functions can often return values larger than can be handled by `double` or `long double` data types. The `lgammal(x)` function is standard in `math.h` with C99 and C11 standards."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Integration using Simpson's Rule\n\n**Works with**: Rakudo version 2019.11\n\n**Translation of**: C\n\nPerhaps \"inspired by C example\" may be more accurate. Gamma subroutine from Gamma function task.\n\n```\nsub Γ(\\z) {\n    constant g = 9;\n    z < .5 ?? π / sin(π × z) / Γ(1 - z) !!\n    τ.sqrt × (z + g - 1/2)**(z - 1/2) ×\n    exp(-(z + g - 1/2)) ×\n    [+] <\n        1.000000000000000174663\n     5716.400188274341379136\n   -14815.30426768413909044\n    14291.49277657478554025\n    -6348.160217641458813289\n     1301.608286058321874105\n     -108.1767053514369634679\n        2.605696505611755827729\n       -0.7423452510201416151527e-2\n        0.5384136432509564062961e-7\n       -0.4023533141268236372067e-8\n    > Z× 1, |map 1/(z + *), 0..*\n}\n\nsub p-value (@A, @B) {\n    return 1 if @A <= 1 or @B <= 1;\n\n    my $a-mean = @A.sum / @A;\n    my $b-mean = @B.sum / @B;\n    my $a-variance = @A.map( { ($a-mean - $_)² } ).sum / (@A - 1);\n    my $b-variance = @B.map( { ($b-mean - $_)² } ).sum / (@B - 1);\n    return 1 unless $a-variance && $b-variance;\n\n    my \\Welchs-𝒕-statistic = ($a-mean - $b-mean)/($a-variance/@A + $b-variance/@B).sqrt;\n\n    my $DoF = ($a-variance / @A + $b-variance / @B)² /\n              (($a-variance² / (@A³ - @A²)) + ($b-variance² / (@B³ - @B²)));\n\n    my $sa = $DoF / 2 - 1;\n    my $x = $DoF / (Welchs-𝒕-statistic² + $DoF);\n    my $N = 65355;\n    my $h = $x / $N;\n    my ( $sum1, $sum2 );\n\n    for ^$N »×» $h -> $i {\n        $sum1 += (($i + $h / 2) ** $sa) / (1 - ($i + $h / 2)).sqrt;\n        $sum2 +=   $i           ** $sa  / (1 -  $i).sqrt;\n    }\n\n    (($h / 6) × ( $x ** $sa / (1 - $x).sqrt + 4 × $sum1 + 2 × $sum2)) /\n     ( Γ($sa + 1) × π.sqrt / Γ($sa + 1.5) );\n}\n\n# Testing\nfor (\n  [<27.5 21.0 19.0 23.6 17.0 17.9 16.9 20.1 21.9 22.6 23.1 19.6 19.0 21.7 21.4>],\n  [<27.1 22.0 20.8 23.4 23.4 23.5 25.8 22.0 24.8 20.2 21.9 22.1 22.9 20.5 24.4>],\n\n  [<17.2 20.9 22.6 18.1 21.7 21.4 23.5 24.2 14.7 21.8>],\n  [<21.5 22.8 21.0 23.0 21.6 23.6 22.5 20.7 23.4 21.8 20.7 21.7 21.5 22.5 23.6 21.5 22.5 23.5 21.5 21.8>],\n\n  [<19.8 20.4 19.6 17.8 18.5 18.9 18.3 18.9 19.5 22.0>],\n  [<28.2 26.6 20.1 23.3 25.2 22.1 17.7 27.6 20.6 13.7 23.2 17.5 20.6 18.0 23.9 21.6 24.3 20.4 24.0 13.2>],\n\n  [<30.02 29.99 30.11 29.97 30.01 29.99>],\n  [<29.89 29.93 29.72 29.98 30.02 29.98>],\n\n  [<3.0 4.0 1.0 2.1>],\n  [<490.2 340.0 433.9>]\n) -> @left, @right { say p-value @left, @right }\n\n```\n\nOutput:\n\n```\n0.0213780014628669\n0.148841696605328\n0.0359722710297969\n0.0907733242856673\n0.010751534033393\n\n```\n\n### Using Burkhardt's 'incomplete beta'\n\n**Works with**: Rakudo version 2019.11\n\n**Translation of**: Perl\n\nThis uses the Soper reduction formula to evaluate the integral, which converges much more quickly than Simpson's formula.\n\n```\nsub lgamma ( Num(Real) \\n --> Num ){\n  use NativeCall;\n  sub lgamma (num64 --> num64) is native {}\n  lgamma( n )\n}\n\nsub p-value (@a, @b) {\n    return 1 if @a.elems | @b.elems ≤ 1;\n    my $mean1 = @a.sum / @a.elems;\n    my $mean2 = @b.sum / @b.elems;\n    return 1 if $mean1 == $mean2;\n\n    my $variance1 = sum (@a «-» $mean1) X**2;\n    my $variance2 = sum (@b «-» $mean2) X**2;\n    return 1 if $variance1 | $variance2 == 0;\n\n    $variance1 /= @a.elems - 1;\n    $variance2 /= @b.elems - 1;\n    my $Welchs-𝒕-statistic = ($mean1-$mean2)/sqrt($variance1/@a.elems+$variance2/@b.elems);\n    my $DoF = ($variance1/@a.elems + $variance2/@b.elems)² /\n               (($variance1 × $variance1)/(@a.elems × @a.elems × (@a.elems-1)) +\n                ($variance2 × $variance2)/(@b.elems × @b.elems × (@b.elems-1))\n               );\n    my $A     = $DoF / 2;\n    my $value = $DoF / ($Welchs-𝒕-statistic² + $DoF);\n    return $value if $A | $value ≤ 0 or $value ≥ 1;\n\n    # from here, translation of John Burkhardt's C\n    my $beta  = lgamma($A) + 0.57236494292470009 - lgamma($A+0.5); # constant is logΓ(.5), more precise than 'lgamma' routine\n    my $eps   = 10**-15;\n    my $psq = $A + 0.5;\n    my $cx = 1 - $value;\n    my ($xx,$pp,$qq,$indx);\n    if $A < $psq × $value { ($xx, $cx, $pp, $qq, $indx) = $cx, $value, 0.5,  $A, 1 }\n    else                  { ($xx,      $pp, $qq, $indx) =      $value,  $A, 0.5, 0 }\n    my $term = my $ai = $value = 1;\n    my $ns = floor $qq + $cx × $psq;\n\n    # Soper reduction formula\n    my $qq-ai = $qq - $ai;\n    my $rx = $ns == 0 ?? $xx !! $xx / $cx;\n    loop {\n        $term  ×= $qq-ai × $rx / ($pp + $ai);\n        $value += $term;\n        $qq-ai  = $term.abs;\n        if $qq-ai ≤ $eps & $eps×$value {\n            $value = $value × ($pp × $xx.log + ($qq - 1) × $cx.log - $beta).exp / $pp;\n            $value = 1 - $value if $indx;\n            last\n        }\n        $ai++;\n        $ns--;\n        if $ns ≥ 0 {\n            $qq-ai = $qq - $ai;\n            $rx    = $xx if $ns == 0;\n        } else {\n            $qq-ai = $psq;\n            $psq  += 1;\n        }\n    }\n    $value\n}\n\nmy $error = 0;\nmy @answers = (\n0.021378001462867,\n0.148841696605327,\n0.0359722710297968,\n0.090773324285671,\n0.0107515611497845,\n0.00339907162713746,\n0.52726574965384,\n0.545266866977794,\n);\n\nfor (\n    [<27.5 21.0 19.0 23.6 17.0 17.9 16.9 20.1 21.9 22.6 23.1 19.6 19.0 21.7 21.4>],\n    [<27.1 22.0 20.8 23.4 23.4 23.5 25.8 22.0 24.8 20.2 21.9 22.1 22.9 20.5 24.4>],\n\n    [<17.2 20.9 22.6 18.1 21.7 21.4 23.5 24.2 14.7 21.8>],\n    [<21.5 22.8 21.0 23.0 21.6 23.6 22.5 20.7 23.4 21.8 20.7 21.7 21.5 22.5 23.6 21.5 22.5 23.5 21.5 21.8>],\n\n    [<19.8 20.4 19.6 17.8 18.5 18.9 18.3 18.9 19.5 22.0>],\n    [<28.2 26.6 20.1 23.3 25.2 22.1 17.7 27.6 20.6 13.7 23.2 17.5 20.6 18.0 23.9 21.6 24.3 20.4 24.0 13.2>],\n\n    [<30.02 29.99 30.11 29.97 30.01 29.99>],\n    [<29.89 29.93 29.72 29.98 30.02 29.98>],\n\n    [<3.0 4.0 1.0 2.1>],\n    [<490.2 340.0 433.9>],\n\n    [<0.010268 0.000167 0.000167>],\n    [<0.159258 0.136278 0.122389>],\n\n    [<1.0/15 10.0/62.0>],\n    [<1.0/10 2/50.0>],\n\n    [<9/23.0 21/45.0 0/38.0>],\n    [<0/44.0 42/94.0 0/22.0>],\n) -> @left, @right {\n    my $p-value = p-value @left, @right;\n    printf(\"p-value = %.14g\\n\",$p-value);\n    $error += abs($p-value - shift @answers);\n}\nprintf(\"cumulative error is %g\\n\", $error);\n\n```\n\nOutput:\n\n```\np-value = 0.021378001462867\np-value = 0.14884169660533\np-value = 0.035972271029797\np-value = 0.090773324285667\np-value = 0.010751561149784\np-value = 0.0033990716271375\np-value = 0.52726574965384\np-value = 0.54526686697779\ncumulative error is 5.30131e-15\n```"}]}
{"messages": [{"role": "user", "content": "|  |\n| --- |\n| This page uses content from **Wikipedia**. The original article was at Wieferich prime. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |\n\nIn number theory, a **Wieferich prime** is a prime number  ***p***  such that  ***p2***  evenly divides  ***2(p − 1) − 1*** .\n\nIt is conjectured that there are infinitely many Wieferich primes, but as of March 2021,only two have been identified.\n\nTask\n\n* Write a routine (function procedure, whatever) to find Wieferich primes.\n\n* Use that routine to identify and display all of the Wieferich primes less than 5000.\n\nSee also\n\n* OEIS A001220 - Wieferich primes"}, {"role": "assistant", "content": "```\nput \"Wieferich primes less than 5000: \", join ', ', ^5000 .grep: { .is-prime and not ( exp($_-1, 2) - 1 ) % .² };\n\n```\n\nOutput:\n\n```\nWieferich primes less than 5000: 1093, 3511\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nMake a file that can be useful with spell checkers like Ispell and Aspell.\n\nUse the wiktionary dump (input) to create a file equivalent to \"/usr/share/dict/spanish\" (output). The input file is an XML dump of the Wiktionary that is a bz2'ed file of about 800MB. The output file should be a file similar to \"/usr/share/dict/spanish\", a simple text file each line of which is one word in the given language. An example of such a file is available in Ubuntu with the package **wspanish**."}, {"role": "assistant", "content": "I misunderstood the data format and now just copy verbatim from Julia entry the processing logics ..\n\n```\n# 20211209 Raku programming solution \n\nuse LWP::Simple;\nuse Compress::Bzip2;\nuse IO::Socket::SSL;\n\nmy $LanguageMark = \"==French==\";\nmy $Target       = 5; # words\nmy $URL          = 'https://dumps.wikimedia.org/enwiktionary/latest/enwiktionary-latest-pages-articles.xml.bz2';\n\nclass CustomLWP is LWP::Simple { has $.URL ;\n\n   method CustomRequest {\n\n      my Blob $resp          = Buf.new;\n      my $bzip               = Compress::Bzip2::Stream.new;\n      my ( $tail, %needles ) = '';\n\n      my ($host, $port, $path) = self.parse_url($.URL)[1..3]; \n      my $sock = IO::Socket::SSL.new: :$host, :$port;\n\n      $sock.print( \"GET {$path} HTTP/1.1\\r\\n\" ~ self.stringify_headers( { \n         'Connection'  => 'close', \n         'User-Agent'  => \"LWP::Simple/{LWP::Simple::<$VERSION>} \" ~\n                          \"Raku/{$*RAKU.compiler.gist}\",\n         'Host'        => $host\n      } ) ~ \"\\r\\n\" ) or die ;       # request string\n\n      while !self.got-header($resp) { $resp ~= $sock.read(2048) }\n\n      my $bzip-stream = supply {\n         emit self.parse_response($resp)[2]; # $resp_content @ parent class \n         loop { \n            done if %needles.elems >= $Target ;\n            ( my $chunk = $sock.read(4096) ) ?? emit $chunk !! done \n         }\n      } \n\n      react {\n         whenever $bzip-stream -> $crypt {\n            my $plain     = ( [~] $bzip.decompress: $crypt ).decode('utf8-c8');\n            my @haystacks = $plain.split: \"\\n\";\n            @haystacks[0] = $tail ~ @haystacks[0]; \n            $tail         = @haystacks[*-1];\n\n            my ($title,$got_text_last) = '', False ; \n\n            for @haystacks[0..*-2] { \n               if / '<title>' (\\w+?) '</title>' / {\n                  ($title,$got_text_last) = $0, False;\n               } elsif /   '<text'     / {  \n                  $got_text_last = True\n               } elsif / $LanguageMark / {\n                  %needles{$title}++ if ( $got_text_last and $title.Bool );  \n                  last if ( %needles.elems >= $Target ) ; \n                  $got_text_last = False;\n               } elsif /  '</text>'    / { $got_text_last = False } \n            }\n         }\n      }\n      return %needles.keys[^$Target]\n   }\n}\n\nmy $ua = CustomLWP.new: URL => $URL ;\n\n$ua.CustomRequest>>.say\n\n```\n\nOutput:\n\n```\nchien\ngratuit\ngratis\npond\nlivre\n\n```"}]}
{"messages": [{"role": "user", "content": "Definition\n\nA Wilson prime of order n is a prime number   **p**   such that   **p2**   exactly divides:\n\n```\n     (n − 1)! × (p − n)! − (− 1)n \n\n```\n\nIf   **n**   is   **1**,   the latter formula reduces to the more familiar:   **(p - n)! + 1**   where the only known examples for   **p**   are   **5**,   **13**,   and   **563**.\n\nTask\n\nCalculate and show on this page the Wilson primes, if any, for orders **n = 1 to 11 inclusive** and for primes **p < 18**   or,\n  \nif your language supports *big integers*, for **p < 11,000**.\n\nRelated task\n:   * Primality by Wilson's theorem"}, {"role": "assistant", "content": "```\n# Factorial\nsub postfix:<!> (Int $n) { (constant f = 1, |[\\×] 1..*)[$n] }\n\n# Invisible times\nsub infix:<⁢> is tighter(&infix:<**>) { $^a * $^b };\n\n# Prime the iterator for thread safety\nsink 11000!;\n\nmy @primes = ^1.1e4 .grep: *.is-prime;\n\nsay\n'  n: Wilson primes\n────────────────────';\n\n.say for (1..40).hyper(:1batch).map: -> \\𝒏 { \n    sprintf \"%3d: %s\", 𝒏, @primes.grep( -> \\𝒑 { (𝒑 ≥ 𝒏) && ((𝒏 - 1)!⁢(𝒑 - 𝒏)! - (-1) ** 𝒏) %% 𝒑² } ).Str\n}\n\n```\n\nOutput:\n\n```\n  n: Wilson primes\n────────────────────\n  1: 5 13 563\n  2: 2 3 11 107 4931\n  3: 7\n  4: 10429\n  5: 5 7 47\n  6: 11\n  7: 17\n  8: \n  9: 541\n 10: 11 1109\n 11: 17 2713\n 12: \n 13: 13\n 14: \n 15: 349\n 16: 31\n 17: 61 251 479\n 18: \n 19: 71\n 20: 59 499\n 21: \n 22: \n 23: \n 24: 47 3163\n 25: \n 26: \n 27: 53\n 28: 347\n 29: \n 30: 137 1109 5179\n 31: \n 32: 71\n 33: 823 1181 2927\n 34: 149\n 35: 71\n 36: \n 37: 71 1889\n 38: \n 39: 491\n 40: 59 71 1171\n```"}]}
{"messages": [{"role": "user", "content": "Display a GUI window. The window need not have any contents, but should respond to requests to be closed."}, {"role": "assistant", "content": "(formerly Perl 6)\n**Library** GTK\n\nExit either by clicking the button or the close window control in the upper corner.\n\n```\nuse GTK::Simple;\nuse GTK::Simple::App;\n\nmy GTK::Simple::App $app .= new(title => 'Simple GTK Window');\n\n$app.size-request(250, 100);\n\n$app.set-content(\n    GTK::Simple::VBox.new(\n        my $button = GTK::Simple::Button.new(label => 'Exit'),\n    )\n);\n\n$app.border-width = 40;\n\n$button.clicked.tap: { $app.exit }\n\n$app.run;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nCreate a simple **X11** application,   using an **X11** protocol library such as Xlib or XCB,   that draws a box and   \"Hello World\"   in a window.\n\nImplementations of this task should   *avoid using a toolkit*   as much as possible."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: C\n\nThere is not yet a X11 library in Raku but we can write the minimal C mappings for this task.\n\n```\nuse NativeCall;\n\nclass Display is repr('CStruct') {\n    has int32 $!screen;\n    has int32 $!window;\n }\nclass GC      is repr('CStruct') {\n    has int32 $!context;\n}\nclass XEvent  is repr('CStruct') {\n    has int32 $.type;\n    method init { $!type = 0 }\n}\n\nsub XOpenDisplay(Str $name = ':0') returns Display is native('X11') { * }\nsub XDefaultScreen(Display $) returns int32 is native('X11') { * }\nsub XRootWindow(Display $, int32 $screen_number) returns int32 is native('X11') { * }\nsub XBlackPixel(Display $, int32 $screen_number) returns int32 is native('X11') { * }\nsub XWhitePixel(Display $, int32 $screen_number) returns int32 is native('X11') { * }\nsub XCreateSimpleWindow(\n    Display $, int32 $parent_window, int32 $x, int32 $y,\n    int32 $width, int32 $height, int32 $border_width,\n    int32 $border, int32 $background\n) returns int32 is native('X11') { * }\nsub XMapWindow(Display $, int32 $window) is native('X11') { * }\nsub XSelectInput(Display $, int32 $window, int32 $mask) is native('X11') { * }\nsub XFillRectangle(\n    Display $, int32 $window, GC $, int32 $x, int32 $y, int32 $width, int32 $height\n) is native('X11') { * }\nsub XDrawString(\n    Display $, int32 $window, GC $, int32 $x, int32 $y, Str $, int32 $str_length\n) is native('X11') { * }\nsub XDefaultGC(Display $, int32 $screen) returns GC is native('X11') { * }\nsub XNextEvent(Display $, XEvent $e)              is native('X11') { * }\nsub XCloseDisplay(Display $)                      is native('X11') { * }\n\nmy Display $display = XOpenDisplay()\n    or die \"Can not open display\";\n\nmy int $screen = XDefaultScreen($display);\nmy int $window = XCreateSimpleWindow(\n    $display,\n    XRootWindow($display, $screen),\n    10, 10, 100, 100, 1,\n    XBlackPixel($display, $screen), XWhitePixel($display, $screen)\n);\nXSelectInput($display, $window, 1 +< 15 +| 1);\nXMapWindow($display, $window);\n\nmy Str $msg = 'Hello, World!';\nmy XEvent $e .= new; $e.init;\nloop {\n    XNextEvent($display, $e);\n    if $e.type == 12 {\n\t    XFillRectangle($display, $window, XDefaultGC($display, $screen), 20, 20, 10, 10);\n\t    XDrawString($display, $window, XDefaultGC($display, $screen), 10, 50, $msg, my int $ = $msg.chars);\n    }\n    elsif $e.type == 2 {\n\t    last;\n    }\n}\nXCloseDisplay($display);\n\n```"}]}
{"messages": [{"role": "user", "content": "Treat windows or at least window identities as first class objects.\n\n* Store window identities in variables, compare them for equality.\n* Provide examples of performing some of the following:\n  + hide,\n  + show,\n  + close,\n  + minimize,\n  + maximize,\n  + move,     and\n  + resize a window.\n\nThe window of interest may or may not have been created by your program."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.12\n\nThis are generic window handling routines. They work for any window managed by the X11 display server, not just windows created by the program.\n\n```\nuse X11::libxdo;\n\nmy $xdo = Xdo.new;\n\nsay 'Visible windows:';\nprintf \"Class: %-21s ID#: %10d  pid: %5d  Name: %s\\n\", $_<class ID pid name>\n    for $xdo.get-windows.sort(+*.key)».value;\nsleep 2;\n\nmy $id = $xdo.get-active-window;\n\nmy ($w,  $h ) = $xdo.get-window-size( $id );\nmy ($wx, $wy) = $xdo.get-window-location( $id );\nmy ($dw, $dh) = $xdo.get-desktop-dimensions( 0 );\n\n$xdo.move-window( $id, 150, 150 );\n\n$xdo.set-window-size( $id, 350, 350, 0 );\n\nsleep .25;\n\nfor flat 1 .. $dw - 350, $dw - 350, {$_ - 1} … 1 -> $mx { #\n    my $my = (($mx / $dw * τ).sin * 500).abs.Int;\n    $xdo.move-window( $id, $mx, $my );\n    $xdo.activate-window($id);\n}\n\nsleep .25;\n\n$xdo.move-window( $id, 150, 150 );\n\nmy $dx = $dw - 300;\nmy $dy = $dh - 300;\n\n$xdo.set-window-size( $id, $dx, $dy, 0 );\n\nsleep .25;\n\nmy $s = -1;\n\nloop {\n    $dx += $s * ($dw / 200).ceiling;\n    $dy += $s * ($dh / 200).ceiling;\n    $xdo.set-window-size( $id, $dx, $dy, 0 );\n    $xdo.activate-window($id);\n    sleep .005;\n    $s *= -1 if $dy < 200;\n    last if $dx >= $dw;\n}\n\nsleep .25;\n\n$xdo.set-window-size( $id, $w, $h, 0 );\n$xdo.move-window( $id, $wx, $wy );\n$xdo.activate-window($id);\n\nsleep .25;\n\n$xdo.minimize($id);\n$xdo.activate-window($id);\nsleep 1;\n$xdo.raise-window($id);\nsleep .25;\n\n```"}]}
{"messages": [{"role": "user", "content": "Wireworld is a cellular automaton with some similarities to Conway's Game of Life.\n\nIt is capable of doing sophisticated computations with appropriate programs\n(it is actually Turing complete),\nand is much simpler to program for.\n\nA Wireworld arena consists of a Cartesian grid of cells,\neach of which can be in one of four states.\nAll cell transitions happen simultaneously.\n\nThe cell transition rules are this:\n\n:   :   | Input State | Output State | Condition |\n        | --- | --- | --- |\n        | empty | empty |  |\n        | electron head | electron tail |  |\n        | electron tail | conductor |  |\n        | conductor | electron head | if 1 or 2 cells in the neighborhood of the cell are in the state “electron head” |\n        | conductor | conductor | otherwise |\n\nTask\n\nCreate a program that reads a Wireworld program from a file and displays an animation of the processing. Here is a sample description file (using \"H\" for an electron head, \"t\" for a tail, \".\" for a conductor and a space for empty) you may wish to test with, which demonstrates two cycle-3 generators and an inhibit gate:\n\n```\ntH.........\n.   .\n   ...\n.   .\nHt.. ......\n\n```\n\nWhile text-only implementations of this task are possible, mapping cells to pixels is advisable if you wish to be able to display large designs. The logic is not significantly more complex."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nclass Wireworld {\n    has @.line;\n    method height returns Int { @!line.elems }\n    method width  returns Int { max @!line».chars }\n\n    multi method new(@line) { samewith :@line }\n    multi method new($str ) { samewith $str.lines }\n\n    method gist { join \"\\n\", @.line }\n\n    method !neighbors($i where ^$.height, $j where ^$.width)\n    {\n        my @i = grep ^$.height, $i «+« (-1, 0, 1);\n        my @j = grep ^$.width,  $j «+« (-1, 0, 1);\n        gather for @i X @j -> (\\i, \\j) {\n            next if [ i, j ] ~~ [ $i, $j ];\n            take @!line[i].comb[j];\n        }\n    }\n    method succ {\n        my @succ;\n        for ^$.height X ^$.width -> ($i, $j) {\n            @succ[$i] ~=\n            do given @.line[$i].comb[$j] {\n                when 'H' { 't' }\n                when 't' { '.' }\n                when '.' {\n                    grep('H', self!neighbors($i, $j)) == 1|2 ?? 'H' !! '.'\n                }\n                default { ' ' }\n            }\n        }\n        return self.new: @succ;\n    }\n}\n\nmy %*SUB-MAIN-OPTS;\n%*SUB-MAIN-OPTS<named-anywhere> = True;\n\nmulti sub MAIN (\n    IO()      $filename,\n    Numeric:D :$interval = 1/4,\n    Bool      :$stop-on-repeat,\n) {\n    run-loop :$interval, :$stop-on-repeat, Wireworld.new: $filename.slurp;\n}\n\n#| run a built-in example\nmulti sub MAIN (\n    Numeric:D :$interval = 1/4,\n    Bool      :$stop-on-repeat,\n) {\n    run-loop\n      :$interval,\n      :$stop-on-repeat,\n      Wireworld.new:\n\tQ:to/§/\n\ttH.........\n\t.   .\n\t   ...\n\t.   .\n\tHt.. ......\n\t§\n}\n\nsub run-loop (\n    Wireworld:D     $initial,\n    Real:D(Numeric) :$interval = 1/4,\n    Bool            :$stop-on-repeat\n){\n    my %seen is SetHash;\n\n    print \"\\e7\";                # save cursor position\n    for $initial ...^ * eqv * { # generate a sequence (uses .succ)\n      print \"\\e8\";              # restore cursor position\n      .say;\n      last if $stop-on-repeat and %seen{ .gist }++;\n      sleep $interval;\n    }\n}\n\n```\n\nWhen run with `--stop-on-repeat`\n\nOutput:\n\n```\nH.tH.tH.tH.\nt   .      \n   ttt     \nt   .      \n.H.t ......\n```"}]}
{"messages": [{"role": "user", "content": "A Wolstenholme number is a number that is the fully reduced numerator of a second order harmonic number:\n\nH\n\nn\n,\n2\n=\n\n∑\n\nk\n=\n1\n\nn\n\n\n1\n\nk\n\n2\n.\n{\\displaystyle H\\_{n,2}=\\sum \\_{k=1}^{n}{\\frac {1}{k^{2}}}.}\n\nPrime Wolstenholme numbers are Wolstenholme numbers that are prime.\n\n(Oddly enough, there is also a class of numbers called Wolstenholme primes that are **not** Wolstenholme numbers that are prime. This is not them.)\n\nTask\n\n* Find and display the first 20 Wolstenholme numbers. (Or as many as reasonably supported by your language if it is fewer.)\n* Find and display the first 4 prime Wolstenholme numbers. (Or as many as reasonably supported by your language if it is fewer.)\n\nStretch\n\n* Find and display the digit count of the 500th, 1000th, 2500th, 5000th, 10000th Wolstenholme numbers.\n* Find and display the digit count of the first 15 prime Wolstenholme numbers.\n\nSee also\n\n* Wikipedia: Wolstenholme number * OEIS:A007406 - Wolstenholme numbers * OEIS:A123751 - Prime Wolstenholme numbers"}, {"role": "assistant", "content": "```\nuse Lingua::EN::Numbers;\n\nsub abbr ($_) { .chars < 41 ?? $_ !! .substr(0,20) ~ '..' ~ .substr(*-20) ~ \" (digits: {.chars})\" }\n\nmy @wolstenholme = lazy ([\\+] (1..∞).hyper.map: {FatRat.new: 1, .²}).map: *.numerator;\n\nsay 'Wolstenholme numbers:';\nprintf \"%8s: %s\\n\", .&ordinal-digit(:c), abbr @wolstenholme[$_-1] for flat 1..20, 5e2, 1e3, 2.5e3, 5e3, 1e4;\n\nsay \"\\nPrime Wolstenholme numbers:\";\nprintf \"%8s: %s\\n\", .&ordinal-digit(:c), @wolstenholme.grep(&is-prime)[$_-1]».&abbr for 1..15;\n\n```\n\nOutput:\n\n```\nWolstenholme numbers:\n     1st: 1\n     2nd: 5\n     3rd: 49\n     4th: 205\n     5th: 5269\n     6th: 5369\n     7th: 266681\n     8th: 1077749\n     9th: 9778141\n    10th: 1968329\n    11th: 239437889\n    12th: 240505109\n    13th: 40799043101\n    14th: 40931552621\n    15th: 205234915681\n    16th: 822968714749\n    17th: 238357395880861\n    18th: 238820721143261\n    19th: 86364397717734821\n    20th: 17299975731542641\n   500th: 40989667509417020364..48084984597965892703 (digits: 434)\n 1,000th: 83545938483149689478..99094240207812766449 (digits: 866)\n 2,500th: 64537911900230612090..12785535902976933153 (digits: 2164)\n 5,000th: 34472086597488537716..22525144829082590451 (digits: 4340)\n10,000th: 54714423173933343999..49175649667700005717 (digits: 8693)\n\nPrime Wolstenholme numbers:\n     1st: 5\n     2nd: 266681\n     3rd: 40799043101\n     4th: 86364397717734821\n     5th: 36190908596780862323..79995976006474252029 (digits: 104)\n     6th: 33427988094524601237..48446489305085140033 (digits: 156)\n     7th: 22812704758392002353..84405125167217413149 (digits: 218)\n     8th: 28347687473208792918..45794572911130248059 (digits: 318)\n     9th: 78440559440644426017..30422337523878698419 (digits: 520)\n    10th: 22706893975121925531..02173859396183964989 (digits: 649)\n    11th: 27310394808585898968..86311385662644388271 (digits: 935)\n    12th: 13001072736642048751..08635832246554146071 (digits: 984)\n    13th: 15086863305391456002..05367804007944918693 (digits: 1202)\n    14th: 23541935187269979100..02324742766220468879 (digits: 1518)\n    15th: 40306783143871607599..58901192511859288941 (digits: 1539)\n```"}]}
{"messages": [{"role": "user", "content": "Task\n:   Given an input string and a dictionary of words, segment the input string into a space-separated sequence of dictionary words if possible.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2017.04\n\nThis implementation does not necessarily find *every* combination, it returns the one with the longest matching tokens.\n\n```\nmy @words = <a bc abc cd b>;\nmy $regex = @words.join('|');\n\nput \"$_: \", word-break($_) for <abcd abbc abcbcd acdbc abcdd>;\n\nsub word-break (Str $word) { ($word ~~ / ^ (<$regex>)+ $ /)[0] // \"Not possible\" }\n\n```\n\nOutput:\n\n```\nabcd: a b cd\nabbc: a b bc\nabcbcd: abc b cd\nacdbc: a cd bc\nabcdd: Not possible\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nGiven a text file and an integer   **n**,   print/display the   **n**   most\ncommon words in the file   (and the number of their occurrences)   in decreasing frequency.\n\nFor the purposes of this task:\n\n* A word is a sequence of one or more contiguous letters.\n* You are free to define what a   *letter*   is.\n* Underscores, accented letters, apostrophes, hyphens, and other special characters can be handled at your discretion.\n* You may treat a compound word like   **well-dressed**   as either one word or two.\n* The word   **it's**   could also be one or two words as you see fit.\n* You may also choose not to support non US-ASCII characters.\n* Assume words will not span multiple lines.\n* Don't worry about normalization of word spelling differences.\n* Treat   **color**   and   **colour**   as two distinct words.\n* Uppercase letters are considered equivalent to their lowercase counterparts.\n* Words of equal frequency can be listed in any order.\n* Feel free to explicitly state the thoughts behind the program decisions.\n\nShow example output using Les Misérables from Project Gutenberg as the text file input and display the top   **10**   most used words.\n\nHistory\n\nThis task was originally taken from programming pearls from Communications of the ACM June 1986 Volume 29 Number 6\nwhere this problem is solved by Donald Knuth using literate programming and then critiqued by Doug McIlroy,\ndemonstrating solving the problem in a 6 line Unix shell script (provided as an example below).\n\nReferences\n\n* McIlroy's program\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2022.07\n\nNote: much of the following exposition is no longer critical to the task as the requirements have been updated, but is left here for historical and informational reasons.\n\nThis is slightly trickier than it appears initially. The task specifically states: \"A word is a sequence of one or more contiguous letters\", so contractions and hyphenated words are broken up. Initially we might reach for a regex matcher like /\\w+/ , but \\w includes underscore, which is not a letter but a punctuation connector; and this text is **full** of underscores since that is how Project Gutenberg texts denote italicized text. The underscores are not actually parts of the words though, they are markup.\n\nWe might try /A-Za-z/ as a matcher but this text is bursting with French words containing various diacritics. Those **are** letters, so words will be incorrectly split up; (Misérables will be counted as 'mis' and 'rables', probably not what we want.)\n\nActually, in this case /A-Za-z/ returns **very nearly** the correct answer. Unfortunately, the name \"Alèthe\" appears once (only once!) in the text, gets incorrectly split into Al & the, and incorrectly reports 41089 occurrences of \"the\".\nThe text has several words like \"Panathenæa\", \"ça\", \"aérostiers\" and \"Keksekça\" so the counts for 'a' are off too. The other 8 of the top 10 are \"correct\" using /A-Za-z/, but it is mostly by accident.\n\nA more accurate regex matcher would be some kind of Unicode aware /\\w/ minus underscore. It may also be useful, depending on your requirements, to recognize contractions with embedded apostrophes, hyphenated words, and hyphenated words broken across lines.\n\nHere is a sample that shows the result when using various different matchers.\n\n```\nsub MAIN ($filename, UInt $top = 10) {\n    my $file = $filename.IO.slurp.lc.subst(/ (<[\\w]-[_]>'-')\\n(<[\\w]-[_]>) /, {$0 ~ $1}, :g );\n    my @matcher = \n        rx/ <[a..z]>+ /,    # simple 7-bit ASCII\n        rx/ \\w+ /,          # word characters with underscore\n        rx/ <[\\w]-[_]>+ /,  # word characters without underscore\n        rx/ [<[\\w]-[_]>+]+ % < ' - '- > /  # word characters without underscore but with hyphens and contractions\n    ;\n    for @matcher -> $reg {\n        say \"\\nTop $top using regex: \", $reg.raku;\n\t    my @words = $file.comb($reg).Bag.sort(-*.value)[^$top];\n\t    my $length = max @words».key».chars;\n        printf \"%-{$length}s %d\\n\", .key, .value for @words;\n    }\n}\n\n```\n\nOutput:\n\nPassing in the file name and 10:\n\n```\nTop 10 using regex: rx/ <[a..z]>+ /\nthe\t41089\nof\t19949\nand\t14942\na\t14608\nto\t13951\nin\t11214\nhe\t9648\nwas\t8621\nthat\t7924\nit\t6661\n\nTop 10 using regex: rx/ \\w+ /\nthe\t41035\nof\t19946\nand\t14940\na\t14577\nto\t13939\nin\t11204\nhe\t9645\nwas\t8619\nthat\t7922\nit\t6659\n\nTop 10 using regex: rx/ <[\\w]-[_]>+ /\nthe\t41088\nof\t19949\nand\t14942\na\t14596\nto\t13951\nin\t11214\nhe\t9648\nwas\t8621\nthat\t7924\nit\t6661\n\nTop 10 using regex: rx/ <[\\w]-[_]>+[[\"'\"|'-'|\"'-\"]<[\\w]-[_]>+]* /\nthe\t41081\nof\t19930\nand\t14934\na\t14587\nto\t13735\nin\t11204\nhe\t9607\nwas\t8620\nthat\t7825\nit\t6535\n```\n\nIt can be difficult to figure out what words the different regexes do or don't match. Here are the three more complex regexes along with a list of \"words\" that are treated as being different using this regex as opposed to /a..z/. IE: It is lumped in as one of the top 10 word counts using /a..z/ but not with this regex.\n\n```\nTop 10 using regex: rx/ \\w+ /\nthe\t41035\talèthe _the _the_\nof\t19946\tof_ _of_\nand\t14940\t_and_ paternoster_and\na\t14577\t_ça aïe ça keksekça aérostiers _a poréa panathenæa\nto\t13939\tto_ _to\nin\t11204\t_in\nhe\t9645\t_he\nwas\t8619\t_was\nthat\t7922\t_that\nit\t6659\t_it\n\nTop 10 using regex: rx/ <[\\w]-[_]>+ /\nthe\t41088\talèthe\nof\t19949\t\nand\t14942\t\na\t14596\tporéa ça aérostiers panathenæa aïe keksekça\nto\t13951\t\nin\t11214\t\nhe\t9648\t\nwas\t8621\t\nthat\t7924\t\nit\t6661\t\n\nTop 10 using regex: rx/ <[\\w]-[_]>+[[\"'\"|'-'|\"'-\"]<[\\w]-[_]>+]* /\nthe\t41081\twill-o'-the-wisps alèthe skip-the-gutter police-agent-ja-vert-was-found-drowned-un-der-a-boat-of-the-pont-au-change jean-the-screw will-o'-the-wisp\nof\t19930\tchromate-of-lead-colored die-of-hunger die-of-cold-if-you-have-bread police-agent-ja-vert-was-found-drowned-un-der-a-boat-of-the-pont-au-change unheard-of die-of-hunger-if-you-have-a-fire\nand\t14934\tcome-and-see so-and-so cock-and-bull hide-and-seek sambre-and-meuse\na\t14587\tkeksekça l'a ça now-a-days vis-a-vis a-dreaming police-agent-ja-vert-was-found-drowned-un-der-a-boat-of-the-pont-au-change poréa panathenæa aérostiers a-hunting aïe die-of-hunger-if-you-have-a-fire\nto\t13735\tto-morrow to-day hand-to-hand to-night well-to-do face-to-face\nin\t11204\tin-pace son-in-law father-in-law whippers-in general-in-chief sons-in-law\nhe\t9607\the's he'll\nwas\t8620\tpolice-agent-ja-vert-was-found-drowned-un-der-a-boat-of-the-pont-au-change\nthat\t7825\tthat's pick-me-down-that\nit\t6535\tit's it'll\n```\n\nOne nice thing is this isn't special cased. It will work out of the box for any text / language.\n\nRussian? No problem.\n\n```\n$ raku wf 14741-0.txt 5\n```\n\n```\nTop 5 using regex: rx/ <[a..z]>+ /\nthe\t176\nof\t119\ngutenberg\t93\nproject\t87\nto\t80\n\nTop 5 using regex: rx/ \\w+ /\nи\t860\nв\t579\nне\t290\nна\t222\nты\t195\n\nTop 5 using regex: rx/ <[\\w]-[_]>+ /\nи\t860\nв\t579\nне\t290\nна\t222\nты\t195\n\nTop 5 using regex: rx/ <[\\w]-[_]>+[[\"'\"|'-'|\"'-\"]<[\\w]-[_]>+]* /\nи\t860\nв\t579\nне\t290\nна\t222\nты\t195\n```\n\nGreek? Sure, why not.\n\n```\n$ raku wf 39963-0.txt 5\n```\n\n```\nTop 5 using regex: rx/ <[a..z]>+ /\nthe\t187\nof\t123\ngutenberg\t93\nproject\t87\nto\t82\n\nTop 5 using regex: rx/ \\w+ /\nκαι\t1628\nεις\t986\nδε\t982\nτου\t895\nτων\t859\n\nTop 5 using regex: rx/ <[\\w]-[_]>+ /\nκαι\t1628\nεις\t986\nδε\t982\nτου\t895\nτων\t859\n\nTop 5 using regex: rx/ <[\\w]-[_]>+[[\"'\"|'-'|\"'-\"]<[\\w]-[_]>+]* /\nκαι\t1628\nεις\t986\nδε\t982\nτου\t895\nτων\t859\n```\n\nOf course, for the first matcher, we are asking specifically to match Latin ASCII, so we end up with... well... Latin ASCII; but the other 3 match any Unicode characters."}]}
{"messages": [{"role": "user", "content": "Yet another shortest path problem. Given two words of equal length the task is to transpose the first into the second.\n\nOnly one letter may be changed at a time and the change must result in a word in unixdict, the minimum number of intermediate words should be used.\n\nDemonstrate the following:\n\nA boy can be made into a man: boy -> bay -> ban -> man\n\nWith a little more difficulty a girl can be made into a lady: girl -> gill -> gall -> gale -> gaze -> laze -> lazy -> lady\n\nA john can be made into a jane: john -> cohn -> conn -> cone -> cane -> jane\n\nA child can not be turned into an adult.\n\nOptional transpositions of your choice.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nconstant %dict = 'unixdict.txt'.IO.lines\n                               .classify(*.chars)\n                               .map({ .key => .value.Set });\n\nsub word_ladder ( Str $from, Str $to ) {\n    die if $from.chars != $to.chars;\n\n    my $sized_dict = %dict{$from.chars};\n    \n    my @workqueue = (($from,),);\n    my $used = ($from => True).SetHash;\n    while @workqueue {\n        my @new_q;\n        for @workqueue -> @words {\n            my $last_word = @words.tail;\n            my @new_tails = gather for 'a' .. 'z' -> $replacement_letter {\n                for ^$last_word.chars -> $i {\n                    my $new_word = $last_word;\n                    $new_word.substr-rw($i, 1) = $replacement_letter;\n\n                    next unless $new_word ∈ $sized_dict\n                        and not $new_word ∈ $used;\n                    take $new_word;\n                    $used{$new_word} = True;\n                    \n                    return |@words, $new_word if $new_word eq $to;\n                }\n            }\n            push @new_q, ( |@words, $_ ) for @new_tails;\n        }\n        @workqueue = @new_q;\n    }\n}\nfor <boy man>, <girl lady>, <john jane>, <child adult> -> ($from, $to) {\n    say word_ladder($from, $to)\n        // \"$from into $to cannot be done\";\n}\n\n```\n\nOutput:\n\n```\n(boy bay may man)\n(girl gill gall gale gaze laze lazy lady)\n(john cohn conn cone cane jane)\nchild into adult cannot be done\n```"}]}
{"messages": [{"role": "user", "content": "A word search puzzle typically consists of a grid of letters in which words are hidden.\n\nThere are many varieties of word search puzzles. For the task at hand we will use a rectangular grid in which the words may be placed horizontally, vertically, or diagonally. The words may also be spelled backwards.\n\nThe words may overlap but are not allowed to zigzag, or wrap around.\n\nTask\n\nCreate a 10 by 10 word search and fill it using words from the unixdict. Use only words that are longer than 2, and contain no non-alphabetic characters.\n\nThe cells not used by the hidden words should contain the message: *Rosetta Code*, read from left to right, top to bottom. These letters should be somewhat evenly distributed over the grid, not clumped together. The message should be in upper case, the hidden words in lower case. All cells should either contain letters from the hidden words or from the message.\n\nPack a minimum of 25 words into the grid.\n\nPrint the resulting grid and the solutions.\n\nExample\n\n```\n     0  1  2  3  4  5  6  7  8  9\n\n0    n  a  y  r  y  R  e  l  m  f \n1    y  O  r  e  t  s  g  n  a  g \n2    t  n  e  d  i  S  k  y  h  E \n3    n  o  t  n  c  p  c  w  t  T \n4    a  l  s  u  u  n  T  m  a  x \n5    r  o  k  p  a  r  i  s  h  h \n6    a  A  c  f  p  a  e  a  c  C \n7    u  b  u  t  t  t  O  l  u  n \n8    g  y  h  w  a  D  h  p  m  u \n9    m  i  r  p  E  h  o  g  a  n \n\nparish     (3,5)(8,5)   gangster   (9,1)(2,1)\npaucity    (4,6)(4,0)   guaranty   (0,8)(0,1)\nprim       (3,9)(0,9)   huckster   (2,8)(2,1)\nplasm      (7,8)(7,4)   fancy      (3,6)(7,2)\nhogan      (5,9)(9,9)   nolo       (1,2)(1,5)\nunder      (3,4)(3,0)   chatham    (8,6)(8,0)\nate        (4,8)(6,6)   nun        (9,7)(9,9)\nbutt       (1,7)(4,7)   hawk       (9,5)(6,2)\nwhy        (3,8)(1,8)   ryan       (3,0)(0,0)\nfay        (9,0)(7,2)   much       (8,8)(8,5)\ntar        (5,7)(5,5)   elm        (6,0)(8,0)\nmax        (7,4)(9,4)   pup        (5,3)(3,5)\nmph        (8,8)(6,8)\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.01\n\n```\nmy $rows = 10;\nmy $cols = 10;\n\nmy $message = q:to/END/;\n    .....R....\n    ......O...\n    .......S..\n    ........E.\n    T........T\n    .A........\n    ..C.......\n    ...O......\n    ....D.....\n    .....E....\n    END\n\nmy %dir =\n    '→' => (1,0),\n    '↘' => (1,1),\n    '↓' => (0,1),\n    '↙' => (-1,1),\n    '←' => (-1,0),\n    '↖' => (-1,-1),\n    '↑' => (0,-1),\n    '↗' => (1,-1)\n;\n\nmy @ws = $message.comb(/<print>/);\n\nmy $path = './unixdict.txt'; # or wherever\n\nmy @words = $path.IO.slurp.words.grep( { $_ !~~ /<-[a..z]>/ and 2 < .chars < 11 } ).pick(*);\nmy %index;\nmy %used;\n\nwhile @ws.first( * eq '.') {\n\n    # find an unfilled cell\n    my $i = @ws.grep( * eq '.', :k ).pick;\n\n    # translate the index to x / y coordinates\n    my ($x, $y) = $i % $cols, floor($i / $rows);\n\n    # find a word that fits\n    my $word = find($x, $y);\n\n    # Meh, reached an impasse, easier to just throw it all\n    # away and start over rather than trying to backtrack.\n    restart, next unless $word;\n\n    %used{\"$word\"}++;\n\n    # Keeps trying to place an already used word, choices\n    # must be limited, start over\n    restart, next if %used{$word} > 15;\n\n    # Already used this word, try again\n    next if %index{$word.key};\n\n    # Add word to used word index\n    %index ,= $word;\n\n    # place the word into the grid\n    place($x, $y, $word);\n\n}\n\ndisplay();\n\nsub display {\n    put flat \"    \", 'ABCDEFGHIJ'.comb;\n    .put for (^10).map: { ($_).fmt(\"  %2d\"), @ws[$_ * $cols .. ($_ + 1) * $cols - 1] }\n    put \"\\n  Words used:\";\n    my $max = 1 + %index.keys.max( *.chars ).chars;\n    for %index.sort {\n        printf \"%{$max}s %4s %s  \", .key, .value.key, .value.value;\n        print \"\\n\" if $++ % 2;\n    }\n    say \"\\n\"\n}\n\nsub restart {\n    @ws = $message.comb(/<print>/);\n    %index = ();\n    %used = ();\n}\n\nsub place ($x is copy, $y is copy, $w) {\n    my @word = $w.key.comb;\n    my $dir  = %dir{$w.value.value};\n    @ws[$y * $rows + $x] = @word.shift;\n    while @word {\n        ($x, $y) »+=« $dir;\n        @ws[$y * $rows + $x] = @word.shift;\n    }\n }\n\nsub find ($x, $y) {\n    my @trials = %dir.keys.map: -> $dir {\n            my $space = '.';\n            my ($c, $r) = $x, $y;\n            loop {\n                ($c, $r) »+=« %dir{$dir};\n                last if 9 < $r|$c;\n                last if 0 > $r|$c;\n                my $l = @ws[$r * $rows + $c];\n                last if $l ~~ /<:Lu>/;\n                $space ~= $l;\n            }\n            next if $space.chars < 3;\n            [$space.trans( '.' => ' ' ),\n            (\"{'ABCDEFGHIJ'.comb[$x]} {$y}\" => $dir)]\n        };\n\n    for @words.pick(*) -> $word {\n        for @trials -> $space {\n            next if $word.chars > $space[0].chars;\n            return ($word => $space[1]) if compare($space[0].comb, $word.comb)\n        }\n    }\n}\n\nsub compare (@s, @w) {\n    for ^@w {\n        next if @s[$_] eq ' ';\n        return False if @s[$_] ne @w[$_]\n    }\n    True\n}\n\n```\n\nSample output:\n\n```\n     A B C D E F G H I J\n   0 b y e e a R s w u k\n   1 r g e n p f O s e s\n   2 d i n l e i i S t i\n   3 r e b i l a c e E f\n   4 T g t a d a g n l T\n   5 d A a t d o w a i d\n   6 g i C n a n a l r c\n   7 a o g O p a l p r f\n   8 p g n p D d a i o a\n   9 c r u s h E s p t d\n\n  Words used:\n     aaa  G 8 ↖    afield  E 0 ↘  \n   alley  F 4 ↖       bye  A 0 →  \n caliber  G 3 ←     crush  A 9 →  \n     dan  F 8 ↑       dig  A 5 ↘  \n    epic  D 0 ↘       fad  J 7 ↓  \n    fisk  J 3 ↑       gap  A 6 ↓  \n   geigy  B 4 ↑       get  G 4 ↗  \n     gnp  B 8 →       goa  C 7 ←  \n    lane  H 6 ↑       law  G 7 ↑  \n     nag  D 6 ↖       nne  D 1 ↙  \n    odin  F 5 ↖       orr  I 8 ↑  \n  paddle  E 7 ↑    picnic  E 1 ↘  \n     pip  H 9 ↑       rib  A 1 ↘  \n     sir  G 9 ↗       sst  G 0 ↘  \n    tail  D 5 ↑       ted  C 4 ↖  \n     tor  I 9 ↑      usia  I 0 ↙  \n     wei  H 0 ↘  \n```"}]}
{"messages": [{"role": "user", "content": "A \"word wheel\" is a type of word game commonly found on the \"puzzle\" page of\nnewspapers. You are presented with nine letters arranged in a circle or 3×3\ngrid. The objective is to find as many words as you can using only the letters\ncontained in the wheel or grid. Each word must contain the letter in the centre\nof the wheel or grid. Usually there will be a minimum word length of 3 or 4\ncharacters. Each letter may only be used as many times as it appears in the wheel\nor grid.\n\nAn example\n\n**:   :   :   :   :   :   :   |  |  |  |\n                            | --- | --- | --- |\n                            | N | D | E |\n                            | O | K | G |\n                            | E | L | W |**\n\nTask\n\nWrite a program to solve the above \"word wheel\" puzzle.\n\nSpecifically:\n\n:   * Find all words of 3 or more letters using only the letters in the string   **ndeokgelw**.\n    * All words must contain the central letter   **K**.\n    * Each letter may be used only as many times as it appears in the string.\n    * For this task we'll use lowercase English letters exclusively.\n\nA \"word\" is defined to be any string contained in the file located at   http://wiki.puzzlers.org/pub/wordlists/unixdict.txt.\n  \nIf you prefer to use a different dictionary,   please state which one you have used.\n\nOptional extra\n\nWord wheel puzzles usually state that there is at least one nine-letter word to be found.\nUsing the above dictionary, find the 3x3 grids with at least one nine-letter\nsolution that generate the largest number of words of three or more letters.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.05\n\nEverything is adjustable through command line parameters.\n\nDefaults to task specified wheel, unixdict.txt, minimum 3 letters.\n\nUsing Terminal::Boxer from the Raku ecosystem.\n\n```\nuse Terminal::Boxer;\n\nmy %*SUB-MAIN-OPTS = :named-anywhere;\n\nunit sub MAIN ($wheel = 'ndeokgelw', :$dict = './unixdict.txt', :$min = 3);\n\nmy $must-have = $wheel.comb[4].lc;\n\nmy $has = $wheel.comb».lc.Bag;\n\nmy %words;\n$dict.IO.slurp.words».lc.map: {\n    next if not .contains($must-have) or .chars < $min;\n    %words{.chars}.push: $_ if .comb.Bag ⊆ $has;\n};\n\nsay \"Using $dict, minimum $min letters.\";\n\nprint rs-box :3col, :3cw, :indent(\"\\t\"), $wheel.comb».uc;\n\nsay \"{sum %words.values».elems} words found\";\n\nprintf \"%d letters:  %s\\n\", .key, .value.sort.join(', ') for %words.sort;\n\n```\n\nOutput:\n\nUsing defaults\n\n```\nraku word-wheel.raku\n\n```\n\n```\nUsing ./unixdict.txt, minimum 3 letters.\n\t╭───┬───┬───╮\n\t│ N │ D │ E │\n\t├───┼───┼───┤\n\t│ O │ K │ G │\n\t├───┼───┼───┤\n\t│ E │ L │ W │\n\t╰───┴───┴───╯\n17 words found\n3 letters:  eke, elk, keg, ken, wok\n4 letters:  keel, keen, keno, knee, knew, know, kong, leek, week, woke\n5 letters:  kneel\n9 letters:  knowledge\n```\n\nLarger dictionary\n\nUsing the much larger dictionary **words.txt** file from **https://github.com/dwyl/english-words**\n\n```\nraku word-wheel.raku --dict=./words.txt\n\n```\n\n```\nUsing ./words.txt, minimum 3 letters.\n\t╭───┬───┬───╮\n\t│ N │ D │ E │\n\t├───┼───┼───┤\n\t│ O │ K │ G │\n\t├───┼───┼───┤\n\t│ E │ L │ W │\n\t╰───┴───┴───╯\n86 words found\n3 letters:  dkg, dkl, eek, egk, eke, ekg, elk, gok, ked, kee, keg, kel, ken, keo, kew, kln, koe, kol, kon, lek, lgk, nek, ngk, oke, owk, wok\n4 letters:  deek, deke, doek, doke, donk, eked, elke, elko, geek, genk, gonk, gowk, keel, keen, keld, kele, kend, keno, keon, klee, knee, knew, know, koel, koln, kone, kong, kwon, leek, leke, loke, lonk, okee, oken, week, welk, woke, wolk, wonk\n5 letters:  dekle, dekow, gleek, kedge, kendo, kleon, klong, kneed, kneel, knowe, konde, oklee, olnek, woken\n6 letters:  gowked, keldon, kelwen, knowle, koleen\n8 letters:  weeklong\n9 letters:  knowledge\n```\n\nTop 5 maximum word wheels with at least one 9 letter word\n\nUsing unixdict.txt:\n\n```\nWheel\t\twords\neimnaprst:\t215\ncelmanort:\t215\nceimanrst:\t210\nelmnaoprt:\t208\nahlneorst:\t201\n```\n\nUsing words.txt:\n\n```\nWheel\t\twords\nmeilanrst:\t1329\ndeilanrst:\t1313\nceilanrst:\t1301\npeilanrst:\t1285\ngeilanrst:\t1284\n```"}]}
{"messages": [{"role": "user", "content": "Even today, with proportional fonts and complex layouts, there are still cases where you need to wrap text at a specified column.\n\nBasic task\n\nThe basic task is to wrap a paragraph of text in a simple way in your language.\n\nIf there is a way to do this that is built-in, trivial, or provided in a standard library, show that. Otherwise implement the minimum length greedy algorithm from Wikipedia.\n\nShow your routine working on a sample of text at two different wrap columns.\n\nExtra credit\n\nWrap text using a more sophisticated algorithm such as the Knuth and Plass TeX algorithm.\nIf your language provides this, you get easy extra credit,\nbut you *must reference documentation* indicating that the algorithm\nis something better than a simple minimum length algorithm.\n\nIf you have both basic and extra credit solutions, show an example where\nthe two algorithms give different results.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nmy $s = \"In olden times when wishing still helped one, there lived a king\nwhose daughters were all beautiful, but the youngest was so beautiful\nthat the sun itself, which has seen so much, was astonished whenever\nit shone in her face.  Close-by-the-king's-castle-lay-a-great-dark\nforest, and under an old lime-tree in the forest was a well, and when\nthe day was very warm, the king's child went out into the forest and\nsat down by the side of the cool fountain, and when she was bored she\ntook a golden ball, and threw it up on high and caught it, and this\nball was her favorite plaything.\";\n\n$s ~~ s:g/»\\s+/ /;\n$s ~~ s/\\s*$/\\n\\n/;\n\nsay $s.subst(/ \\s* (. ** 1..66) \\s /, -> $/ { \"$0\\n\" }, :g);\nsay $s.subst(/ \\s* (. ** 1..25) \\s /, -> $/ { \"$0\\n\" }, :g);\n\n```"}]}
{"messages": [{"role": "user", "content": "Wordiff is an original game in which contestants take turns spelling new dictionary words of three or more characters that only differ from\nthe last by a change in one letter.\n\nThe change can be either:\n\n1. a deletion of one letter;\n2. addition of one letter;\n3. or change in one letter.\n\nNote:\n\n* All words must be in the dictionary.\n* No word in a game can be repeated.\n* The first word must be three or four letters long.\n\nTask\n\nCreate a program to aid in the playing of the game by:\n\n* Asking for contestants names.\n* Choosing an initial random three or four letter word from the dictionary.\n* Asking each contestant in their turn for a wordiff word.\n* Checking the wordiff word is:\n\n:   * in the dictionary,\n    * not a repetition of past words,\n    * and differs from the last appropriately.\n\nOptional stretch goals\n\n* Add timing.\n* Allow players to set a maximum playing time for the game.\n* An internal timer accumulates how long each user takes to respond in their turns.\n* Play is halted if the maximum playing time is exceeded on a players input.\n\n:   * That last player must have entered a wordiff or loses.\n    * If the game is timed-out, the loser is the person who took the longest `average` time to answer in their rounds.\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nmy @words = 'unixdict.txt'.IO.slurp.lc.words.grep(*.chars > 2);\n\nmy @small = @words.grep(*.chars < 6);\n\nuse Text::Levenshtein;\n\nmy ($rounds, $word, $guess, @used, @possibles) = 0;\n\nloop {\n    my $lev;\n    $word = @small.pick;\n    hyper for @words  -> $this {\n        next if ($word.chars - $this.chars).abs > 1;\n        last if ($lev = distance($word, $this)[0]) == 1;\n    }\n    last if $lev;\n}\n\nmy $name = ',';\n\n#[[### Entirely unnecessary and unuseful \"chatty repartee\" but is required by the task\n\nrun 'clear';\n$name = prompt \"Hello player one, what is your name? \";\nsay \"Cool. I'm going to call you Gomer.\";\n$name = ' Gomer,';\nsleep 1;\nsay \"\\nPlayer two, what is your name?\\nOh wait, this isn't a \\\"specified number of players\\\" game...\";\nsleep 1;\nsay \"Nevermind.\\n\";\n\n################################################################################]]\n\nloop {\n    say \"Word in play: $word\";\n    push @used, $word;\n    @possibles = @words.hyper.map: -> $this {\n        next if ($word.chars - $this.chars).abs > 1;\n        $this if distance($word, $this)[0] == 1 and $this ∉ @used;\n    }\n    $guess = prompt \"your word? \";\n    last unless $guess ∈ @possibles;\n    ++$rounds;\n    say qww<Ok! Woot! 'Way to go!' Nice! 👍 😀>.pick ~ \"\\n\";\n    $word = $guess;\n}\n\nmy $already = ($guess ∈ @used) ?? \" $guess was already played but\" !! '';\n\nif @possibles {\n    say \"\\nOops. Sorry{$name}{$already} one of [{@possibles}] would have continued the game.\"\n} else {\n    say \"\\nGood job{$name}{$already} there were no possible words to play.\"\n}\nsay \"You made it through $rounds rounds.\";\n\n```\n\nSample output:\n\n```\nHello player one, what is your name? Burtram Redneck\nCool. I'm going to call you Gomer.\n\nPlayer two, what is your name?\nOh wait, this isn't a \"specified number of players\" game...\nNevermind.\n\nWord in play: howe\nyour word? how\nWoot!\n\nWord in play: how\nyour word? show\n👍\n\nWord in play: show\nyour word? shot\nNice!\n\nWord in play: shot\nyour word? hot\n😀\n\nWord in play: hot\nyour word? hit\nWay to go!\n\nWord in play: hit\nyour word? mit\nNice!\n\nWord in play: mit\nyour word? kit\n😀\n\nWord in play: kit\nyour word? nit\nWoot!\n\nWord in play: nit\nyour word? nip\n😀\n\nWord in play: nip\nyour word? snip\nOk!\n\nWord in play: snip\nyour word? slip\nOk!\n\nWord in play: slip\nyour word? slap\nWay to go!\n\nWord in play: slap\nyour word? lap\nWoot!\n\nWord in play: lap\nyour word? nap\nWoot!\n\nWord in play: nap\nyour word? nan\nNice!\n\nWord in play: nan\nyour word? man\nNice!\n\nWord in play: man\nyour word? men\nWoot!\n\nWord in play: men\nyour word? ben\nNice!\n\nWord in play: ben\nyour word? ban\n👍\n\nWord in play: ban\nyour word? man\n\nOops. Sorry Gomer, man was already played but one of [bad bag bah bam band bane bang bank bar barn bat bay bean bin bon bran bun can dan fan han ian jan pan ran san tan van wan zan] would have continued the game.\nYou made it through 19 rounds.\n```"}]}
{"messages": [{"role": "user", "content": "Rationale\n\nWhile similar to both Bulls and cows and Mastermind, Wordle is a notable variation, having experienced a viral surge in popularity, and reverse engineering the game or creating variants has become a popular programming exercise. However, a sampling of the \"code a Wordle clone\" videos on YouTube shows that seven of the eight reviewed had a serious flaw in the way that they assigned colours to the letters of a guessed word. This aspect of the game is described here: en.wikipedia.org/wiki/Wordle#Gameplay\n\n> After every guess, each letter is marked as either green, yellow or gray: green indicates that letter is correct and in the correct position, yellow means it is in the answer but not in the right position, while gray indicates it is not in the answer at all. Multiple instances of the same letter in a guess, such as the \"o\"s in \"robot\", will be colored green or yellow only if the letter also appears multiple times in the answer; otherwise, excess repeating letters will be colored gray.\n\nTask\n\nCreate a function or procedure that takes two strings; the answer string, and the guess string, and returns a string, list, dynamic array or other ordered sequence indicating how each letter should be marked as per the description above. (e.g. \"green\", \"yellow\", or \"grey\", or, equivalently, the integers 2, 1, or 0 or suchlike.)\n\nYou can assume that both the answer string and the guess string are the same length, and contain only printable characters/code points in the ASCII/UniCode Range ! to ~ (hex 20 to 7F) and that case is significant. (The original game only uses strings of 5 characters, all alphabetic letters, all in the same case, but this allows for most existing variants of the game.)\n\nProvide test data and show the output here.\n\nThe test data should include the answer string `ALLOW` and the guess string `LOLLY`, and the result should be `(yellow, yellow, green, grey, grey)` or equivalent."}, {"role": "assistant", "content": "Updated to add a proof of concept matching for similarity where commonly found on spoofing domain names. Of course this is just the tip of the iceberg (only comparing results after decomposition) and there are way too many Unicode homoglyphs that can only be matched using a lookup table/database.\n\n```\n# 20220216 Raku programming solution\n\nsub wordle (\\answer,\\guess where [==] (answer,guess)».chars ) {\n\n   my ($aSet, $gSet, @return) = (answer,guess)».&{ (set .comb.pairs).SetHash }\n\n   (my \\intersection = $aSet ∩ $gSet).keys».&{ @return[.key] = 'green' }\n   ($aSet,$gSet)».&{ $_ ∖= intersection } # purge common subset\n\n   for $gSet.keys.sort -> \\trial { # pair \n      @return[trial.key] = 'grey';\n      for $aSet.keys -> \\actual { # pair\n         if [eq] (trial,actual)».value {\n            @return[trial.key] = 'yellow'; \n            $aSet{actual}:delete;\n            last\n         } \n         my @NFD = (trial,actual).map: { .value.NFD }\n         if [ne] @NFD and [==] @NFD».first {\n            @return[trial.key] = 'azure';\n            $aSet{actual}:delete;\n            last\n         }\n      }\n   }\n   @return\n}\n\nsay .[0]~' vs '~.[1]~\"\\t\"~ wordle .[0],.[1] for (\n<ALLOW LOLLY>, <ROBIN ALERT>, <ROBIN SONIC>, <ROBIN ROBIN>, <BULLY LOLLY>,\n<ADAPT SÅLÅD>, <Ukraine Ukraíne>, <BBAABBB BBBBBAA>, <BBAABBB AABBBAA> );\n\n```\n\nOutput:\n\n```\nALLOW vs LOLLY  yellow yellow green grey grey\nROBIN vs ALERT  grey grey grey yellow grey\nROBIN vs SONIC  grey green yellow green grey\nROBIN vs ROBIN  green green green green green\nBULLY vs LOLLY  grey grey green green green\nADAPT vs SÅLÅD\tgrey azure grey azure yellow\nUkraine vs Ukraíne\tgreen green green green azure green green\nBBAABBB vs BBBBBAA      green green yellow yellow green yellow yellow\nBBAABBB vs AABBBAA      yellow yellow yellow yellow green grey grey\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nUsing the dictionary   unixdict.txt,   search words containing \"the\" substring,\n  \nthen display the found words (on this page).\n\nThe length of any word shown should have a length   **>  11****.**\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "A trivial modification of the ABC words task.\n\n```\nput 'unixdict.txt'.IO.words».fc.grep({ (.chars > 11) && (.contains: 'the') })\\\n    .&{\"{+$_} words:\\n  \" ~ .batch(8)».fmt('%-17s').join: \"\\n  \"};\n\n```\n\nOutput:\n\n```\n32 words:\n  authenticate      chemotherapy      chrysanthemum     clothesbrush      clotheshorse      eratosthenes      featherbedding    featherbrain     \n  featherweight     gaithersburg      hydrothermal      lighthearted      mathematician     neurasthenic      nevertheless      northeastern     \n  northernmost      otherworldly      parasympathetic   physiotherapist   physiotherapy     psychotherapeutic psychotherapist   psychotherapy    \n  radiotherapy      southeastern      southernmost      theoretician      weatherbeaten     weatherproof      weatherstrip      weatherstripping \n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nUse the dictionary   unixdict.txt\n\nIgnore any word in the dictionary whose length is less than 9.\n\nLet's take the words from next characters:\n  \n1 <= n < (dictionary length) - 9.\n  \nchar1 = 1st character of         nth   word.\n  \nchar2 = 2nd character of  (n+1)th  word.\n  \nchar3 = 3rd character of  (n+2)th  word.\n  \n      ⋮ \n  \nchar9 = 9th character of  (n+8)th  word.\n\nConcatenate (append) the nine characters by:\n\n```\n      newword = char1 + char2 + char3 + ... + char9 \n\n```\n\nIf   *newword*   is in the dictionary, then show on this page.\n\nLength of  *newword* = 9\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "```\nmy @words_ge_9 = 'unixdict.txt'.IO.lines.grep( *.chars >= 9 );\nmy %words_eq_9  = @words_ge_9           .grep( *.chars == 9 ).Set;\n\nmy @new_words = gather for @words_ge_9.rotor( 9 => -8 ) -> @nine_words {\n    my $new_word = [~] map { @nine_words[$_].substr($_, 1) }, ^9;\n\n    take $new_word if %words_eq_9{$new_word};\n}\n\n.say for unique @new_words;\n\n```\n\nOutput:\n\n```\napplicate\narchitect\nastronomy\nchristine\nchristoph\ncommittee\ncomposite\nconstrict\nconstruct\ndifferent\nextensive\ngreenwood\nimplement\nimprovise\nintercept\ninterpret\ninterrupt\nphilosoph\nprescript\nreceptive\ntelephone\ntranscend\ntransport\ntranspose\n\n```"}]}
{"messages": [{"role": "user", "content": "It's World Cup season (or at least it was when this page was created)!\n\nThe World Cup is an international football/soccer tournament that happens every 4 years.   Countries put their international teams together in the years between tournaments and qualify for the tournament based on their performance in other international games.   Once a team has qualified they are put into a group with 3 other teams.\n\nFor the first part of the World Cup tournament the teams play in \"group stage\" games where each of the four teams in a group plays all three other teams once.   The results of these games determine which teams will move on to the \"knockout stage\" which is a standard single-elimination tournament.   The two teams from each group with the most standings points move on to the knockout stage.\n\nEach game can result in a win for one team and a loss for the other team or it can result in a draw/tie for each team.\n\n:   :   :   * A win is worth three points.\n            * A draw/tie is worth one point.\n            * A loss is worth zero points.\n\nTask\n:   * Generate all possible outcome combinations for the six group stage games.   With three possible outcomes for each game there should be 36 = 729 of them.\n    * Calculate the standings points for each team with each combination of outcomes.\n    * Show a histogram (graphical,   ASCII art, or straight counts--whichever is easiest/most fun) of the standings points for all four teams over all possible outcomes.\n\nDon't worry about tiebreakers as they can get complicated.   We are basically looking to answer the question \"if a team gets x standings points, where can they expect to end up in the group standings?\".\n\n*Hint: there should be no possible way to end up in second place with less than two points as well as no way to end up in first with less than three.   Oddly enough, there is no way to get 8 points at all.*"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2016.12\n\n**Translation of**: Python\n\n```\nconstant scoring = 0, 1, 3;\nmy @histo = [0 xx 10] xx 4;\n\nfor [X] ^3 xx 6 -> @results {\n    my @s;\n\n    for @results Z (^4).combinations(2) -> ($r, @g) {\n        @s[@g[0]] += scoring[$r];\n        @s[@g[1]] += scoring[2 - $r];\n    }\n\n    for @histo Z @s.sort -> (@h, $v) {\n        ++@h[$v];\n    }\n}\n\nsay .fmt('%3d',' ') for @histo.reverse;\n\n```\n\nOutput:\n\n```\n  0   0   0   1  14 148 152 306   0 108\n  0   0   4  33 338 172 164  18   0   0\n  0  18 136 273 290   4   8   0   0   0\n108 306 184 125   6   0   0   0   0   0\n```"}]}
{"messages": [{"role": "user", "content": "Recreate https://xkcd.com/1205/ which shows a (humorous) table of how long you can work on making a\nroutine task more efficient before spending more time than saved, for various s(h)avings against how\noften the task is run (over the course of five years).\n\nThere are of course several possible interpretations of \"day\" and \"week\" in this context. The Phix\nimplementation assumes 8 hour days and 5 day weeks might be more realistic, whereas it seems the\noriginal author worked with 24 hour days and 7 day weeks, and, tbh, my interest is piqued to see\nwhat built-in facilities other languages might have for handling such non-standard terms, if any.\nExtra kudos awarded for getting into the mind of the original author and reproducing their results\nexactly (see talk page), or drumming up non-trivial (but still elegant) and potentially actually useful routines.\nThis task can be made as trivial or as convoluted as you please, and should aim more for a little\nplayfulness than rigid scientific accuracy."}, {"role": "assistant", "content": "**Translation of**: Wren\n\n```\n# 20220207 Raku programming solution \n\nmy \\shaved  = [1, 5, 30, 60, 300, 1800, 3600, 21600, 86400]; # time shaved off in seconds\nmy \\columns = [ \"1 SECOND\", \"5 SECONDS\", \"30 SECONDS\", \"1 MINUTE\", \"5 MINUTES\",\n                \"30 MINUTES\", \"1 HOUR\", \"6 HOURS\", \"1 DAY\" ];\nmy \\diy     = 365.25;\nmy \\minute  = 60;\nmy \\hour    = minute * 60;\nmy \\day     = hour * 24;\nmy \\week    = day * 7;\nmy \\month   = day * diy / 12;\nmy \\year    = day * diy;\nmy \\freq    = [50 * diy, 5 * diy, diy, diy/7, 12, 1]; # frequency per year\nmy \\mult    = 5; # multiplier for table\n\nsub fmtTime (\\t, \\interval) { printf \"%-12s \", t.floor~\" \"~interval~(t == 1 ?? \"\" !! \"S\") }\n\nsay ' ' x 34~\"HOW OFTEN YOU DO THE TASK\";\nprintf(\"%-12s | %-12s %-12s %-12s %-12s %-12s %-12s\\n\", \n   [\"SHAVED OFF\", \"50/DAY\", \"5/DAY\", \"DAILY\", \"WEEKLY\", \"MONTHLY\", \"YEARLY\"]);\nsay '-' x 93;\n\nfor ^9 -> \\y {\n   printf \"%-12s | \", columns[y];\n   for ^6 -> \\x {\n      given my \\t = freq[x] * shaved[y] * mult {\n         when t < minute  { fmtTime t,        \"SECOND\" } \n         when t < hour    { fmtTime t/minute, \"MINUTE\" } \n         when t < day     { fmtTime t/hour,   \"HOUR\"   } \n         when t < 14*day  { fmtTime t/day,    \"DAY\"    } \n         when t < 9*week  { fmtTime t/week,   \"WEEK\"   }\n         when t < year    { fmtTime t/month,  \"MONTH\"  }\n         default          { print   '   N/A       '    }\n      }\n   }\n   print \"\\n\"\n}\n\n```\n\nOutput:\n\n```\n                                  HOW OFTEN YOU DO THE TASK\nSHAVED OFF   | 50/DAY       5/DAY        DAILY        WEEKLY       MONTHLY      YEARLY\n---------------------------------------------------------------------------------------------\n1 SECOND     | 1 DAYS       2 HOURS      30 MINUTES   4 MINUTES    1 MINUTE     5 SECONDS\n5 SECONDS    | 5 DAYS       12 HOURS     2 HOURS      21 MINUTES   5 MINUTES    25 SECONDS\n30 SECONDS   | 4 WEEKS      3 DAYS       15 HOURS     2 HOURS      30 MINUTES   2 MINUTES\n1 MINUTE     | 2 MONTHS     6 DAYS       1 DAYS       4 HOURS      1 HOUR       5 MINUTES\n5 MINUTES    | 10 MONTHS    4 WEEKS      6 DAYS       21 HOURS     5 HOURS      25 MINUTES\n30 MINUTES   |    N/A       6 MONTHS     5 WEEKS      5 DAYS       1 DAYS       2 HOURS\n1 HOUR       |    N/A          N/A       2 MONTHS     10 DAYS      2 DAYS       5 HOURS\n6 HOURS      |    N/A          N/A          N/A       2 MONTHS     2 WEEKS      1 DAYS\n1 DAY        |    N/A          N/A          N/A       8 MONTHS     8 WEEKS      5 DAYS\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\n(Over)write a file so that it contains a string.\n\nThe reverse of Read entire file—for when you want to update or create a file which you would read in its entirety all at once."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nspurt 'path/to/file', $file-data;\n\n```\n\nor\n\n```\n'path/to/file'.IO.spurt: $file-data;\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite two equal-sized numerical arrays 'x' and 'y' to\na two-column text file named 'filename'.\n\nThe first column of the file contains values from an 'x'-array with a\ngiven 'xprecision', the second -- values from 'y'-array with 'yprecision'.\n\nFor example, considering:\n\n```\n   x = {1, 2, 3, 1e11};\n   y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}; \n                                                          /* sqrt(x) */\n   xprecision = 3;\n   yprecision = 5;\n\n```\n\nThe file should look like:\n\n```\n   1    1\n   2    1.4142\n   3    1.7321\n   1e+011   3.1623e+005\n\n```\n\nThis task is intended as a subtask for Measure relative performance of sorting algorithms implementations."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n### Perl 5-ish\n\nWritten in the style of the 2nd Perl 5 example.\n\n```\nsub writefloat ( $filename, @x, @y, $x_precision = 3, $y_precision = 5 ) {\n    my $fh = open $filename, :w;\n    for flat @x Z @y -> $x, $y {\n        $fh.printf: \"%.*g\\t%.*g\\n\", $x_precision, $x, $y_precision, $y;\n    }\n    $fh.close;\n}\n \nmy @x = 1, 2, 3, 1e11;\nmy @y = @x.map({.sqrt});\n\nwritefloat( 'sqrt.dat', @x, @y );\n\n```\n\nOutput:\n\n```\n1\t1\n2\t1.4142\n3\t1.7321\n1e+11\t3.1623e+05\n```\n\n### Idiomatic\n\nWritten in a more idiomatic style.\n\n```\nsub writefloat($filename, @x, @y, :$x-precision = 3, :$y-precision = 3) {\n    open($filename, :w).print:\n        join '', flat (@x».fmt(\"%.{$x-precision}g\") X \"\\t\") Z (@y».fmt(\"%.{$y-precision}g\") X \"\\n\");\n}\nmy @x = 1, 2, 3, 1e11;\nwritefloat('sqrt.dat', @x, @x».sqrt, :y-precision(5));\n\n```\n\nOutput:\n\n```\n1\t1\n2\t1.4142\n3\t1.7321\n1e+11\t3.1623e+05\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite/display a language's name in **3D** ASCII.\n\n(We can leave the definition of \"3D ASCII\" fuzzy,\nso long as the result is interesting or amusing,\nnot a cheap hack to satisfy the task.)\n\nRelated tasks\n\n* draw a sphere\n* draw a cuboid\n* draw a rotating cube\n* draw a Deathstar"}, {"role": "assistant", "content": "(formerly Perl 6)\nProduces a good old-fashioned stereogram, meant to be looked at by focusing beyond the screen, not by crossing your eyes. If you can't get it to converge, try shrinking the font size till the images are closer together than your eyes. Also helps to be old enough to have progressive lenses, so you can look through the reading part of your glasses. Or borrow glasses from someone who's farsighted. :-)\n\n```\n# must be evenly padded with white-space$\nmy $text = q:to/END/;\n                                 \n @@@@@              @@           \n @    @              @     @@@   \n @    @              @    @@     \n @    @  @@@   @ @@  @    @@     \n @@@@@  @   @  @@  @ @    @@@@@  \n @      @@@@@  @     @    @@  @@ \n @      @      @     @    @@  @@ \n @       @@@   @     @@    @@@@  \n                                 \nEND\n\nsay '' for ^5;\nfor $text.lines -> $_ is copy {\n    my @chars = |｢-+ ., ;: '\"｣.comb.pick(*) xx *;\n    s:g [' '] = @chars.shift;\n    print \"                              $_  \";\n    s:g [('@'+)(.)] = @chars.shift ~ $0;\n    .say;\n}\nsay '' for ^5;\n\n```\n\nOutput:\n\n```\n\n                              \";,' :-+  . ,. ; -:+\"',';-. : \" +   \";,' :-+  . ,. ; -:+\"',';-. : \" + \n                              :@@@@@  ,'+\".-; ;-+,@@\"'  :.  ;. \"  :'@@@@@ ,'+\".-; ;-+,,@@'  :.  ;. \"\n                              \"@-.  @ ';,+:- +:  ,;@'\". +@@@, \"-  \" @.  .@';,+:- +:  ,;:@\". +;@@@ \"-\n                              '@,- ;@ \"+: .+ -',:\" @; . @@; -\" ,  ':@- ;'@\"+: .+ -',:\" .@ . +@@ -\" ,\n                              ;@ +, @\"-@@@' :@.@@  @-,:.@@+ ;'\":  ; @+, .@-'@@@ : @;@@  @,:.+@@ ;'\":\n                               @@@@@+-@':.@, @@\" @;@ +\":@@@@@',    ;@@@@@--@:. @ .@@ :@ @+\": @@@@@, \n                               @;-+, .@@@@@ :@\"'+' @\"-,:@@; @@.    +@-+, .,@@@@@::@'+'  @-,: @@ \"@@ \n                              :@ . \"- @,;+'; @\" .-'@ +:,@@ ;@@'+  :-@. \"- ,@;+'; \"@ .-' @+:, @@;:@@+\n                              +@'\"., ; @@@ -:@;'  \"@@-+.:@@@@,    +:@\"., ; \"@@@-:;@'  \".@@+.: @@@@  \n                               ;.:+\"-,'  +:'; -,\"  .+:\"  ;-.,' .   ;.:+\"-,'  +:'; -,\"  .+:\"  ;-.,' .\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nWrite script status to the Windows Event Log"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.01\n\nThere is not yet (that I am aware of) a native interface to the Windows logging functions, but Raku can shell out and run a console command just as easily as most of these other languages. It *does* have a native interface to the syslog functions under POSIX environments though.\n\n(Same caveats as the others, needs to be run as administrator or with elevated privileges under Windows.)\n\n```\ngiven $*DISTRO {\n    when .is-win {\n        my $cmd = \"eventcreate /T INFORMATION /ID 123 /D \\\"Bla de bla bla bla\\\"\";\n        run($cmd);\n    }\n    default { # most POSIX environments\n        use Log::Syslog::Native;\n        my $logger = Log::Syslog::Native.new(facility => Log::Syslog::Native::User);\n        $logger.info(\"[$*PROGRAM-NAME pid=$*PID user=$*USER] Just thought you might like to know.\");\n    }\n}\n\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nImplement the   Xiaolin Wu's line algorithm   described in Wikipedia.\n\nThis algorithm draws anti-aliased lines.\n\nRelated task\n\n* See   Bresenham's line algorithm   for *aliased* lines."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub plot(\\x, \\y, \\c) { say \"plot {x} {y} {c}\" }\n \nsub fpart(\\x) { x - floor(x) }\n \nsub draw-line(@a is copy, @b is copy) {\n    my Bool \\steep = abs(@b[1] - @a[1]) > abs(@b[0] - @a[0]);\n    my $plot = &OUTER::plot;\n \n    if steep {\n\t$plot = -> $y, $x, $c { plot($x, $y, $c) }\n\t@a.=reverse;\n\t@b.=reverse;\n    }\n    if @a[0] > @b[0] { my @t = @a; @a = @b; @b = @t }\n\n    my (\\x0,\\y0) = @a;\n    my (\\x1,\\y1) = @b;\n \n    my \\dx = x1 - x0;\n    my \\dy = y1 - y0;\n    my \\gradient = dy / dx;\n \n    # handle first endpoint\n    my \\x-end1 = round(x0);\n    my \\y-end1 = y0 + gradient * (x-end1 - x0);\n    my \\x-gap1 = 1 - round(x0 + 0.5);\n\n    my \\x-pxl1 = x-end1;   # this will be used in the main loop\n    my \\y-pxl1 = floor(y-end1);\n    my \\c1 = fpart(y-end1) * x-gap1;\n\n    $plot(x-pxl1, y-pxl1    , 1 - c1) unless c1 == 1;\n    $plot(x-pxl1, y-pxl1 + 1, c1    ) unless c1 == 0;\n \n    # handle second endpoint\n    my \\x-end2 = round(x1);\n    my \\y-end2 = y1 + gradient * (x-end2 - x1);\n    my \\x-gap2 = fpart(x1 + 0.5);\n\n    my \\x-pxl2 = x-end2; # this will be used in the main loop\n    my \\y-pxl2 = floor(y-end2);\n    my \\c2 = fpart(y-end2) * x-gap2;\n \n    my \\intery = y-end1 + gradient;\n\n    # main loop\n    for (x-pxl1 + 1 .. x-pxl2 - 1)\n\tZ\n\t(intery, intery + gradient ... *)\n    -> (\\x,\\y) {\n\tmy \\c = fpart(y);\n\t$plot(x, floor(y)    , 1 - c) unless c == 1;\n\t$plot(x, floor(y) + 1, c    ) unless c == 0;\n    }\n\n    $plot(x-pxl2, y-pxl2    , 1 - c2) unless c2 == 1;\n    $plot(x-pxl2, y-pxl2 + 1, c2    ) unless c2 == 0;\n}\n\ndraw-line [0,1], [10,2];\n\n```\n\nOutput:\n\n```\nplot 0 1 1\nplot 1 1 0.9\nplot 1 2 0.1\nplot 2 1 0.8\nplot 2 2 0.2\nplot 3 1 0.7\nplot 3 2 0.3\nplot 4 1 0.6\nplot 4 2 0.4\nplot 5 1 0.5\nplot 5 2 0.5\nplot 6 1 0.4\nplot 6 2 0.6\nplot 7 1 0.3\nplot 7 2 0.7\nplot 8 1 0.2\nplot 8 2 0.8\nplot 9 1 0.1\nplot 9 2 0.9\nplot 10 2 1\n```"}]}
{"messages": [{"role": "user", "content": "Given an XML document and an XSD schema definition validate that the document follows the schema described.\n\nSample XML and XSD for tests can be found on this W3 Schools page."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Translation of**: Perl\n\n```\n# Reference: https://github.com/libxml-raku/LibXML-raku\n\nuse v6.d;\nuse LibXML;\nuse LibXML::Schema;\n\nmy $good_xml         = '<a>5</a>';\nmy $bad_xml          = '<a>5<b>foobar</b></a>';\n\nmy $xsdschema = q:to<EOF>;\n   <xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">\n      <xsd:element name=\"a\" type=\"xsd:integer\"/>\n   </xsd:schema>\nEOF\n\nmy LibXML $p .= new();\n\nfor ( $good_xml, $bad_xml ) {\n   my $x = $p.parse: :string($_);\n   try { LibXML::Schema.new( string => $xsdschema ).validate( $x ) }\n   !$! ?? say \"Valid.\" !! say $!.message() ;\n}\n\n```\n\nOutput:\n\n```\nValid.\nSchemas validity error : Element 'a': Element content is not allowed, because the type definition is simple.\n\n```"}]}
{"messages": [{"role": "user", "content": "Create a simple DOM and having it serialize to:\n\n```\n <?xml version=\"1.0\" ?>\n <root>\n     <element>\n         Some text here\n     </element>\n </root>\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.05\n\n```\nuse XML;\nuse XML::Writer;\n\nsay my $document = XML::Document.new(\n    XML::Writer.serialize( :root[ :element['Some text here', ], ] )\n);\n\n```\n\nOutput:\n\n```\n<?xml version=\"1.0\"?><root><element>Some text here</element></root>\n\n```"}]}
{"messages": [{"role": "user", "content": "Given the following XML fragment, extract the list of *student names* using whatever means desired. If the only viable method is to use XPath, refer the reader to the task XML and XPath.\n\n```\n<Students>\n  <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n  <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />\n  <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />\n  <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">\n    <Pet Type=\"dog\" Name=\"Rover\" />\n  </Student>\n  <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />\n</Students>\n\n```\n\nExpected Output\n\n```\nApril\nBob\nChad\nDave\nÉmily\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.02\n\n**Library:** XML\n\n```\nuse XML;\n\nmy $xml = from-xml '<Students>\n  <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n  <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />\n  <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />\n  <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">\n    <Pet Type=\"dog\" Name=\"Rover\" />\n  </Student>\n  <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />\n</Students>';\n\nsay .<Name> for $xml.nodes.grep(/Student/)\n\n```"}]}
{"messages": [{"role": "user", "content": "Create a function that takes a list of character names and a list of corresponding remarks and returns an XML document of `<Character>` elements each with a name attributes and each enclosing its remarks.\nAll `<Character>` elements are to be enclosed in turn, in an outer `<CharacterRemarks>` element.\n\nAs an example, calling the function with the three names of:\n\n```\nApril\nTam O'Shanter\nEmily\n```\n\nAnd three remarks of:\n\n```\nBubbly: I'm > Tam and <= Emily\nBurns: \"When chapman billies leave the street ...\"\nShort & shrift\n```\n\nShould produce the XML (but not necessarily with the indentation):\n\n```\n<CharacterRemarks>\n    <Character name=\"April\">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>\n    <Character name=\"Tam O'Shanter\">Burns: \"When chapman billies leave the street ...\"</Character>\n    <Character name=\"Emily\">Short &amp; shrift</Character>\n</CharacterRemarks>\n\n```\n\nThe document may include an <?xml?> declaration and document type declaration, but these are optional. If attempting this task by direct string manipulation, the implementation *must* include code to perform entity substitution for the characters that have entities defined in the XML 1.0 specification.\n\nNote: the example is chosen to show correct escaping of XML strings.\nNote too that although the task is written to take two lists of corresponding data, a single mapping/hash/dictionary of names to remarks is also acceptable.\n\n**Note to editors:** Program output with escaped characters will be viewed as the character on the page so you need to 'escape-the-escapes' to make the RC entry display what would be shown in a plain text viewer (See this).\nAlternately, output can be placed in <syntaxhighlight lang=\"xml\"></syntaxhighlight> tags without any special treatment."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.05\n\n```\nuse XML::Writer;\n\nmy @students =\n    [ Q[April],         Q[Bubbly: I'm > Tam and <= Emily] ],\n    [ Q[Tam O'Shanter], Q[Burns: \"When chapman billies leave the street ...\"] ],\n    [ Q[Emily],         Q[Short & shrift] ]\n;\n\nmy @lines = map { :Character[:name(.[0]), .[1]] }, @students;\n\nsay XML::Writer.serialize( CharacterRemarks => @lines );\n\n```\n\nOutput:\n\n```\n<CharacterRemarks><Character name=\"April\">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>\n<Character name=\"Tam O'Shanter\">Burns: &quot;When chapman billies leave the street ...&quot;</Character>\n<Character name=\"Emily\">Short &amp; shrift</Character></CharacterRemarks>\n\n```"}]}
{"messages": [{"role": "user", "content": "Perform the following three XPath queries on the XML Document below:\n\n* **//item[1]**: Retrieve the first \"item\" element\n* **//price/text()**: Perform an action on each \"price\" element (print it out)\n* **//name**: Get an array of all the \"name\" elements\n\nXML Document:\n\n```\n<inventory title=\"OmniCorp Store #45x10^3\">\n\n<item upc=\"123456789\" stock=\"12\">\n      <name>Invisibility Cream</name>\n      <price>14.50</price>\n      <description>Makes you invisible</description>\n    </item>\n    <item upc=\"445322344\" stock=\"18\">\n      <name>Levitation Salve</name>\n      <price>23.99</price>\n      <description>Levitate yourself for up to 3 hours per application</description>\n    </item>\n\n<item upc=\"485672034\" stock=\"653\">\n      <name>Blork and Freen Instameal</name>\n      <price>4.95</price>\n      <description>A tasty meal in a tablet; just add water</description>\n    </item>\n    <item upc=\"132957764\" stock=\"44\">\n      <name>Grob winglets</name>\n      <price>3.56</price>\n      <description>Tender winglets of Grob. Just add water</description>\n    </item>\n\n</inventory>\n\n```"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nuse XML::XPath;\n\nmy $XML = XML::XPath.new(xml => q:to/END/);\n<inventory title=\"OmniCorp Store #45x10^3\">\n  <section name=\"health\">\n    <item upc=\"123456789\" stock=\"12\">\n      <name>Invisibility Cream</name>\n      <price>14.50</price>\n      <description>Makes you invisible</description>\n    </item>\n    <item upc=\"445322344\" stock=\"18\">\n      <name>Levitation Salve</name>\n      <price>23.99</price>\n      <description>Levitate yourself for up to 3 hours per application</description>\n    </item>\n  </section>\n  <section name=\"food\">\n    <item upc=\"485672034\" stock=\"653\">\n      <name>Blork and Freen Instameal</name>\n      <price>4.95</price>\n      <description>A tasty meal in a tablet; just add water</description>\n    </item>\n    <item upc=\"132957764\" stock=\"44\">\n      <name>Grob winglets</name>\n      <price>3.56</price>\n      <description>Tender winglets of Grob. Just add water</description>\n    </item>\n  </section>\n</inventory>\nEND\n\nput \"First item:\\n\", $XML.find('//item[1]')[0];\n\nput \"\\nPrice elements:\";\n.contents.put for $XML.find('//price').List;\n\nput \"\\nName elements:\\n\", $XML.find('//name')».contents.join: ', ';\n\n```\n\nOutput:\n\n```\nFirst item:\n<item upc=\"123456789\" stock=\"12\"> <name>Invisibility Cream</name>  <price>14.50</price>  <description>Makes you invisible</description>  </item>\n\nPrice elements:\n14.50\n23.99\n4.95\n3.56\n\nName elements:\nInvisibility Cream, Levitation Salve, Blork and Freen Instameal, Grob winglets\n```"}]}
{"messages": [{"role": "user", "content": "You've been given a contract from a three letter abbreviation government agency. They want a program to automatically redact sensitive information from documents to be released to the public. They want fine control over what gets redacted though.\n\nGiven a piece of free-form, possibly Unicode text, (assume text only, no markup or formatting codes) they want to be able to redact: whole words, (case sensitive or insensitive) or partial words, (case sensitive or insensitive). Further, they want the option to \"overkill\" redact a partial word. Overkill redact means if the word *contains* the redact target, even if is only part of the word, redact the **entire** word.\n\nFor our purposes, a \"word\" here, means: a character group, separated by white-space and possibly punctuation; not necessarily strictly alphabetic characters. To \"redact\" a word or partial word, replace each character in the redaction target with a capital letter 'X'. There should be the same number of graphemes in the final redacted word as there were in the non-redacted word.\n\nTask\n\nWrite a procedure to \"redact\" a given piece of text. Your procedure should take the text (or a link to it), the redaction target (or a link to it) and the redaction options. It need not be a single routine, as long as there is some way to programmatically select which operation will be performed. It may be invoked from a command line or as an internal routine, but it should be separately invokable, not just a hard coded block.\n\n*The given strings are enclosed in square brackets to denote them. The brackets should not be counted as part of the strings.*\n\nUsing the test string: [**Tom? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so tom.**]\n\nShow the redacted sentence for each of the redaction target strings [**Tom**] & [**tom**] using the following options:\n\n:   * Whole word\n    * Whole word, Case insensitive\n    * Partial word\n    * Partial word, Case insensitive\n    * Partial word, Overkill\n    * Partial word, Case insensitive, Overkill\n\nNote that some combinations don't, or at least, shouldn't really differ from less specific combination. E.G. \"Whole word, Overkill\" should be theoretically be exactly the same as \"Whole word\".\n\nExtra kudos for not including adjoining punctuation during \"Overkill\" redaction.\n\nExtra kudos if the redaction target can contain non-letter characters.\n\n*The demo strings use the abbreviations **w/p** for whole/partial word, **i/s** for case insensitive/sensitive, **n/o** for normal/overkill. You are not required to use those, or any abbreviation. They are just for display, though may be useful to show what operation you are **intending** to perform.*\n\nIdeal expected output (adjoining punctuation untouched):\n\n```\n   Redact 'Tom':\n   [w|s|n] XXX? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so tom.\n   [w|i|n] XXX? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so XXX.\n   [p|s|n] XXX? XXXs bottom tomato is in his stomach while playing the \"XXX-tom\" brand tom-toms. That's so tom.\n   [p|i|n] XXX? XXXs botXXX XXXato is in his sXXXach while playing the \"XXX-XXX\" brand XXX-XXXs. That's so XXX.\n   [p|s|o] XXX? XXXX bottom tomato is in his stomach while playing the \"XXXXXXX\" brand tom-toms. That's so tom.\n   [p|i|o] XXX? XXXX XXXXXX XXXXXX is in his XXXXXXX while playing the \"XXXXXXX\" brand XXXXXXXX. That's so XXX.\n\n```\n\n```\n   Redact 'tom':\n   [w|s|n] Tom? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so XXX.\n   [w|i|n] XXX? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so XXX.\n   [p|s|n] Tom? Toms botXXX XXXato is in his sXXXach while playing the \"Tom-XXX\" brand XXX-XXXs. That's so XXX.\n   [p|i|n] XXX? XXXs botXXX XXXato is in his sXXXach while playing the \"XXX-XXX\" brand XXX-XXXs. That's so XXX.\n   [p|s|o] Tom? Toms XXXXXX XXXXXX is in his XXXXXXX while playing the \"XXXXXXX\" brand XXXXXXXX. That's so XXX.\n   [p|i|o] XXX? XXXX XXXXXX XXXXXX is in his XXXXXXX while playing the \"XXXXXXX\" brand XXXXXXXX. That's so XXX.\n\n```\n\nStretch\n\nComplex Unicode: Using the test string: [🧑 👨 🧔 👨‍👩‍👦] and the redaction strings: [👨] and [👨‍👩‍👦]\n\nShow the redacted strings when using the option \"Whole word\" (Case sensitivity shouldn't matter.) A single grapheme should be replaced by a single 'X'.\n\n```\n                  🧑 👨 🧔 👨‍👩‍👦\n   Redact '👨' [w] 🧑 X 🧔 👨‍👩‍👦\n   Redact '👨‍👩‍👦' [w] 🧑 👨 🧔 X\n\n```\n\nOther tasks related to string operations:\n\nMetrics\n\n* Array length\n* String length\n* Copy a string\n* Empty string  (assignment)\n\nCounting\n\n* Word frequency\n* Letter frequency\n* Jewels and stones\n* I before E except after C\n* Bioinformatics/base count\n* Count occurrences of a substring\n* Count how many vowels and consonants occur in a string\n\nRemove/replace\n\n* XXXX redacted\n* Conjugate a Latin verb\n* Remove vowels from a string\n* String interpolation (included)\n* Strip block comments\n* Strip comments from a string\n* Strip a set of characters from a string\n* Strip whitespace from a string -- top and tail\n* Strip control codes and extended characters from a string\n\nAnagrams/Derangements/shuffling\n\n* Word wheel\n* ABC problem\n* Sattolo cycle\n* Knuth shuffle\n* Ordered words\n* Superpermutation minimisation\n* Textonyms (using a phone text pad)\n* Anagrams\n* Anagrams/Deranged anagrams\n* Permutations/Derangements\n\nFind/Search/Determine\n\n* ABC words\n* Odd words\n* Word ladder\n* Semordnilap\n* Word search\n* Wordiff  (game)\n* String matching\n* Tea cup rim text\n* Alternade words\n* Changeable words\n* State name puzzle\n* String comparison\n* Unique characters\n* Unique characters in each string\n* Extract file extension\n* Levenshtein distance\n* Palindrome detection\n* Common list elements\n* Longest common suffix\n* Longest common prefix\n* Compare a list of strings\n* Longest common substring\n* Find common directory path\n* Words from neighbour ones\n* Change e letters to i in words\n* Non-continuous subsequences\n* Longest common subsequence\n* Longest palindromic substrings\n* Longest increasing subsequence\n* Words containing \"the\" substring\n* Sum of the digits of n is substring of n\n* Determine if a string is numeric\n* Determine if a string is collapsible\n* Determine if a string is squeezable\n* Determine if a string has all unique characters\n* Determine if a string has all the same characters\n* Longest substrings without repeating characters\n* Find words which contains all the vowels\n* Find words which contain the most consonants\n* Find words which contains more than 3 vowels\n* Find words whose first and last three letters are equal\n* Find words with alternating vowels and consonants\n\nFormatting\n\n* Substring\n* Rep-string\n* Word wrap\n* String case\n* Align columns\n* Literals/String\n* Repeat a string\n* Brace expansion\n* Brace expansion using ranges\n* Reverse a string\n* Phrase reversals\n* Comma quibbling\n* Special characters\n* String concatenation\n* Substring/Top and tail\n* Commatizing numbers\n* Reverse words in a string\n* Suffixation of decimal numbers\n* Long literals, with continuations\n* Numerical and alphabetical suffixes\n* Abbreviations, easy\n* Abbreviations, simple\n* Abbreviations, automatic\n\nSong lyrics/poems/Mad Libs/phrases\n\n* Mad Libs\n* Magic 8-ball\n* 99 bottles of beer\n* The Name Game (a song)\n* The Old lady swallowed a fly\n* The Twelve Days of Christmas\n\nTokenize\n\n* Text between\n* Tokenize a string\n* Word break problem\n* Tokenize a string with escaping\n* Split a character string based on change of character\n\nSequences\n\n* Show ASCII table\n* De Bruijn sequences\n* Summarize and say sequence\n* Generate lower case ASCII alphabet"}, {"role": "assistant", "content": "**Works with**: Rakudo version 2020.02\n\n```\nsub redact ( Str $str, Str $redact, :i(:$insensitive) = False, :p(:$partial) = False, :o(:$overkill) = False ) {\n    my $rx =\n        $insensitive ??\n            $partial ??\n           $overkill ?? rx/:i <?after ^ | <:Po> | \\s > (<[\\w<:!Po>-]>*? [\\w*\\']? $redact [\\w*\\'\\w+]? \\S*?) <?before $ | <:Po> | \\s > / #'\n                     !! rx/:i ($redact) /\n                     !! rx/:i <?after ^ | [\\s<:Po>] | \\s > ($redact) <?before $ | <:Po> | \\s > /\n                     !!\n            $partial ??\n           $overkill ?? rx/ <?after ^ | <:Po> | \\s > (<[\\w<:!Po>-]>*? [\\w*\\']? $redact [\\w*\\'\\w+]? \\S*?) <?before $ | <:Po> | \\s > / #'\n                     !! rx/ ($redact) /\n                     !! rx/ <?after ^ | [\\s<:Po>] | \\s > ($redact) <?before $ | <:Po> | \\s > /\n    ;\n    $str.subst( $rx, {'X' x $0.chars}, :g )\n}\n\nmy %*SUB-MAIN-OPTS = :named-anywhere;\n\n# Operate on a given file with the given parameters\nmulti MAIN (\n    Str $file,    #= File name with path\n    Str $target,  #= Redact target text string\n    :$i = False,  #= Case insensitive flag\n    :$p = False,  #= Partial words flag\n    :$o = False   #= Overkill flag\n  ) { put $file.IO.slurp.&redact( $target, :i($i), :p($p), :o($o) ) }\n\n# Operate on the internal strings / parameters\nmulti MAIN () {\n\n# TESTING\n\n    my $test = q:to/END/;\n        Tom? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so tom.\n        'Tis very tomish, don't you think?\n        END\n        #'\n\n    for 'Tom', 'tom', 't' -> $redact {\n        say \"\\nRedact '$redact':\";\n        for '[w|s|n]', $redact, {},\n            '[w|i|n]', $redact, {:i},\n            '[p|s|n]', $redact, {:p},\n            '[p|i|n]', $redact, {:p, :i},\n            '[p|s|o]', $redact, {:p, :o},\n            '[p|i|o]', $redact, {:p, :i, :o}\n        -> $option, $str, %opts { printf \"%s %s\\n\", $option, $test.&redact($str, |%opts) }\n    }\n\n    my $emoji = '🧑 👨 🧔 👨‍👩‍👦';\n    printf \"%20s %s\\n\", '', $emoji;\n    printf \"%20s %s\\n\", \"Redact '👨' [w]\", $emoji.&redact('👨');\n    printf \"%20s %s\\n\", \"Redact '👨‍👩‍👦' [w]\", $emoji.&redact('👨‍👩‍👦');\n\n    # Even more complicated Unicode\n\n    $emoji = 'Argentina🧑🇦🇹  France👨🇫🇷  Germany🧔🇩🇪  Netherlands👨‍👩‍👦🇳🇱';\n    printf \"\\n%20s %s\\n\", '', $emoji;\n    printf \"%20s %s\\n\", \"Redact '👨' [p]\", $emoji.&redact('👨', :p);\n    printf \"%20s %s\\n\", \"Redact '👨‍👩‍👦' [p]\", $emoji.&redact('👨‍👩‍👦', :p);\n    printf \"%20s %s\\n\", \"Redact '👨' [p|o]\", $emoji.&redact('👨', :p, :o);\n    printf \"%20s %s\\n\", \"Redact '👨‍👩‍👦' [p|o]\", $emoji.&redact('👨‍👩‍👦', :p, :o);\n}\n\n```\n\nOutput:\n\n```\nRedact 'Tom':\n[w|s|n] XXX? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so tom.\n'Tis very tomish, don't you think?\n\n[w|i|n] XXX? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so XXX.\n'Tis very tomish, don't you think?\n\n[p|s|n] XXX? XXXs bottom tomato is in his stomach while playing the \"XXX-tom\" brand tom-toms. That's so tom.\n'Tis very tomish, don't you think?\n\n[p|i|n] XXX? XXXs botXXX XXXato is in his sXXXach while playing the \"XXX-XXX\" brand XXX-XXXs. That's so XXX.\n'Tis very XXXish, don't you think?\n\n[p|s|o] XXX? XXXX bottom tomato is in his stomach while playing the \"XXXXXXX\" brand tom-toms. That's so tom.\n'Tis very tomish, don't you think?\n\n[p|i|o] XXX? XXXX XXXXXX XXXXXX is in his XXXXXXX while playing the \"XXXXXXX\" brand XXXXXXXX. That's so XXX.\n'Tis very XXXXXX, don't you think?\n\n\nRedact 'tom':\n[w|s|n] Tom? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so XXX.\n'Tis very tomish, don't you think?\n\n[w|i|n] XXX? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so XXX.\n'Tis very tomish, don't you think?\n\n[p|s|n] Tom? Toms botXXX XXXato is in his sXXXach while playing the \"Tom-XXX\" brand XXX-XXXs. That's so XXX.\n'Tis very XXXish, don't you think?\n\n[p|i|n] XXX? XXXs botXXX XXXato is in his sXXXach while playing the \"XXX-XXX\" brand XXX-XXXs. That's so XXX.\n'Tis very XXXish, don't you think?\n\n[p|s|o] Tom? Toms XXXXXX XXXXXX is in his XXXXXXX while playing the \"XXXXXXX\" brand XXXXXXXX. That's so XXX.\n'Tis very XXXXXX, don't you think?\n\n[p|i|o] XXX? XXXX XXXXXX XXXXXX is in his XXXXXXX while playing the \"XXXXXXX\" brand XXXXXXXX. That's so XXX.\n'Tis very XXXXXX, don't you think?\n\n\nRedact 't':\n[w|s|n] Tom? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so tom.\n'Tis very tomish, don't you think?\n\n[w|i|n] Tom? Toms bottom tomato is in his stomach while playing the \"Tom-tom\" brand tom-toms. That's so tom.\n'Tis very tomish, don't you think?\n\n[p|s|n] Tom? Toms boXXom XomaXo is in his sXomach while playing Xhe \"Tom-Xom\" brand Xom-Xoms. ThaX's so Xom.\n'Tis very Xomish, don'X you Xhink?\n\n[p|i|n] Xom? Xoms boXXom XomaXo is in his sXomach while playing Xhe \"Xom-Xom\" brand Xom-Xoms. XhaX's so Xom.\n'Xis very Xomish, don'X you Xhink?\n\n[p|s|o] Tom? Toms XXXXXX XXXXXX is in his XXXXXXX while playing XXX \"XXXXXXX\" brand XXXXXXXX. XXXXXX so XXX.\n'Tis very XXXXXX, XXXXX you XXXXX?\n\n[p|i|o] XXX? XXXX XXXXXX XXXXXX is in his XXXXXXX while playing XXX \"XXXXXXX\" brand XXXXXXXX. XXXXXX so XXX.\nXXXX very XXXXXX, XXXXX you XXXXX?\n\n                     🧑 👨 🧔 👨‍👩‍👦\n      Redact '👨' [w] 🧑 X 🧔 👨‍👩‍👦\n      Redact '👨‍👩‍👦' [w] 🧑 👨 🧔 X\n\n                     Argentina🧑🇦🇹  France👨🇫🇷  Germany🧔🇩🇪  Netherlands👨‍👩‍👦🇳🇱\n      Redact '👨' [p] Argentina🧑🇦🇹  FranceX🇫🇷  Germany🧔🇩🇪  Netherlands👨‍👩‍👦🇳🇱\n      Redact '👨‍👩‍👦' [p] Argentina🧑🇦🇹  France👨🇫🇷  Germany🧔🇩🇪  NetherlandsX🇳🇱\n    Redact '👨' [p|o] Argentina🧑🇦🇹  XXXXXXXX  Germany🧔🇩🇪  Netherlands👨‍👩‍👦🇳🇱\n    Redact '👨‍👩‍👦' [p|o] Argentina🧑🇦🇹  France👨🇫🇷  Germany🧔🇩🇪  XXXXXXXXXXXXX\n\n```"}]}
{"messages": [{"role": "user", "content": "In strict functional programming and the lambda calculus, functions (lambda expressions) don't have state and are only allowed to refer to arguments of enclosing functions.\n\nThis rules out the usual definition of a recursive function wherein a function is associated with the state of a variable and this variable's state is used in the body of the function.\n\nThe   Y combinator   is itself a stateless function that, when applied to another stateless function, returns a recursive version of the function.\n\nThe Y combinator is the simplest of the class of such functions, called fixed-point combinators.\n\nTask\n\nDefine the stateless   *Y combinator*   and use it to compute factorials and Fibonacci numbers from other stateless functions or lambda expressions.\n\nCf\n\n* Jim Weirich: Adventures in Functional Programming"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n```\nsub Y (&f) { sub (&x) { x(&x) }( sub (&y) { f(sub ($x) { y(&y)($x) }) } ) }\nsub fac (&f) { sub ($n) { $n < 2 ?? 1 !! $n * f($n - 1) } }\nsub fib (&f) { sub ($n) { $n < 2 ?? $n !! f($n - 1) + f($n - 2) } }\nsay map Y($_), ^10 for &fac, &fib;\n```\n\nOutput:\n\n```\n(1 1 2 6 24 120 720 5040 40320 362880)\n(0 1 1 2 3 5 8 13 21 34)\n```\n\nNote that Raku doesn't actually need a Y combinator because you can name anonymous functions from the inside:\n\n```\nsay .(10) given sub (Int $x) { $x < 2 ?? 1 !! $x * &?ROUTINE($x - 1); }\n```"}]}
{"messages": [{"role": "user", "content": "Create a class for searching Yahoo! results.\n\nIt must implement a **Next Page** method, and read URL, Title and Content from results."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Library:** Gumbo\n\n**Library:** LWP-Simple\n\n**Library:** exemel\n\nYahooSearch.rakumod:\n\n```\nuse Gumbo;\nuse LWP::Simple;\nuse XML::Text;\n\nclass YahooSearch {\n  has $!dom;\n\n  submethod BUILD (:$!dom) { }\n\n  method new($term) {\n    self.bless(\n      dom => parse-html(\n        LWP::Simple.get(\"http://search.yahoo.com/search?p={ $term }\")\n      )\n    );\n  }\n\n  method next {\n    $!dom = parse-html(\n      LWP::Simple.get(\n        $!dom.lookfor( TAG => 'a', class => 'next' ).head.attribs<href> \n      )\n    );\n    self;\n  }\n\n  method text ($node) {\n    return ''         unless $node;\n    return $node.text if     $node ~~ XML::Text;\n\n    $node.nodes.map({ self.text($_).trim }).join(' ');\n  }\n\n  method results {\n    state $n = 0;\n    for $!dom.lookfor( TAG => 'h3', class => 'title') {\n      given .lookfor( TAG => 'a' )[0] {\n        next unless $_;                                               # No Link\n        next if .attribs<href> ~~ / ^ 'https://r.search.yahoo.com' /; # Ad\n        say \"=== #{ ++$n } ===\";\n        say \"Title: { .contents[0] ?? self.text( .contents[0] ) !! '' }\";\n        say \"  URL: { .attribs<href> }\";\n\n        my $pt = .parent.parent.parent.elements( TAG => 'div' ).tail;\n        say \" Text: { self.text($pt) }\";\n      }\n    }\n    self;\n  }\n\n}\n\nsub MAIN (Str $search-term) is export {\n  YahooSearch.new($search-term).results.next.results;\n}\n\n```\n\nAnd the invocation script is simply:\n\nyahoo-search.raku\n\n```\n   use YahooSearch; \n\n```\n\nSo:\n\n```\n   raku yahoo-search.raku test \n\n```\n\nShould give out something like the following:\n\n```\n=== #1 ===\nTitle: \n  URL: https://www.speedtest.net/\n Text: At Ookla, we are committed to ensuring that individuals with disabilities can access all of the content at www.speedtest.net. We also strive to make all content in Speedtest apps accessible. If you are having trouble accessing www.speedtest.net or Speedtest apps, please email legal@ziffdavis.com for assistance. Please put \"ADA Inquiry\" in the ...\n=== #2 ===\nTitle: Test | Definition of Test by Merriam-Webster\n  URL: https://www.merriam-webster.com/dictionary/test\n Text: Test definition is - a means of testing: such as. How to use test in a sentence.\n=== #3 ===\nTitle: - Video Results\n  URL: https://video.search.yahoo.com/search/video?p=test\n Text: More Test videos\n\n```\n\n...and should go up to result #21!"}]}
{"messages": [{"role": "user", "content": "The **Yellowstone sequence**, also called the **Yellowstone permutation**, is defined as:\n\nFor n <= 3,\n\n```\n   a(n) = n\n\n```\n\nFor n >= 4,\n\n```\n   a(n) = the smallest number not already in sequence such that a(n) is relatively prime to a(n-1) and \n          is not relatively prime to a(n-2).\n\n```\n\nThe sequence is a permutation of the natural numbers, and gets its name from what its authors felt was a spiking, geyser like appearance of a plot of the sequence.\n\nExample\n\na(4) is 4 because 4 is the smallest number following 1, 2, 3 in the sequence that is relatively prime to the entry before it (3), and is not relatively prime to the number two entries before it (2).\n\nTask\n:   Find and show as output the first  **30**  Yellowstone numbers.\n\nExtra\n:   Demonstrate how to plot, with x = n and y coordinate a(n), the first 100 Yellowstone numbers.\n\nRelated tasks\n:   * Greatest common divisor.\n    * Plot coordinate pairs.\n    * EKG sequence convergence\n\nSee also\n:   * The OEIS entry:   A098550 The Yellowstone permutation.\n    * Applegate et al, 2015: The Yellowstone Permutation [1]."}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2020.01\n\nNot really clear whether a line graph or bar graph was desired, so generate both. Also, 100 points don't really give a good feel for the overall shape so do 500.\n\n```\nmy @yellowstone = 1, 2, 3, -> $q, $p {\n    state @used = True xx 4;\n    state $min  = 3;\n    my \\index = ($min .. *).first: { not @used[$_] and $_ gcd $q != 1 and $_ gcd $p == 1 };\n    @used[index] = True;\n    $min = @used.first(!*, :k) // +@used - 1;\n    index\n} … *;\n\nput \"The first 30 terms in the Yellowstone sequence:\\n\", @yellowstone[^30];\n\nuse SVG;\nuse SVG::Plot;\n\nmy @x = ^500;\n\nmy $chart = SVG::Plot.new(\n    background  => 'white',\n    width       => 1000,\n    height      => 600,\n    plot-width  => 950,\n    plot-height => 550,\n    x           => @x,\n    x-tick-step => { 10 },\n    y-tick-step => { 50 },\n    min-y-axis  => 0,\n    values      => [@yellowstone[@x],],\n    title       => \"Yellowstone Sequence - First {+@x} values (zero indexed)\",\n);\n\nmy $line = './Yellowstone-sequence-line-perl6.svg'.IO;\nmy $bars = './Yellowstone-sequence-bars-perl6.svg'.IO;\n\n$line.spurt: SVG.serialize: $chart.plot: :lines;\n$bars.spurt: SVG.serialize: $chart.plot: :bars;\n\n```\n\nOutput:\n\n```\nThe first 30 terms in the Yellowstone sequence:\n1 2 3 4 9 8 15 14 5 6 25 12 35 16 7 10 21 20 27 22 39 11 13 33 26 45 28 51 32 17\n```\n\nSee (offsite SVG images) Line graph or Bar graph"}]}
{"messages": [{"role": "user", "content": "One well-known symbol of the philosophy of duality known as yin and yang is the taijitu.\n\nTask\n:   * Create a function that, given a parameter representing size, generates such a symbol scaled to the requested size.\n    * Generate and display the symbol for two different (small) sizes."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nTranslation / Modification of C and Perl examples.\n\n```\nsub circle ($rad, $cx, $cy, $fill = 'white', $stroke = 'black' ){\n    say \"<circle cx='$cx' cy='$cy' r='$rad' fill='$fill' stroke='$stroke' stroke-width='1'/>\";\n}\n\nsub yin_yang ($rad, $cx, $cy, :$fill = 'white', :$stroke = 'black', :$angle = 90) {\n    my ($c, $w) = (1, 0);\n    say \"<g transform='rotate($angle, $cx, $cy)'>\" if $angle;\n    circle($rad, $cx, $cy, $fill, $stroke);\n    say \"<path d='M $cx {$cy + $rad}A {$rad/2} {$rad/2} 0 0 $c $cx $cy \",\n        \"{$rad/2} {$rad/2} 0 0 $w $cx {$cy - $rad} $rad $rad 0 0 $c $cx \",\n        \"{$cy + $rad} z' fill='$stroke' stroke='none' />\";\n    circle($rad/5, $cx, $cy + $rad/2, $fill, $stroke);\n    circle($rad/5, $cx, $cy - $rad/2, $stroke, $fill);\n    say \"</g>\" if $angle;\n}\n\nsay '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<svg height=\"400\" width=\"400\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\"\n xmlns:xlink=\"http://www.w3.org/1999/xlink\">';\n\nyin_yang(100, 130, 130);\nyin_yang(50, 300, 300);\n\nsay '</svg>';\n\n```\n\nSeems like something of a cheat since it relies on a web browser /\nsvg image interpreter to actually view the output image.\nIf that's the case, we may as well cheat harder. ;-)\n\n```\nsub cheat_harder ($scale) { \"<span style=\\\"font-size:$scale%;\\\">&#x262f;</span>\"; }\n\nsay '<div>', cheat_harder(700), cheat_harder(350), '</div>';\n\n```\n\n☯☯"}]}
{"messages": [{"role": "user", "content": "The Zebra puzzle, a.k.a. Einstein's Riddle,\nis a logic puzzle which is to be solved programmatically.\n\nIt has several variants, one of them this:\n\n:   1. There are five houses.\n    2. The English man lives in the red house.\n    3. The Swede has a dog.\n    4. The Dane drinks tea.\n    5. The green house is immediately to the left of the white house.\n    6. They drink coffee in the green house.\n    7. The man who smokes Pall Mall has a bird.\n    8. In the yellow house they smoke Dunhill.\n    9. In the middle house they drink milk.\n    10. The Norwegian lives in the first house.\n    11. The Blend-smoker lives in the house next to the house with a cat.\n    12. In a house next to the house with a horse, they smoke Dunhill.\n    13. The man who smokes Blue Master drinks beer.\n    14. The German smokes Prince.\n    15. The Norwegian lives next to the blue house.\n    16. They drink water in a house next to the house where they smoke Blend.\n\nThe question is, who owns the zebra? For clarity, each of the five houses is painted a different color, and their inhabitants are of different nationalities, own different pets, drink different beverages and smoke different brands of cigarettes.\n\nAdditionally, list the solution for all the houses.\n  \nOptionally, show the solution is unique.\n\nRelated tasks\n\n* Dinesman's multiple-dwelling problem\n* Twelve statements"}, {"role": "assistant", "content": "(formerly Perl 6)\nA rule driven approach:\n\n```\nmy Hash @houses = (1 .. 5).map: { %(:num($_)) }; # 1 there are five houses\n\nmy @facts = (\n    { :nat<English>, :color<red> },      # 2 The English man lives in the red house.\n    { :nat<Swede>, :pet<dog> },          # 3 The Swede has a dog.\n    { :nat<Dane>, :drink<tea> },         # 4 The Dane drinks tea.\n    { :color<green>, :Left-Of(:color<white>) }, # 5 the green house is immediately to the left of the white house\n    { :drink<coffee>, :color<green> },   # 6 They drink coffee in the green house.\n    { :smoke<Pall-Mall>, :pet<birds> },  # 7 The man who smokes Pall Mall has birds.\n    { :color<yellow>, :smoke<Dunhill> }, # 8 In the yellow house they smoke Dunhill.\n    { :num(3), :drink<milk> },           # 9 In the middle house they drink milk.\n    { :num(1), :nat<Norwegian> },        # 10 The Norwegian lives in the first house.\n    { :smoke<Blend>, :Next-To(:pet<cats>) }, # 11 The man who smokes Blend lives in the house next to the house with cats.\n    { :pet<horse>, :Next-To(:smoke<Dunhill>) }, # 12 In a house next to the house where they have a horse, they smoke Dunhill.\n    { :smoke<Blue-Master>, :drink<beer> }, # 13 The man who smokes Blue Master drinks beer.\n    { :nat<German>, :smoke<Prince> },      # 14 The German smokes Prince.\n    { :nat<Norwegian>, :Next-To(:color<blue>) }, # 15 The Norwegian lives next to the blue house.\n    { :drink<water>, :Next-To(:smoke<Blend>) },  # 16 They drink water in a house next to the house where they smoke Blend.\n    { :pet<zebra> }, # who owns this?\n);\n\nsub MAIN {\n    for gather solve(@houses, @facts) {\n        #-- output\n        say .head.sort.map(*.key.uc.fmt(\"%-9s\")).join(' | ');\n        say .sort.map(*.value.fmt(\"%-9s\")).join(' | ')\n            for .list;\n        last; # stop after first solution\n    }\n}\n\n#| a solution has been found that fits all the facts\nmulti sub solve(@solution, @facts [ ]) {\n    take @solution;\n}\n\n#| extend this scenario to fit the next fact\nmulti sub solve(@scenario, [ $fact, *@facts ]) {\n    for gather match(@scenario, |$fact) -> @houses {\n        solve(@houses, @facts)\n    }\n}\n\n#| find all possible solutions for pairs of houses with\n#| properties %b, left of a house  with properties %a\nmulti sub match(@houses, :Left-Of(%a)!, *%b) {\n    for 1 ..^ @houses {\n        my %left-house  := @houses[$_-1];\n        my %right-house := @houses[$_];\n        \n        if plausible(%left-house, %a) && plausible(%right-house, %b) {\n            temp %left-house  ,= %a;\n            temp %right-house ,= %b;\n            take @houses;\n        }\n    }\n}\n\n#| match these houses are next to each other (left or right)\nmulti sub match(@houses, :Next-To(%b)!, *%a ) {\n    match(@houses, |%a, :Left-Of(%b) );\n    match(@houses, |%b, :Left-Of(%a) );\n}\n\n#| find all possible houses that match the given properties\nmulti sub match(@houses, *%props) {\n    for @houses.grep({plausible($_, %props)}) -> %house {\n        temp %house ,= %props;\n        take @houses;\n    }\n}\n\n#| plausible if doesn't conflict with anything\nsub plausible(%house, %props) {\n   ! %props.first: {%house{.key} && %house{.key} ne .value };\n}\n\n```\n\nOutput:\n\n```\nCOLOR     | DRINK     | NAT       | NUM       | PET       | SMOKE    \nyellow    | water     | Norwegian | 1         | cats      | Dunhill  \nblue      | tea       | Dane      | 2         | horse     | Blend    \nred       | milk      | English   | 3         | birds     | Pall-Mall\ngreen     | coffee    | German    | 4         | zebra     | Prince   \nwhite     | beer      | Swede     | 5         | dog       | Blue-Master\n\n```\n\nNote: Facts can be shuffled by changing line 3 to `my @facts = pick *, (`. It seems to reliably find solutions, although execution times will vary (from under 1 sec up to about 10sec)."}]}
{"messages": [{"role": "user", "content": "This task is a *total immersion* zeckendorf task; using decimal numbers will attract serious disapprobation.\n\nThe task is to implement addition, subtraction, multiplication, and division using Zeckendorf number representation. Optionally provide decrement, increment and comparitive operation functions.\n\nAddition\n\nLike binary 1 + 1 = 10, note carry 1 left. There the similarity ends. 10 + 10 = 101, note carry 1 left and 1 right. 100 + 100 = 1001, note carry 1 left and 2 right, this is the general case.\n\nOccurrences of 11 must be changed to 100. Occurrences of 111 may be changed from the right by replacing 11 with 100, or from the left converting 111 to 100 + 100;\n\nSubtraction\n\n10 - 1 = 1. The general rule is borrow 1 right carry 1 left. eg:\n\n```\n  abcde\n  10100 -\n   1000\n  _____\n    100  borrow 1 from a leaves 100\n  + 100  add the carry\n  _____\n   1001\n\n```\n\nA larger example:\n\n```\n  abcdef\n  100100 -\n    1000\n  ______\n  1*0100 borrow 1 from b\n   + 100 add the carry\n  ______\n  1*1001\n\nSadly we borrowed 1 from b which didn't have it to lend. So now b borrows from a:\n\n    1001\n  + 1000 add the carry\n    ____\n   10100\n\n```\n\nMultiplication\n\nHere you teach your computer its zeckendorf tables. eg. 101 \\* 1001:\n\n```\n  a = 1 * 101 = 101\n  b = 10 * 101 = a + a = 10000\n  c = 100 * 101 = b + a = 10101\n  d = 1000 * 101 = c + b = 101010\n\n  1001 = d + a therefore 101 * 1001 =\n \n  101010\n   + 101\n  ______\n 1000100\n\n```\n\nDivision\n\nLets try 1000101 divided by 101, so we can use the same table used for multiplication.\n\n```\n  1000101 -\n   101010 subtract d (1000 * 101)\n  _______\n     1000 -\n      101 b and c are too large to subtract, so subtract a\n     ____\n        1 so 1000101 divided by 101 is d + a (1001) remainder 1\n\n```\n\nEfficient algorithms for Zeckendorf arithmetic is interesting. The sections on addition and subtraction are particularly relevant for this task."}, {"role": "assistant", "content": "(formerly Perl 6)\n\nThis is a somewhat limited implementation of Zeckendorf arithmetic operators. They only handle positive integer values. There are no actual calculations, everything is done with string manipulations, so it doesn't matter what glyphs you use for 1 and 0.\n\nImplemented arithmetic operators:\n\n```\n  +z addition \n  -z subtraction\n  ×z multiplication\n  /z division (more of a divmod really)\n ++z post increment\n --z post decrement\n\n```\n\nComparison operators:\n\n```\n eqz equal \n nez not equal \n gtz greater than \n ltz less than \n\n```\n\n```\nmy $z1 = '1'; # glyph to use for a '1'\nmy $z0 = '0'; # glyph to use for a '0'\n\nsub zorder($a) { ($z0 lt $z1) ?? $a !! $a.trans([$z0, $z1] => [$z1, $z0]) }\n\n######## Zeckendorf comparison operators #########\n\n# less than\nsub infix:<ltz>($a, $b) { $a.&zorder lt $b.&zorder }\n\n# greater than\nsub infix:<gtz>($a, $b) { $a.&zorder gt $b.&zorder }\n\n# equal\nsub infix:<eqz>($a, $b) { $a eq $b }\n\n# not equal\nsub infix:<nez>($a, $b) { $a ne $b }\n\n######## Operators for Zeckendorf arithmetic ########\n\n# post increment\nsub postfix:<++z>($a is rw) {\n    $a = (\"$z0$z0\"~$a).subst(/(\"$z0$z0\")($z1+ %% $z0)?$/,\n      -> $/ { \"$z0$z1\" ~ ($1 ?? $z0 x $1.chars !! '') });\n    $a ~~ s/^$z0+//;\n    $a\n}\n\n# post decrement\nsub postfix:<--z>($a is rw) {\n    $a.=subst(/$z1($z0*)$/,\n      -> $/ {$z0 ~ \"$z1$z0\" x $0.chars div 2 ~ $z1 x $0.chars mod 2});\n    $a ~~ s/^$z0+(.+)$/$0/;\n    $a\n}\n\n# addition\nsub infix:<+z>($a is copy, $b is copy) { $a++z; $a++z while $b--z nez $z0; $a }\n\n# subtraction\nsub infix:<-z>($a is copy, $b is copy) { $a--z; $a--z while $b--z nez $z0; $a }\n\n# multiplication\nsub infix:<×z>($a, $b) { \n    return $z0 if $a eqz $z0 or $b eqz $z0;\n    return $a if $b eqz $z1;\n    return $b if $a eqz $z1;\n    my $c = $a;\n    my $d = $z1;\n    repeat { \n         my $e = $z0;\n         repeat { $c++z; $e++z } until $e eqz $a;\n         $d++z;\n    } until $d eqz $b;\n    $c\n}\n\n# division  (really more of a div mod)\nsub infix:</z>($a is copy, $b is copy) {\n    fail \"Divide by zero\" if $b eqz $z0;\n    return $a if $a eqz $z0 or $b eqz $z1;\n    my $c = $z0;\n    repeat { \n        my $d = $b +z ($z1 ~ $z0);\n        $c++z;\n        $a++z;\n        $a--z while $d--z nez $z0\n    } until $a ltz $b;\n    $c ~= \" remainder $a\" if $a nez $z0;\n    $c\n}\n\n###################### Testing ######################\n\n# helper sub to translate constants into the particular glyphs you used\nsub z($a) { $a.trans([<1 0>] => [$z1, $z0]) }\n\nsay \"Using the glyph '$z1' for 1 and '$z0' for 0\\n\";\n\nmy $fmt = \"%-22s = %15s  %s\\n\";\n\nmy $zeck = $z1;\n\nprintf( $fmt, \"$zeck++z\", $zeck++z, '# increment' ) for 1 .. 10;\n\nprintf $fmt, \"$zeck +z {z('1010')}\", $zeck +z= z('1010'), '# addition';\n\nprintf $fmt, \"$zeck -z {z('100')}\", $zeck -z= z('100'), '# subtraction';\n\nprintf $fmt, \"$zeck ×z {z('100101')}\", $zeck ×z= z('100101'), '# multiplication';\n\nprintf $fmt, \"$zeck /z {z('100')}\", $zeck /z= z('100'), '# division';\n\nprintf( $fmt, \"$zeck--z\", $zeck--z, '# decrement' ) for 1 .. 5;\n\nprintf $fmt, \"$zeck ×z {z('101001')}\", $zeck ×z= z('101001'), '# multiplication';\n\nprintf $fmt, \"$zeck /z {z('100')}\", $zeck /z= z('100'), '# division';\n\n```\n\n**Testing Output**\n\n```\nUsing the glyph '1' for 1 and '0' for 0\n\n1++z                   =              10  # increment\n10++z                  =             100  # increment\n100++z                 =             101  # increment\n101++z                 =            1000  # increment\n1000++z                =            1001  # increment\n1001++z                =            1010  # increment\n1010++z                =           10000  # increment\n10000++z               =           10001  # increment\n10001++z               =           10010  # increment\n10010++z               =           10100  # increment\n10100 +z 1010          =          101000  # addition\n101000 -z 100          =          100010  # subtraction\n100010 ×z 100101       =    100001000001  # multiplication\n100001000001 /z 100    =       101010001  # division\n101010001--z           =       101010000  # decrement\n101010000--z           =       101001010  # decrement\n101001010--z           =       101001001  # decrement\n101001001--z           =       101001000  # decrement\n101001000--z           =       101000101  # decrement\n101000101 ×z 101001    = 101010000010101  # multiplication\n101010000010101 /z 100 = 1001010001001 remainder 10  # division\n```\n\nUsing alternate glyphs:\n\n```\nUsing the glyph 'X' for 1 and 'O' for 0\n\nX++z                   =              XO  # increment\nXO++z                  =             XOO  # increment\nXOO++z                 =             XOX  # increment\nXOX++z                 =            XOOO  # increment\nXOOO++z                =            XOOX  # increment\nXOOX++z                =            XOXO  # increment\nXOXO++z                =           XOOOO  # increment\nXOOOO++z               =           XOOOX  # increment\nXOOOX++z               =           XOOXO  # increment\nXOOXO++z               =           XOXOO  # increment\nXOXOO +z XOXO          =          XOXOOO  # addition\nXOXOOO -z XOO          =          XOOOXO  # subtraction\nXOOOXO ×z XOOXOX       =    XOOOOXOOOOOX  # multiplication\nXOOOOXOOOOOX /z XOO    =       XOXOXOOOX  # division\nXOXOXOOOX--z           =       XOXOXOOOO  # decrement\nXOXOXOOOO--z           =       XOXOOXOXO  # decrement\nXOXOOXOXO--z           =       XOXOOXOOX  # decrement\nXOXOOXOOX--z           =       XOXOOXOOO  # decrement\nXOXOOXOOO--z           =       XOXOOOXOX  # decrement\nXOXOOOXOX ×z XOXOOX    = XOXOXOOOOOXOXOX  # multiplication\nXOXOXOOOOOXOXOX /z XOO = XOOXOXOOOXOOX remainder XO  # division\n```"}]}
{"messages": [{"role": "user", "content": "Just as numbers can be represented in a positional notation as sums of multiples of the powers of ten (decimal) or two (binary); all the positive integers can be represented as the sum of one or zero times the distinct members of the Fibonacci series.\n\nRecall that the first six distinct Fibonacci numbers are: 1, 2, 3, 5, 8, 13.\n\nThe decimal number eleven can be written as 0\\*13 + 1\\*8 + 0\\*5 + 1\\*3 + 0\\*2 + 0\\*1 or 010100 in positional notation where the columns represent multiplication by a particular member of the sequence. Leading zeroes are dropped so that 11 decimal becomes 10100.\n\n10100 is not the only way to make 11 from the Fibonacci numbers however; 0\\*13 + 1\\*8 + 0\\*5 + 0\\*3 + 1\\*2 + 1\\*1 or 010011 would also represent decimal 11. For a true Zeckendorf number there is the added restriction that *no two consecutive Fibonacci numbers can be used* which leads to the former unique solution.\n\nTask\n\nGenerate and show here a table of the Zeckendorf number representations of the decimal numbers zero to twenty, in order.\n\nThe intention in this task to find the Zeckendorf form of an arbitrary integer. The Zeckendorf form can be iterated by some bit twiddling rather than calculating each value separately but leave that to another separate task.\n\nAlso see\n\n* OEIS A014417   for the the sequence of required results.\n* Brown's Criterion - Numberphile\n\nRelated task\n\n* Fibonacci sequence"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: rakudo version 2015.12\n\n```\nprintf \"%2d: %8s\\n\", $_, zeckendorf($_) for 0 .. 20;\n\nmulti zeckendorf(0) { '0' }\nmulti zeckendorf($n is copy) {\n    constant FIBS = (1,2, *+* ... *).cache;\n    [~] map {\n        $n -= $_ if my $digit = $n >= $_;\n        +$digit;\n    }, reverse FIBS ...^ * > $n;\n}\n\n```\n\nOutput:\n\n```\n 0:        0\n 1:        1\n 2:       10\n 3:      100\n 4:      101\n 5:     1000\n 6:     1001\n 7:     1010\n 8:    10000\n 9:    10001\n10:    10010\n11:    10100\n12:    10101\n13:   100000\n14:   100001\n15:   100010\n16:   100100\n17:   100101\n18:   101000\n19:   101001\n20:   101010\n```"}]}
{"messages": [{"role": "user", "content": "Some computer programming languages are not exactly consistent   (with other computer programming languages)  \n  \nwhen   *raising zero to the zeroth power*:     **00**\n\nTask\n\nShow the results of raising   zero   to the   zeroth   power.\n\nIf your computer language objects to      **0\\*\\*0**      or      **0^0**      at compile time,   you may also try something like:\n\n```\n           x = 0\n           y = 0\n           z = x**y\n           say  'z='  z\n\n```\n\n**Show the result here.**  \nAnd of course use any symbols or notation that is supported in your computer programming language for exponentiation.\n\nSee also\n\n* The Wiki entry: Zero to the power of zero.\n* The Wiki entry: Zero to the power of zero: History.\n* The MathWorld™ entry: exponent laws.\n  + Also, in the above MathWorld™ entry, see formula (**9**): \n\n    x\n\n    0\n    =\n    1\n    {\\displaystyle {\\displaystyle x^{0}=1}}\n    .\n* The OEIS entry: The special case of zero to the zeroth power"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Works with**: Rakudo version 2018.03\n\n```\nsay '    type         n      n**n  exp(n,n)';\nsay '--------  --------  --------  --------';\n\nfor 0, 0.0, FatRat.new(0), 0e0, 0+0i {\n    printf \"%8s  %8s  %8s  %8s\\n\", .^name, $_, $_**$_, exp($_,$_);\n}\n\n```\n\nOutput:\n\n```\n    type         n      n**n  exp(n,n)\n--------  --------  --------  --------\n     Int         0         1         1\n     Rat         0         1         1\n  FatRat         0         1         1\n     Num         0         1         1\n Complex      0+0i      1+0i      1+0i\n\n```"}]}
{"messages": [{"role": "user", "content": "This is an algorithm used to thin a black and white i.e. one bit per pixel images.\n\nFor example, with an input image of:\n\n```\n                                                           \n #################                   #############         \n ##################               ################         \n ###################            ##################         \n ########     #######          ###################         \n   ######     #######         #######       ######         \n   ######     #######        #######                       \n   #################         #######                       \n   ################          #######                       \n   #################         #######                       \n   ######     #######        #######                       \n   ######     #######        #######                       \n   ######     #######         #######       ######         \n ########     #######          ###################         \n ########     ####### ######    ################## ######  \n ########     ####### ######      ################ ######  \n ########     ####### ######         ############# ######  \n                                                           \n```\n\nIt produces the thinned output:\n\n```\n                                                           \n                                                           \n    # ##########                       #######             \n     ##        #                   ####       #            \n     #          #                 ##                       \n     #          #                #                         \n     #          #                #                         \n     #          #                #                         \n     ############               #                          \n     #          #               #                          \n     #          #                #                         \n     #          #                #                         \n     #          #                #                         \n     #                            ##                       \n     #                             ############            \n                       ###                          ###    \n                                                           \n                                                           \n```\n\nAlgorithm\n\nAssume black pixels are one and white pixels zero, and that the input image is a rectangular N by M array of ones and zeroes.\n\nThe algorithm operates on all black pixels P1 that can have eight neighbours.\n\nThe neighbours are, in order, arranged as:\n\n|  |  |  |\n| --- | --- | --- |\n| P9 | P2 | P3 |\n| P8 | **P1** | P4 |\n| P7 | P6 | P5 |\n\nObviously the boundary pixels of the image cannot have the full eight neighbours.\n\n* Define \n\n  A\n  (\n  P\n  1\n  )\n  {\\displaystyle {\\displaystyle A(P1)}}\n   = the number of transitions from white to black, (0 -> 1) in the sequence P2,P3,P4,P5,P6,P7,P8,P9,P2. (Note the extra P2 at the end - it is circular).\n* Define \n\n  B\n  (\n  P\n  1\n  )\n  {\\displaystyle {\\displaystyle B(P1)}}\n   = The number of black pixel neighbours of P1. ( = sum(P2 .. P9) )\n\nStep 1\n\nAll pixels are tested and pixels satisfying all the following conditions (simultaneously) are just noted at this stage.\n\n* (0) The pixel is black and has eight neighbours\n* (1) \n\n  2\n  <=\n  B\n  (\n  P\n  1\n  )\n  <=\n  6\n  {\\displaystyle {\\displaystyle 2<=B(P1)<=6}}\n* (2) A(P1) = 1\n* (3) At least one of P2 and P4 and P6 is white\n* (4) At least one of P4 and P6 and P8 is white\n\nAfter iterating over the image and collecting all the pixels satisfying all step 1 conditions, all these condition satisfying pixels are set to white.\n\nStep 2\n\nAll pixels are again tested and pixels satisfying all the following conditions are just noted at this stage.\n\n* (0) The pixel is black and has eight neighbours\n* (1) \n\n  2\n  <=\n  B\n  (\n  P\n  1\n  )\n  <=\n  6\n  {\\displaystyle {\\displaystyle 2<=B(P1)<=6}}\n* (2) A(P1) = 1\n* (3) At least one of P2 and P4 and **P8** is white\n* (4) At least one of **P2** and P6 and P8 is white\n\nAfter iterating over the image and collecting all the pixels satisfying all step 2 conditions, all these condition satisfying pixels are again set to white.\n\nIteration\n\nIf any pixels were set in this round of either step 1 or step 2 then all steps are repeated until no image pixels are so changed.\n\nTask\n\n1. Write a routine to perform Zhang-Suen thinning on an image matrix of ones and zeroes.\n2. Use the routine to thin the following image and show the output here on this page as either a matrix of ones and zeroes, an image, or an ASCII-art image of space/non-space characters.\n\n```\n          00000000000000000000000000000000\n          01111111110000000111111110000000\n          01110001111000001111001111000000\n          01110000111000001110000111000000\n          01110001111000001110000000000000\n          01111111110000001110000000000000\n          01110111100000001110000111000000\n          01110011110011101111001111011100\n          01110001111011100111111110011100\n          00000000000000000000000000000000\n\n```\n\nReference\n\n* Zhang-Suen Thinning Algorithm, Java Implementation by Nayef Reza.\n* \"Character Recognition Systems: A Guide for Students and Practitioners\" By Mohamed Cheriet, Nawwaf Kharma, Cheng-Lin Liu, Ching Suen"}, {"role": "assistant", "content": "(formerly Perl 6)\nSource image may be based on any characters whose low bits are 0 or 1 (which conveniently includes . and #).\n\n```\nmy $source = qq:to/EOD/;\n................................\n.#########.......########.......\n.###...####.....####..####......\n.###....###.....###....###......\n.###...####.....###.............\n.#########......###.............\n.###.####.......###....###......\n.###..####..###.####..####.###..\n.###...####.###..########..###..\n................................\nEOD\n\nmy @lines = ([.ords X+& 1] for $source.split(\"\\n\")); # The low bits Just Work.\nmy \\v = +@lines;\nmy \\h = +@lines[0];\nmy @black = flat @lines.map: *.values;   # Flatten to 1-dimensional.\n\nmy \\p8 = [-h-1, -h+0, -h+1,         # Flatland distances to 8 neighbors.\n           0-1,        0+1,\n           h-1,  h+0,  h+1].[1,2,4,7,6,5,3,0];   # (in cycle order)\n\n# Candidates have 8 neighbors and are known black\nmy @cand = grep { @black[$_] }, do\n    for 1..v-2 X 1..h-2 -> (\\y,\\x) { y*h + x }\n\nrepeat while my @goners1 or my @goners2 {\n    sub seewhite (\\w1,\\w2) {\n        sub cycles (@neighbors) { [+] @neighbors Z< @neighbors[].rotate }\n        sub blacks (@neighbors) { [+] @neighbors }\n\n        my @prior = @cand; @cand = ();\n\n        gather for @prior -> \\p {\n            my \\n = @black[p8 X+ p];\n            if cycles(n) == 1 and 2 <= blacks(n) <= 6 and n[w1].any == 0 and n[w2].any == 0\n                 { take p }\n            else { @cand.push: p }\n        }\n    }\n\n    @goners1 = seewhite (0,2,4), (2,4,6);\n    @black[@goners1] = 0 xx *;\n    say \"Ping: {[+] @black} remaining after removing \", @goners1;\n\n    @goners2 = seewhite (0,2,6), (0,4,6);\n    @black[@goners2] = 0 xx *;\n    say \"Pong: {[+] @black} remaining after removing \", @goners2;\n}\n\nsay @black.splice(0,h).join.trans('01' => '.#') while @black;\n\n```\n\nOutput:\n\n```\nPing: 66 remaining after removing 33 41 49 56 67 71 74 80 83 86 89 99 106 114 119 120 121 131 135 138 146 169 178 195 197 210 215 217 227 230 233 236 238 240 243 246 249 251 253 257 258 259 263 264 266 268 269 270 273 274 279 280 283 284 285\nPong: 47 remaining after removing 65 73 88 97 104 112 129 137 144 161 167 176 193 198 208 216 225 226 231\nPing: 45 remaining after removing 87 194\nPong: 45 remaining after removing \nPing: 45 remaining after removing \nPong: 45 remaining after removing \n................................\n..#######.........######........\n..#.....#........##.............\n..#......#.......#..............\n..#.....#........#..............\n..#####.#........#..............\n.......##........#..............\n........#....#...##....##...#...\n.........#.........####.........\n................................\n```"}]}
{"messages": [{"role": "user", "content": "Task\n\nProduce a zig-zag array.\n\nA   *zig-zag*   array is a square arrangement of the first   N2   natural numbers,   where the\n  \nnumbers increase sequentially as you zig-zag along the array's   anti-diagonals.\n\nFor a graphical representation, see   JPG zigzag   (JPG uses such arrays to encode images).\n\nFor example, given   **5**,   produce this array:\n\n```\n 0  1  5  6 14\n 2  4  7 13 15\n 3  8 12 16 21\n 9 11 17 20 22\n10 18 19 23 24\n\n```\n\nRelated tasks\n\n* Spiral matrix\n* Identity matrix\n* Ulam spiral (for primes)\n\nSee also\n\n* Wiktionary entry:   anti-diagonals"}, {"role": "assistant", "content": "(formerly Perl 6)\n\nUsing the same Turtle class as in the Spiral matrix task:\n\n```\nclass Turtle {\n    my @dv =  [0,-1], [1,-1], [1,0], [1,1], [0,1], [-1,1], [-1,0], [-1,-1];\n    my $points = 8; # 'compass' points of neighbors on grid: north=0, northeast=1, east=2, etc.\n \n    has @.loc = 0,0;\n    has $.dir = 0;\n    has %.world;\n    has $.maxegg;\n    has $.range-x;\n    has $.range-y;\n \n    method turn-left ($angle = 90) { $!dir -= $angle / 45; $!dir %= $points; }\n    method turn-right($angle = 90) { $!dir += $angle / 45; $!dir %= $points; }\n \n    method lay-egg($egg) {\n    %!world{~@!loc} = $egg;\n    $!maxegg max= $egg;\n    $!range-x minmax= @!loc[0];\n    $!range-y minmax= @!loc[1];\n    }\n \n    method look($ahead = 1) {\n    my $there = @!loc »+« @dv[$!dir] »*» $ahead;\n    %!world{~$there};\n    }\n \n    method forward($ahead = 1) {\n    my $there = @!loc »+« @dv[$!dir] »*» $ahead;\n    @!loc = @($there);\n    }\n \n    method showmap() {\n    my $form = \"%{$!maxegg.chars}s\";\n    my $endx = $!range-x.max;\n        for $!range-y.list X $!range-x.list -> ($y, $x) {\n        print (%!world{\"$x $y\"} // '').fmt($form);\n        print $x == $endx ?? \"\\n\" !! ' ';\n    }\n    }\n}\n\nsub MAIN(Int $size = 5) {\n    my $t = Turtle.new(dir => 1);\n    my $counter = 0;\n    for 1 ..^ $size -> $run {\n\tfor ^$run {\n\t    $t.lay-egg($counter++);\n\t    $t.forward;\n\t}\n\tmy $yaw = $run %% 2 ?? -1 !! 1;\n\t$t.turn-right($yaw * 135); $t.forward; $t.turn-right($yaw * 45);\n    }\n    for $size ... 1 -> $run {\n\tfor ^$run -> $ {\n\t    $t.lay-egg($counter++);\n\t    $t.forward;\n\t}\n\t$t.turn-left(180); $t.forward;\n\tmy $yaw = $run %% 2 ?? 1 !! -1;\n\t$t.turn-right($yaw * 45); $t.forward; $t.turn-left($yaw * 45);\n    }\n    $t.showmap;\n}\n```"}]}
{"messages": [{"role": "user", "content": "**Zsigmondy numbers** **n** to **a**, **b**, are the greatest divisor of **an - bn** that is coprime to **am - bm** for all positive integers **m < n**.\n\nE.G.\n\nSuppose we set **a** = **2** and **b** = **1**. *(**Zs(n,2,1)**)*\n\nFor each **n**, find the divisors of **an - bn** and return the largest that is coprime to all of **am - bm**, where **m** is each of the positive integers **1** to **n - 1**.\n\nWhen **n** = **4**, **24 - 14 = 15**. The divisors of **15** are **1, 3, 5,** and **15**.\n\nFor **m = 1, 2, 3** we get **2-1, 22-12, 23-13**, or **1, 3, 7**.\n\nThe divisors of **15** that are coprime to each are **5** and **1**, (***1** is always included*).\n\nThe largest coprime divisor is **5**, so **Zs(4,2,1) = 5**.\n\nWhen **n** = **6**, **26 - 16 = 63**; its divisors are **1, 3, 7, 9, 21, 63**. The largest divisor coprime to all of **1, 3, 7, 15, 31** is **1**, (***1** is always included*), so **Zs(6,2,1) = 1**.\n\nIf a particular **an - bn** is prime, then **Zs(n,a,b)** will be equal to that prime. **25 - 15 = 31** so **Zs(5,2,1) = 31**.\n\nTask\n\n* Write a general routine (function, procedure, whatever) to find the Zsigmondy number sequence given a set of radices.\n* Use that routine to generate the first several elements, (at least 10), for the following radix sets.\n\n:   * (2,1)\n    * (3,1)\n    * (4,1)\n    * (5,1)\n    * (6,1)\n    * (7,1)\n    * (3,2)\n    * (5,3)\n    * (7,3)\n    * (7,5)\n\nSee also\n\n* OEIS:A064078 - Zsigmondy numbers for a = 2, b = 1 * OEIS:A064077 - Zsigmondy numbers for a = 3, b = 1 * OEIS:A064080 - Zsigmondy numbers for a = 4, b = 1 * OEIS:A064081 - Zsigmondy numbers for a = 5, b = 1 * OEIS:A064082 - Zsigmondy numbers for a = 6, b = 1 * OEIS:A064083 - Zsigmondy numbers for a = 7, b = 1 * OEIS:A109325 - Zsigmondy numbers for a = 3, b = 2 * OEIS:A109347 - Zsigmondy numbers for a = 5, b = 3 * OEIS:A109348 - Zsigmondy numbers for a = 7, b = 3 * OEIS:A109349 - Zsigmondy numbers for a = 7, b = 5"}, {"role": "assistant", "content": "First twenty elements of each.\n\n```\nuse Prime::Factor;\n\nsub Zsigmondy ($a, $b) {\n    my @aexp = 1, * × $a … *;\n    my @bexp = 1, * × $b … *;\n    (1..∞).map: -> $n {\n        (@aexp[$n] - @bexp[$n]).&divisors.sort(-*).first: -> $d {\n            all (1..^$n).map: { (@aexp[$_] - @bexp[$_]) gcd $d == 1 }\n        }\n    }\n}\n\nfor '064078', (2,1), '064079', (3,1), '064080', (4,1), '064081', (5,1), '064082', (6,1),\n    '064083', (7,1), '109325', (3,2), '109347', (5,3), '109348', (7,3), '109349', (7,5)\n  -> $oeis, $seq {\n    say \"\\nA$oeis: Zsigmondy(n,$seq[0],$seq[1]):\\n\" ~ Zsigmondy(|$seq)[^20]\n}\n\n```\n\nOutput:\n\n```\nA064078: Zsigmondy(n,2,1):\n1 3 7 5 31 1 127 17 73 11 2047 13 8191 43 151 257 131071 19 524287 41\n\nA064079: Zsigmondy(n,3,1):\n2 1 13 5 121 7 1093 41 757 61 88573 73 797161 547 4561 3281 64570081 703 581130733 1181\n\nA064080: Zsigmondy(n,4,1):\n3 5 7 17 341 13 5461 257 1387 41 1398101 241 22369621 3277 49981 65537 5726623061 4033 91625968981 61681\n\nA064081: Zsigmondy(n,5,1):\n4 3 31 13 781 7 19531 313 15751 521 12207031 601 305175781 13021 315121 195313 190734863281 5167 4768371582031 375601\n\nA064082: Zsigmondy(n,6,1):\n5 7 43 37 311 31 55987 1297 46873 1111 72559411 1261 2612138803 5713 1406371 1679617 3385331888947 46441 121871948002099 1634221\n\nA064083: Zsigmondy(n,7,1):\n6 1 19 25 2801 43 137257 1201 39331 2101 329554457 2353 16148168401 102943 4956001 2882401 38771752331201 117307 1899815864228857 1129901\n\nA109325: Zsigmondy(n,3,2):\n1 5 19 13 211 7 2059 97 1009 11 175099 61 1586131 463 3571 6817 129009091 577 1161737179 4621\n\nA109347: Zsigmondy(n,5,3):\n2 1 49 17 1441 19 37969 353 19729 421 24325489 481 609554401 10039 216001 198593 381405156481 12979 9536162033329 288961\n\nA109348: Zsigmondy(n,7,3):\n4 5 79 29 4141 37 205339 1241 127639 341 494287399 2041 24221854021 82573 3628081 2885681 58157596211761 109117 2849723505777919 4871281\n\nA109349: Zsigmondy(n,7,5):\n2 3 109 37 6841 13 372709 1513 176149 1661 964249309 1801 47834153641 75139 3162961 3077713 115933787267041 30133 5689910849522509 3949201\n```"}]}
{"messages": [{"role": "user", "content": "Zumkeller numbers are the set of numbers whose divisors can be partitioned into two disjoint sets that sum to the same value. Each sum must contain divisor values that are not in the other sum, and all of the divisors must be in one or the other. There are no restrictions on *how* the divisors are partitioned, only that the two partition sums are equal.\n\nE.G.\n\n:   **6** is a Zumkeller number; The divisors **{1 2 3 6}** can be partitioned into two groups **{1 2 3}** and **{6}** that both sum to 6.\n\n:   **10** is not a Zumkeller number; The divisors **{1 2 5 10}** can not be partitioned into two groups in any way that will both sum to the same value.\n\n:   **12** is a Zumkeller number; The divisors **{1 2 3 4 6 12}** can be partitioned into two groups **{1 3 4 6}** and **{2 12}** that both sum to 14.\n\nEven Zumkeller numbers are common; odd Zumkeller numbers are much less so. For values below 10^6, there is *at least* one Zumkeller number in every 12 consecutive integers, and the vast majority of them are even. The odd Zumkeller numbers are very similar to the list from the task Abundant odd numbers; they are nearly the same except for the further restriction that the abundance (**A(n) = sigma(n) - 2n**), must be even: **A(n) mod 2 == 0**\n\nTask\n:   * Write a routine (function, procedure, whatever) to find Zumkeller numbers.\n    * Use the routine to find and display here, on this page, the first **220 Zumkeller numbers**.\n    * Use the routine to find and display here, on this page, the first **40 odd Zumkeller numbers**.\n    * Optional, stretch goal: Use the routine to find and display here, on this page, the first **40 odd Zumkeller numbers that don't end with 5**.\n\nSee Also\n\n:   * **OEIS:A083207 - Zumkeller numbers** to get an impression of different partitions **OEIS:A083206 Zumkeller partitions**\n    * **OEIS:A174865 - Odd Zumkeller numbers**\n\nRelated Tasks\n\n:   * **Abundant odd numbers**\n    * **Abundant, deficient and perfect number classifications**\n    * **Proper divisors** , **Factors of an integer**"}, {"role": "assistant", "content": "(formerly Perl 6)\n\n**Library:** ntheory\n\n```\nuse ntheory:from<Perl5> <factor is_prime>;\n\nsub zumkeller ($range)  {\n    $range.grep: -> $maybe {\n        next if $maybe < 3 or $maybe.&is_prime;\n        my @divisors = $maybe.&factor.combinations».reduce( &[×] ).unique.reverse;\n        next unless [and] @divisors > 2, @divisors %% 2, (my $sum = @divisors.sum) %% 2, ($sum /= 2) ≥ $maybe;\n        my $zumkeller = False;\n        if $maybe % 2 {\n            $zumkeller = True\n        } else {\n            TEST: for 1 ..^ @divisors/2 -> $c {\n                @divisors.combinations($c).map: -> $d {\n                    next if $d.sum != $sum;\n                    $zumkeller = True and last TEST\n                }\n            }\n        }\n        $zumkeller\n    }\n}\n\nsay \"First 220 Zumkeller numbers:\\n\" ~\n    zumkeller(^Inf)[^220].rotor(20)».fmt('%3d').join: \"\\n\";\n\nput \"\\nFirst 40 odd Zumkeller numbers:\\n\" ~\n    zumkeller((^Inf).map: * × 2 + 1)[^40].rotor(10)».fmt('%7d').join: \"\\n\";\n\n# Stretch. Slow to calculate. (minutes) \nput \"\\nFirst 40 odd Zumkeller numbers not divisible by 5:\\n\" ~\n    zumkeller(flat (^Inf).map: {my \\p = 10 * $_; p+1, p+3, p+7, p+9} )[^40].rotor(10)».fmt('%7d').join: \"\\n\";\n\n```\n\nOutput:\n\n```\nFirst 220 Zumkeller numbers:\n  6  12  20  24  28  30  40  42  48  54  56  60  66  70  78  80  84  88  90  96\n102 104 108 112 114 120 126 132 138 140 150 156 160 168 174 176 180 186 192 198\n204 208 210 216 220 222 224 228 234 240 246 252 258 260 264 270 272 276 280 282\n294 300 304 306 308 312 318 320 330 336 340 342 348 350 352 354 360 364 366 368\n372 378 380 384 390 396 402 408 414 416 420 426 432 438 440 444 448 456 460 462\n464 468 474 476 480 486 490 492 496 498 500 504 510 516 520 522 528 532 534 540\n544 546 550 552 558 560 564 570 572 580 582 588 594 600 606 608 612 616 618 620\n624 630 636 640 642 644 650 654 660 666 672 678 680 684 690 696 700 702 704 708\n714 720 726 728 732 736 740 744 750 756 760 762 768 770 780 786 792 798 804 810\n812 816 820 822 828 832 834 836 840 852 858 860 864 868 870 876 880 888 894 896\n906 910 912 918 920 924 928 930 936 940 942 945 948 952 960 966 972 978 980 984\n\nFirst 40 odd Zumkeller numbers:\n    945    1575    2205    2835    3465    4095    4725    5355    5775    5985\n   6435    6615    6825    7245    7425    7875    8085    8415    8505    8925\n   9135    9555    9765   10395   11655   12285   12705   12915   13545   14175\n  14805   15015   15435   16065   16695   17325   17955   18585   19215   19305\n\nFirst 40 odd Zumkeller numbers not divisible by 5:\n  81081  153153  171171  189189  207207  223839  243243  261261  279279  297297\n 351351  459459  513513  567567  621621  671517  729729  742203  783783  793611\n 812889  837837  891891  908523  960687  999999 1024947 1054053 1072071 1073709\n1095633 1108107 1145529 1162161 1198197 1224531 1270269 1307691 1324323 1378377\n```"}]}