Popular recipes tagged "recursion"

Permutations by recursive Heap's method (Batch)

2016-06-11T08:42:41-07:00

Batch recipe 580678 by Antoni Gual (permutation, recursion).

Setlocal / endlocal allow for recursion in batch. Values can be passed by value and by reference, the later can return a value to the caller.

Computing simple list functions recursively (Python)

2016-03-01T20:41:13-08:00

Python recipe 580617 by Vasudev Ram (algorithm, algorithms, lists, python, python2, recursion, recursive).

This recipe shows how to compute some simple list functions (functions that operate on lists) using simple recursive algorithms. Simple non-recursive algorithms exist for these tasks; this recipe is just for illustrative purposes. However, the principles described can be used for more complex recursive algorithms, for which non-recursive algorithms might be more complex than the recursive ones.

RecursionError exception: concise and informative output (Python)

2015-07-05T23:46:59-07:00

Python recipe 578660 by elazar (debugging, exception, handler, recursion). Revision 3.

Replaces the default exception hook with one that, upon "infinite recursion", removes the last cycle. This results in a significantly cleaner and shorter error message.

Usage: simply import <module> as _

For more details see the descussion here: https://mail.python.org/pipermail/python-ideas/2013-September/023190.html

Recursive Mandelbrot Generation (Python)

2013-08-11T03:46:46-07:00

Python recipe 578635 by Bill Pickett (mandelbrot, pygame, recursion). Revision 12.

This program recursively generates a Mandelbrot set using Python and PyGame. The size of the window must be a power of two or you will get rendering errors in the final image. It was written as an exercise in recursion, primarily to further my own understanding of that.

Recursive find and replace in all files in directory with regex (Python)

2013-03-21T12:33:44-07:00

Python recipe 578312 by ccpizza (directory, recursion, regular_expressions, replace).

Search and replace files recursively in a given directory. Accepts regular expressions as search and replacement patterns.

Example usage:

python find_replace_regex.py ".", "<span[^>]*>", "<div>", "*.html" backup

Note: On win32 the < and > symbols are interpreted by the shell as input/output redirection even when they are surrounded with single or double quotes, and therefore need to be escaped with the caret character ^.

Recursively print (nested) dictionaries (Python)

2012-04-04T15:20:42-07:00

Python recipe 578094 by Mauricio Dada Fonseca de Freitas (dictionary, print, recursion).

Snippet of code that uses recursion to print nested dictionaries. It does not sort the entries!

Permutation and combination using recursive generator (Python)

2011-10-04T05:44:19-07:00

Python recipe 577890 by Shao-chuan Wang (combinatorics, generators, permutation, recursion). Revision 2.

This recipes demonstrates how to use recursive generator to implement permutation and combination.

Recursive Functional State Machine (Python)

2011-05-20T13:46:48-07:00

Python recipe 577709 by Stefan Tunsch (functional, recursion, state_machine).

This is a simple state machine that takes a functional approach. It requires trampoline from pysistence.func to avoid the recursion limit.

Namedtuples are used to define the different states. globals() is used to reference the states. (This could also be done putting states into a separate module and getting them through getattr.)

In this recipe the functions called in the different states need to return a boolean, which defines the success or failure event.

Destroying Directories (Python)

2011-04-21T02:55:31-07:00

Python recipe 577670 by Stephen Chappell (delete, directory, recursion).

When files and directories need to be securely deleted, there are many tools in existence that people can turn to for their needs. While there are many ways one might go about manually deleting files and removing directories, this recipe provides a sample implementation of what may be considered throughout the process. This destructive command line program takes the path to a directory as a command line argument and does its best to render it and its contents unrecoverable. There are much better and inclusive applications than this one, but those wishing to write their own utilities may take some inspiration from this recipe while writing their own tools.

If there are any recommendation for this recipe or if anyone wishes to down-vote this recipe, please provide corrective criticism showing the the program's faults and give suggestions on how you would fix any problems that it might have.

converting numbers to their alphabetical style (Python)

2011-03-17T06:57:06-07:00

Python recipe 577607 by amir naghavi (algorithm, recursion, string). Revision 4.

converts numbers to alphabetical numbers

Recoursive File Moving (Python)

2010-09-28T19:01:24-07:00

Python recipe 577411 by shawn (files, recursion). Revision 3.

This script is placed in a location then run. All files underneath the root will be propagated to the top level, while deleting any old directory's.

Problems: If you have large files in nested folders you will be copying them multiple times.

p.s. shoulda used walk() but i'm newb

Minimalistic Memoization (Python)

2010-05-06T16:59:52-07:00

Python recipe 577219 by Ahmed El Deeb (caching, memoization, recursion).

Minimalistic Memoization in python, just works, doesn't take care of cleaning up the cache however.

Simple regex engine, elementary Python (Python)

2010-07-10T10:43:30-07:00

Python recipe 577251 by Joost Behrends (cached, parse, parsing, recursion, regular_expressions). Revision 40.

A short engine for testing against a regex, understanding the 3 common quantifiers ?,+,* (non-greedy) working on characters, ., [...], [^...], \s, \S, bracketed patterns and group designators \N. Accepts unicode objects and fixed-width encoded strings (but problems with eventual comparisons of trailing bytes in multi-byte utf-letters). Captures up to 10 groups ( (?:...) implemented), which can be used for back referencing and in xreplace(). Captured groups are accessible after the search in the global list xGroups. | is supported, but only in groups and needing nested=True. nested=False is making '(' and ')' common letters.

This is not about Python or for Python, there it has little use beside re. But regarding that re needs about 6,000 lines you might agree with the author, that these 176 lines are powerful. This was the reason to publish it as a recipe - as a kind of (fairly complete) minimal example of a regex tester and as an example for corresponding recursive structures in data (TokenListCache) and code.

Working on this improved the author's understanding of regular expressions - especially of their eventual "greed". "Greedy" quantifiers are a concept, which has to be explained seperately and is coming unexpected: Whoever is scanning a text for '<.*>', s/he will search SGML tags, not the whole text. Even with the star's "greediness" the code has to take care, that '.*' doesn't eat the whole text finding no match for '<.*>' at all. Thus the standard syntax with greedy quantifiers cannot be simpler to implement than this with its mere 3 lines 101, 111 and 121 preventing any greed. Perhaps it is faster - otherwise it is difficult to understand, why the concept "greed" is existing at all.

This engine might be useful here and then under circumstances with nothing else available. Its brevity eases translation to other languages and it can work with arbitrary characters for STAR or PERHAPS (for example).

Sudoku solver in functional-programming style (Python)

2010-04-23T12:35:13-07:00

Python recipe 577188 by Arnau Sanchez (functional, recursion, sudoku). Revision 10.

A simple brute-force Sudoku solver written in functional-programming style. This code is not aimed for speed, the goal is to write a clear, compact and (hopefully) pedagogical functional solution.

Recursive file/folder cleaner (Python)

2011-02-12T20:30:59-08:00

Python recipe 576643 by Alia Khouri (cleaner, cleaning, files, folder, pyc, recursion, svn). Revision 24.

This script recursively scans a given path and applies a cleaning 'action' to matching files and folders. By default files and folders matching the specified (.endswith) patterns are deleted. Alternatively, _quoted_ glob patterns can used with the '-g' or '--glob' option.

By design, the script lists targets and asks permission before applying cleaning actions. It should be easy to extend this script with further actions and also more intelligent pattern matching functions.

The getch (single key confirmation) functionality comes courtesy of http://code.activestate.com/recipes/134892/

To use it, place the script in your path and call it something like 'clean':

Usage: clean [options] patterns

        deletes files/folder patterns:
            clean .svn .pyc
            clean -p /tmp/folder .svn .csv .bzr .pyc
            clean -g "*.pyc"
            clean -ng "*.py"

        converts line endings from windows to unix:
            clean -e .py
            clean -e -p /tmp/folder .py

Options:
  -h, --help            show this help message and exit
  -p PATH, --path=PATH  set path
  -n, --negated         clean everything except specified patterns
  -e, --endings         clean line endings
  -g, --glob            clean with glob patterns
  -v, --verbose

Lazy, recursive generator function (Python)

2008-12-14T10:04:29-08:00

Python recipe 576585 by Don Sawatzky (algorithm, generator, lazy_evaluation, recursion). Revision 4.

This procedure was proposed as a challenge to Python and other languages as the most concise coding. See Icon programming on the web. This is a lazy, recursive generator. It can be implemented several ways in Python with lists, iteration, and recursion. However, the lists increase in size exponentially with each iteration and recursion plus they are saved in every recursion. This recipe develops a lazy generator function.

Matlab code for displaying 'struct' details (Python)

2008-09-05T13:31:54-07:00

Python recipe 576489 by Kaushik Ghose (matlab, recursion, structure, tree).

This code, when passed a MATLAB structure, will recursively go into it and print out the form of the struct.