christopher/rosetta-code · Datasets at Hugging Face

task_url stringlengths 30 116	task_name stringlengths 2 86	task_description stringlengths 0 14.4k	language_url stringlengths 2 53	language_name stringlengths 1 52	code stringlengths 0 61.9k
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#LFE	LFE	> (lists:reverse "asdf") "fdsa"
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#VBA	VBA	Public Function RepeatStr(aString As String, aNumber As Integer) As String Dim bString As String, i As Integer bString = "" For i = 1 To aNumber bString = bString & aString Next i RepeatStr = bString End Function Debug.Print RepeatStr("ha", 5)
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#VBScript	VBScript	' VBScript has a String() function that can repeat a character a given number of times ' but this only works with single characters (or the 1st char of a string): WScript.Echo String(10, "123") ' Displays "1111111111" ' To repeat a string of chars, you can use either of the following "hacks"... WScript.Echo Replace(Space(10), " ", "Ha") WScript.Echo Replace(String(10, "X"), "X", "Ha")
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#Batch_File	Batch File	@echo off for /f "skip=6 tokens=*" %%i in (file.txt) do ( set line7=%%i goto break ) :break echo Line 7 is: %line7% pause>nul
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#BBC_BASIC	BBC BASIC	filepath$ = @lib$ + "..\licence.txt" requiredline% = 7 file% = OPENIN(filepath$) IF file%=0 ERROR 100, "File could not be opened" FOR i% = 1 TO requiredline% IF EOF#file% ERROR 100, "File contains too few lines" INPUT #file%, text$ NEXT CLOSE #file% IF ASCtext$=10 text$ = MID$(text$,2) PRINT text$
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Red	Red	>> items: [1 "a" "c" 1 3 4 5 "c" 3 4 5] >> unique items == [1 "a" "c" 3 4 5]
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#REXX	REXX	/REXX program removes any duplicate elements (items) that are in a list (using a hash)./ $= '2 3 5 7 11 13 17 19 cats 222 -100.2 +11 1.1 +7 7. 7 5 5 3 2 0 4.4 2' /item list./ say 'original list:' $ say right( words($), 17, '─') 'words in the original list.' z=; @.= /initialize the NEW list & index list./ do j=1 for words($); y= word($, j) /process the words (items) in the list/ if @.y=='' then z= z y; @.y= . /Not duplicated? Add to Z list,@ array/ end /j/ say say 'modified list:' space(z) /stick a fork in it, we're all done. / say right( words(z), 17, '─') 'words in the modified list.'
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#QBasic	QBasic	f = FREEFILE filename$ = "file.txt" OPEN filename$ FOR BINARY AS #f WHILE NOT EOF(f) char$ = STR$(LOF(f)) GET #f, , char$ PRINT char$; WEND CLOSE #f
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#Racket	Racket	#lang racket ; This file contains utf-8 charachters: λ, α, γ ... (for ([c (in-port read-char (open-input-file "read-file.rkt"))]) (display c))
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#JavaScript	JavaScript	function millis() { // Gets current time in milliseconds. return (new Date()).getTime(); } /* Executes function 'func' n times, returns array of execution times. */ function benchmark(n, func, args) { var times = []; for (var i=0; i<n; i++) { var m = millis(); func.apply(func, args); times.push(millis() - m); } return times; }
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Liberty_BASIC	Liberty BASIC	input$ ="abcdefgABCDEFG012345" print input$ print ReversedStr$( input$) end function ReversedStr$(in$) for i =len(in$) to 1 step -1 ReversedStr$ =ReversedStr$ +mid$( in$, i, 1) next i end function
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Vedit_macro_language	Vedit macro language	Ins_Text("ha", COUNT, 5)
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Visual_Basic	Visual Basic	Public Function StrRepeat(s As String, n As Integer) As String Dim r As String, i As Integer r = "" For i = 1 To n r = r & s Next i StrRepeat = r End Function Debug.Print StrRepeat("ha", 5)
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#C	C	#include <unistd.h> #include <sys/types.h> #include <sys/mman.h> #include <sys/stat.h> #include <fcntl.h> #include <err.h> /* following code assumes all file operations succeed. In practice, * return codes from open, close, fstat, mmap, munmap all need to be * checked for error. / int read_file_line(const char path, int line_no) { struct stat s; char buf; off_t start = -1, end = -1; size_t i; int ln, fd, ret = 1; if (line_no == 1) start = 0; else if (line_no < 1){ warn("line_no too small"); return 0; / line_no starts at 1; less is error / } line_no--; / back to zero based, easier / fd = open(path, O_RDONLY); fstat(fd, &s); / Map the whole file. If the file is huge (up to GBs), OS will swap * pages in and out, and because search for lines goes sequentially * and never accesses more than one page at a time, penalty is low. * If the file is HUGE, such that OS can't find an address space to map * it, we got a real problem. In practice one would repeatedly map small * chunks, say 1MB at a time, and find the offsets of the line along the * way. Although, if file is really so huge, the line itself can't be * guaranteed small enough to be "stored in memory", so there. / buf = mmap(0, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0); / optional; if the file is large, tell OS to read ahead / madvise(buf, s.st_size, MADV_SEQUENTIAL); for (i = ln = 0; i < s.st_size && ln <= line_no; i++) { if (buf[i] != '\n') continue; if (++ln == line_no) start = i + 1; else if (ln == line_no + 1) end = i + 1; } if (start >= s.st_size \|\| start < 0) { warn("file does not have line %d", line_no + 1); ret = 0; } else { / do something with the line here, like write(STDOUT_FILENO, buf + start, end - start); or copy it out, or something */ } munmap(buf, s.st_size); close(fd); return ret; }
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Ring	Ring	list = ["Now", "is", "the", "time", "for", "all", "good", "men", "to", "come", "to", "the", "aid", "of", "the", "party."] for i = 1 to len(list) for j = i + 1 to len(list) if list[i] = list[j] del(list, j) j-- ok next next for n = 1 to len(list) see list[n] + " " next see nl
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Ruby	Ruby	ary = [1,1,2,1,'redundant',[1,2,3],[1,2,3],'redundant'] p ary.uniq # => [1, 2, "redundant", [1, 2, 3]]
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#Raku	Raku	.say while defined $_ = $*IN.getc;
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#REXX	REXX	/REXX program reads and displays a file char by char, returning 'EOF' when done. / parse arg iFID . /iFID: is the fileID to be read. / /* [↓] show the file's contents. / if iFID\=='' then do j=1 until x=='EOF' /J count's the file's characters. / x=getchar(iFID); y= /get a character or an 'EOF'. / if x>>' ' then y=x /display X if presentable. / say right(j, 12) 'character, (hex,char)' c2x(x) y end /j/ / [↑] only display X if not low hex/ exit /stick a fork in it, we're all done. / /──────────────────────────────────────────────────────────────────────────────────────*/ getchar: procedure; parse arg z; if chars(z)==0 then return 'EOF'; return charin(z)
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#Jsish	Jsish	#!/usr/bin/env jsish "use strict"; /* Rate counter, timer access, in Jsish / / System time in milliseconds / var runs = 0, newMs; function countJobsIsTheJob() { runs += 1; } var milliSeconds = strptime(); while ((newMs = strptime()) < (milliSeconds + 1000)) { countJobsIsTheJob(); } puts(runs, 'runs in', newMs - milliSeconds, 'ms'); / Builtin times test(callback, runs), result in microseconds */ function sleeper() { sleep(10); } var timer; for (var i = 1; i < 4; i++) { timer = times(sleeper, 100); puts(timer, 'μs to sleep 10 ms, 100 times'); }
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Lingo	Lingo	on reverse (str) res = "" repeat with i = str.length down to 1 put str.char[i] after res end repeat return res end
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Visual_Basic_.NET	Visual Basic .NET	Debug.Print(Replace(Space(5), " ", "Ha"))
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Visual_FoxPro	Visual FoxPro	? REPLICATE("HO", 3)
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#C.23	C#	using System; using System.IO; namespace GetLine { internal class Program { private static void Main(string[] args) { Console.WriteLine(GetLine(args[0], uint.Parse(args[1]))); } private static string GetLine(string path, uint line) { using (var reader = new StreamReader(path)) { try { for (uint i = 0; i <= line; i++) { if (reader.EndOfStream) return string.Format("There {1} less than {0} line{2} in the file.", line, ((line == 1) ? "is" : "are"), ((line == 1) ? "" : "s")); if (i == line) return reader.ReadLine(); reader.ReadLine(); } } catch (IOException ex) { return ex.Message; } catch (OutOfMemoryException ex) { return ex.Message; } } throw new Exception("Something bad happened."); } } }
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Run_BASIC	Run BASIC	a$ = "2 3 5 7 11 13 17 19 cats 222 -100.2 +11 1.1 +7 7. 7 5 5 3 2 0 4.4 2" for i = 1 to len(a$) a1$ = word$(a$,i) if a1$ = "" then exit for for i1 = 1 to len(b$) if a1$ = word$(b$,i1) then [nextWord] next i1 b$ = b$ + a1$ + " " [nextWord] next i print "Dups:";a$ print "No Dups:";b$
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#Ring	Ring	fp = fopen("C:\Ring\ReadMe.txt","r") r = fgetc(fp) while isstring(r) r = fgetc(fp) see r end fclose(fp)
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#Ruby	Ruby	File.open('input.txt', 'r:utf-8') do \|f\| f.each_char{\|c\| p c} end
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#Julia	Julia	dosomething() = sleep(abs(randn())) function runNsecondsworthofjobs(N) times = Vector{Float64}() totaltime = 0 runcount = 0 while totaltime < N t = @elapsed(dosomething()) push!(times, t) totaltime += t runcount += 1 end println("Ran job $runcount times, for total time of $totaltime seconds.") println("Average time per run was $(sum(times)/length(times)) seconds.") println("Individual times of the jobs in seconds were:") for t in times println(" $t") end end runNsecondsworthofjobs(5)
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#Kotlin	Kotlin	// version 1.1.3 typealias Func<T> = (T) -> T fun cube(n: Int) = n * n * n fun <T> benchmark(n: Int, func: Func<T>, arg: T): LongArray { val times = LongArray(n) for (i in 0 until n) { val m = System.nanoTime() func(arg) times[i] = System.nanoTime() - m } return times } fun main(args: Array<String>) { println("\nTimings (nanoseconds) : ") for (time in benchmark(10, ::cube, 5)) println(time) }
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#LiveCode	LiveCode	function reverseString S repeat with i = length(S) down to 1 put char i of S after R end repeat return R end reverseString
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Vlang	Vlang	// Repeat a string, in V // Tectonics: v run repeat-a-string.v module main import strings // starts here pub fn main() { // A strings module function to repeat strings println(strings.repeat_string("ha", 5)) // Another strings module function to repeat a byte // This indexes the string to get the first byte of the rune array println(strings.repeat("*"[0], 5)) }
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Wart	Wart	def (s * n) :case (string? s) with outstring repeat n pr s ("ha" * 5) => "hahahahaha"
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#C.2B.2B	C++	#include <string> #include <fstream> #include <iostream> int main( ) { std::cout << "Which file do you want to look at ?\n" ; std::string input ; std::getline( std::cin , input ) ; std::ifstream infile( input.c_str( ) , std::ios::in ) ; std::string file( input ) ; std::cout << "Which file line do you want to see ? ( Give a number > 0 ) ?\n" ; std::getline( std::cin , input ) ; int linenumber = std::stoi( input ) ; int lines_read = 0 ; std::string line ; if ( infile.is_open( ) ) { while ( infile ) { getline( infile , line ) ; lines_read++ ; if ( lines_read == linenumber ) { std::cout << line << std::endl ; break ; } } infile.close( ) ; if ( lines_read < linenumber ) std::cout << "No " << linenumber << " lines in " << file << " !\n" ; return 0 ; } else { std::cerr << "Could not find file " << file << " !\n" ; return 1 ; } }
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Rust	Rust	use std::collections::HashSet; use std::hash::Hash; fn remove_duplicate_elements_hashing<T: Hash + Eq>(elements: &mut Vec<T>) { let set: HashSet<_> = elements.drain(..).collect(); elements.extend(set.into_iter()); } fn remove_duplicate_elements_sorting<T: Ord>(elements: &mut Vec<T>) { elements.sort_unstable(); // order does not matter elements.dedup(); } fn main() { let mut sample_elements = vec![0, 0, 1, 1, 2, 3, 2]; println!("Before removal of duplicates : {:?}", sample_elements); remove_duplicate_elements_sorting(&mut sample_elements); println!("After removal of duplicates : {:?}", sample_elements); }
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#Run_BASIC	Run BASIC	open file.txt" for binary as #f numChars = 1 ' specify number of characters to read a$ = input$(#f,numChars) ' read number of characters specified b$ = input$(#f,1) ' read one character close #f
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#Rust	Rust	use std::{ convert::TryFrom, fmt::{Debug, Display, Formatter}, io::Read, }; pub struct ReadUtf8<I: Iterator> { source: std::iter::Peekable<I>, } impl<R: Read> From<R> for ReadUtf8<std::io::Bytes<R>> { fn from(source: R) -> Self { ReadUtf8 { source: source.bytes().peekable(), } } } impl<I, E> Iterator for ReadUtf8<I> where I: Iterator<Item = Result<u8, E>>, { type Item = Result<char, Error<E>>; fn next(&mut self) -> Option<Self::Item> { self.source.next().map(\|next\| match next { Ok(lead) => self.complete_char(lead), Err(e) => Err(Error::SourceError(e)), }) } } impl<I, E> ReadUtf8<I> where I: Iterator<Item = Result<u8, E>>, { fn continuation(&mut self) -> Result<u32, Error<E>> { if let Some(Ok(byte)) = self.source.peek() { let byte = *byte; return if byte & 0b1100_0000 == 0b1000_0000 { self.source.next(); Ok((byte & 0b0011_1111) as u32) } else { Err(Error::InvalidByte(byte)) }; } match self.source.next() { None => Err(Error::InputTruncated), Some(Err(e)) => Err(Error::SourceError(e)), Some(Ok(_)) => unreachable!(), } } fn complete_char(&mut self, lead: u8) -> Result<char, Error<E>> { let a = lead as u32; // Let's name the bytes in the sequence let result = if a & 0b1000_0000 == 0 { Ok(a) } else if lead & 0b1110_0000 == 0b1100_0000 { let b = self.continuation()?; Ok((a & 0b0001_1111) << 6 \| b) } else if a & 0b1111_0000 == 0b1110_0000 { let b = self.continuation()?; let c = self.continuation()?; Ok((a & 0b0000_1111) << 12 \| b << 6 \| c) } else if a & 0b1111_1000 == 0b1111_0000 { let b = self.continuation()?; let c = self.continuation()?; let d = self.continuation()?; Ok((a & 0b0000_0111) << 18 \| b << 12 \| c << 6 \| d) } else { Err(Error::InvalidByte(lead)) }; Ok(char::try_from(result?).unwrap()) } } #[derive(Debug, Clone)] pub enum Error<E> { InvalidByte(u8), InputTruncated, SourceError(E), } impl<E: Display> Display for Error<E> { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { match self { Self::InvalidByte(b) => write!(f, "invalid byte 0x{:x}", b), Self::InputTruncated => write!(f, "character truncated"), Self::SourceError(e) => e.fmt(f), } } } fn main() -> std::io::Result<()> { for (index, value) in ReadUtf8::from(std::fs::File::open("test.txt")?).enumerate() { match value { Ok(c) => print!("{}", c), Err(e) => { print!("\u{fffd}"); eprintln!("offset {}: {}", index, e); } } } Ok(()) }
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#Liberty_BASIC	Liberty BASIC	Print "Rate counter" print "Precision: system clock, ms "; t0=time$("ms") while time$("ms")=t0 'busy loop till click ticks wend print time$("ms")-t0 print Print "Run jobs N times, report every time" Print "After that, report average time" N=10 t00=time$("ms") for i = 1 to 10 scan t0=time$("ms") 'any code we want to measure goes here res = testFunc() 'end of measured code t1=time$("ms") ElapsedTime = t1-t0 print "Job #";i;" Elapsed time, ms ";ElapsedTime, 1000/ElapsedTime; " ticks per second" next print "---------------------------------" print "Average time, ms, is ";(t1-t00)/N, 1000/((t1-t00)/N); " ticks per second" print print "Run jobs for not less then N seconds (if time up, it'll finish last job)" print "After that, report average time" NSec=5 i = 0 t00=time$("ms") while time$("ms")<t00+NSec*1000 scan i = i+1 t0=time$("ms") 'any code we want to measure goes here res = testFunc() 'end of measured code t1=time$("ms") ElapsedTime = t1-t0 print "Job #";i;" Elapsed time, ms ";ElapsedTime, 1000/ElapsedTime; " ticks per second" wend print "---------------------------------" print "Average time, ms, is ";(t1-t00)/i, 1000/((t1-t00)/i); " ticks per second" end function testFunc() s=0 for i = 1 to 30000 s=s+sin(i)/30000 next testFunc = s end function
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#LLVM	LLVM	; This is not strictly LLVM, as it uses the C library function "printf". ; LLVM does not provide a way to print values, so the alternative would be ; to just load the string into memory, and that would be boring. ; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps $"main.printf" = comdat any @main.str = private unnamed_addr constant [12 x i8] c"Hello world\00", align 1 @"main.printf" = linkonce_odr unnamed_addr constant [4 x i8] c"%s\0A\00", comdat, align 1 define void @reverse(i64, i8) { %3 = alloca i8, align 8 ; allocate str (local) %4 = alloca i64, align 8 ; allocate len (local) %5 = alloca i64, align 8 ; allocate i %6 = alloca i64, align 8 ; allocate j %7 = alloca i8, align 1 ; allocate t store i8* %1, i8** %3, align 8 ; set str (local) to the parameter str store i64 %0, i64* %4, align 8 ; set len (local) to the paremeter len store i64 0, i64* %5, align 8 ; i = 0 %8 = load i64, i64* %4, align 8 ; load len %9 = sub i64 %8, 1 ; decrement len store i64 %9, i64* %6, align 8 ; j = br label %loop loop: %10 = load i64, i64* %5, align 8 ; load i %11 = load i64, i64* %6, align 8 ; load j %12 = icmp ult i64 %10, %11 ; i < j br i1 %12, label %loop_body, label %exit loop_body: %13 = load i8, i8* %3, align 8 ; load str %14 = load i64, i64* %5, align 8 ; load i %15 = getelementptr inbounds i8, i8* %13, i64 %14 ; address of str[i] %16 = load i8, i8* %15, align 1 ; load str[i] store i8 %16, i8* %7, align 1 ; t = str[i] %17 = load i64, i64* %6, align 8 ; load j %18 = getelementptr inbounds i8, i8* %13, i64 %17 ; address of str[j] %19 = load i8, i8* %18, align 1 ; load str[j] %20 = getelementptr inbounds i8, i8* %13, i64 %14 ; address of str[i] store i8 %19, i8* %20, align 1 ; str[i] = str[j] %21 = load i8, i8* %7, align 1 ; load t %22 = getelementptr inbounds i8, i8* %13, i64 %17 ; address of str[j] store i8 %21, i8* %22, align 1 ; str[j] = t ;-- loop increment %23 = load i64, i64* %5, align 8 ; load i %24 = add i64 %23, 1 ; increment i store i64 %24, i64* %5, align 8 ; store i %25 = load i64, i64* %6, align 8 ; load j %26 = add i64 %25, -1 ; decrement j store i64 %26, i64* %6, align 8 ; store j br label %loop exit: ret void } define i32 @main() { ;-- char str[] %1 = alloca [12 x i8], align 1 ;-- memcpy(str, "Hello world") %2 = bitcast [12 x i8]* %1 to i8* call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @main.str, i32 0, i32 0), i64 12, i32 1, i1 false) ;-- printf("%s\n", str) %3 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0 %4 = call i32 (i8, ...) @printf(i8 getelementptr inbounds ([4 x i8], [4 x i8]* @"main.printf", i32 0, i32 0), i8* %3) ;-- %7 = strlen(str) %5 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0 %6 = call i64 @strlen(i8* %5) ;-- reverse(%6, str) call void @reverse(i64 %6, i8* %5) ;-- printf("%s\n", str) %7 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0 %8 = call i32 (i8, ...) @printf(i8 getelementptr inbounds ([4 x i8], [4 x i8]* @"main.printf", i32 0, i32 0), i8* %7) ;-- end of main ret i32 0 } ;--- The declaration for the external C printf function. declare i32 @printf(i8, ...) ; Function Attrs: argmemonly nounwind declare void @llvm.memcpy.p0i8.p0i8.i64(i8 nocapture writeonly, i8* nocapture readonly, i64, i32, i1) declare i64 @strlen(i8*)
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Wortel	Wortel	@join "" @rep 5 "ha" ; returns "hahahahaha"
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Wren	Wren	System.print("ha" * 5)
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#Clojure	Clojure	(defn read-nth-line "Read line-number from the given text file. The first line has the number 1." [file line-number] (with-open [rdr (clojure.java.io/reader file)] (nth (line-seq rdr) (dec line-number))))
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Scala	Scala	val list = List(1,2,3,4,2,3,4,99) val l2 = list.distinct // l2: scala.List[scala.Int] = List(1,2,3,4,99) val arr = Array(1,2,3,4,2,3,4,99) val arr2 = arr.distinct // arr2: Array[Int] = Array(1, 2, 3, 4, 99)
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#Seed7	Seed7	$ include "seed7_05.s7i"; include "utf8.s7i"; const proc: main is func local var file: inFile is STD_NULL; var char: ch is ' '; begin OUT := STD_UTF8_OUT; inFile := openUtf8("readAFileCharacterByCharacterUtf8.in", "r"); if inFile <> STD_NULL then while hasNext(inFile) do ch := getc(inFile); writeln("got character " <& ch <& " [U+" <& ord(ch) radix 16 <& "]"); end while; close(inFile); end if; end func;
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#Sidef	Sidef	var file = File('input.txt') # the input file contains: "aă€⼥" var fh = file.open_r # equivalent with: file.open('<:utf8') fh.each_char { \|char\| printf("got character #{char} [U+%04x]\n", char.ord) }
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#Mathematica.2FWolfram_Language	Mathematica/Wolfram Language	jobRateCounted[fn_,Y_Integer]:=First[AbsoluteTiming[Do[fn,{Y}]]/Y; SetAttributes[jobRateCounted,HoldFirst] jobRatePeriod[fn_,time_]:=Block[{n=0},TimeConstrained[While[True,fn;n++]];n/time]; SetAttributes[jobRatePeriod,HoldFirst]
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#Nim	Nim	import sugar, std/monotimes, times type Func[T] = (T) -> T func cube(n: int): int = n * n * n proc benchmark[T](n: int; f: Func[T]; arg: T): seq[Duration] = result.setLen(n) for i in 0..<n: let m = getMonoTime() discard f(arg) result[i] = getMonoTime() - m echo "Timings (nanoseconds):" for time in benchmark(10, cube, 5): echo time.inNanoseconds
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Logo	Logo	print reverse "cat ; tac
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#XPL0	XPL0	cod T=12; int I; for I gets 1,5 do T(0,"ha")
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Yorick	Yorick	array("ha", 5)(sum)
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#Common_Lisp	Common Lisp	(defun read-nth-line (file n &aux (line-number 0)) "Read the nth line from a text file. The first line has the number 1" (assert (> n 0) (n)) (with-open-file (stream file) (loop for line = (read-line stream nil nil) if (and (null line) (< line-number n)) do (error "file ~a is too short, just ~a, not ~a lines long" file line-number n) do (incf line-number) if (and line (= line-number n)) do (return line))))
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Scheme	Scheme	(define (remove-duplicates l) (cond ((null? l) '()) ((member (car l) (cdr l)) (remove-duplicates (cdr l))) (else (cons (car l) (remove-duplicates (cdr l)))))) (remove-duplicates '(1 2 1 3 2 4 5))
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#Smalltalk	Smalltalk	\|utfStream\| utfStream := 'input' asFilename readStream asUTF8EncodedStream. [utfStream atEnd] whileFalse:[ Transcript showCR:'got char ',utfStream next. ]. utfStream close.
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#Tcl	Tcl	set ch [read $channel 1]
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#OxygenBasic	OxygenBasic	'======== 'TIME API '======== 'http://msdn.microsoft.com/en-us/library/windows/desktop/ms724950(v=vs.85).aspx extern lib "kernel32.dll" type SYSTEMTIME WORD wYear WORD wMonth WORD wDayOfWeek WORD wDay WORD wHour WORD wMinute WORD wSecond WORD wMilliseconds end type void GetSystemTime(SYSTEMTIMEt) void GetLocalTime(SYSTEMTIMEt) void QueryPerformanceCounter(quadc) void QueryPerformanceFrequency(quadfreq) void Sleep(sys millisecods) end extern String WeekDay[7]={"Sunday","Monday","Tuesday","Wednesday", "Thursday","Friday","Saturday"} String MonthName[12]={"January","February","March","April","May","June", "July","August","September","October","November","December"} '============== Class Jobrecord '============== has SYSTEMTIME stt has SYSTEMTIME fin quad countA quad CountB quad freq sys serial method pad(string s) as string method=s if len(method)<2 then method="0"+method end method method ShowDateTime(sys a,f) as string SYSTEMTIME *t if a then @t=@fin else @t=@stt end if ' String month=pad(str t.wMonth) String day=pad(str t.wDay) if f=0 then return "" t.wYear "-" month "-" day " "+ pad(t.wHour) ":" pad(t.wMinute) ":" pad(t.wSecond) ":" t.wMilliSeconds elseif f=1 return WeekDay[t.wDayOfWeek+1 and 7 ] " " + MonthName[t.wMonth and 31] " " day " " t.wYear end if end method method Start() QueryPerformanceCounter countA QueryPerformanceFrequency freq serial++ GetLocalTime stt end method method Finish() GetLocalTime fin QueryPerformanceCounter countB end method method ShowDuration() as string return str((countB-countA)/freq,6) 'seconds with microsecond resolution end method method report() as string string tab=chr(9), cr=chr(13)+chr(10) method="Job:" tab serial cr + "Duration:" tab ShowDuration() cr + "Start: " tab ShowDateTime(0,0) cr + "Finish:" tab ShowDateTime(1,0) cr + ShowDateTime(1,1) cr end method end class '#recordof JobRecord '==== 'TEST '==== JobRecord JR JR.start sleep 100 'JOB! JR.finish print JR.Report 'putfile "s.txt",JR.Report ' 'Job: 1 'Duration: 0.099026 'Start: 2012-07-01 00:52:36:874 'Finish: 2012-07-01 00:52:36:974 'Sunday July 01 2012
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Lua	Lua	theString = theString:reverse()
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Z80_Assembly	Z80 Assembly	PrintChar equ &BB5A ;Amstrad CPC BIOS call, prints the ascii code in the accumulator to the screen. org &8000 ld b,5 ; repeat 5 times loop: call PrintImmediate byte "ha",0 djnz loop ret ; return to basic ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PrintImmediate: pop hl ; get the return address into HL, it's the start of the embedded string. call PrintString ; inc hl ; if your strings are null-terminated you can omit this, since a 0 equals the "NOP" instruction jp (hl) ; acts as a ret, returning execution to the instruction just after the embedded string. PrintString: ld a,(hl) ; read in a character from the string or a ; if your strings are null-terminated you can use this as a shortcut, otherwise use the compare instruction ret z ; exit once the terminator is reached. call PrintChar ; BIOS call, all regs are preserved. inc hl ; next char jr PrintString ; back to start.
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#D	D	void main() { import std.stdio, std.file, std.string; auto file_lines = readText("input.txt").splitLines(); //file_lines becomes an array of strings, each line is one element writeln((file_lines.length > 6) ? file_lines[6] : "line not found"); }
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Seed7	Seed7	$ include "seed7_05.s7i"; const proc: main is func local const array integer: data is [] (1, 3, 2, 9, 1, 2, 3, 8, 8, 1, 0, 2); var set of integer: dataSet is (set of integer).value; var integer: number is 0; begin for number range data do incl(dataSet, number); end for; writeln(dataSet); end func;
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#Wren	Wren	import "io" for File File.open("input.txt") { \|file\| var offset = 0 var char = "" // stores each byte read till we have a complete UTF encoded character while(true) { var b = file.readBytes(1, offset) if (b == "") return // end of stream char = char + b if (char.codePoints[0] >= 0) { // a UTF encoded character is complete System.write(char) // print it char = "" // reset store } offset = offset + 1 } }
http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8	Read a file character by character/UTF8	Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line	#zkl	zkl	fcn readUTF8c(chr,s=""){ // transform UTF-8 character stream s+=chr; try{ s.len(8); return(s) } catch{ if(s.len()>6) throw(__exception) } // 6 bytes max for UTF-8 return(Void.Again,s); // call me again with s & another character }
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#PARI.2FGP	PARI/GP	a=0; b=0; for(n=1,20000000, a=a+gettime(); if(a>60000,print(b);a=0;b=0); '''code to test''' b=b+1; a=a+gettime(); if(a>60000,print(b);a=0;b=0) )
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#M2000_Interpreter	M2000 Interpreter	Module ReverseString { a$="as⃝df̅" Print Len(a$), len.disp(a$) Let i=1, j=Len(a$) z$=String$(" ",j) j++ do { k$=mid$(a$, i, 1) if i<len(a$) then { while len.disp(k$+mid$(a$, i+1,1)) =len.disp(k$) { k$+=mid$(a$, i+1,1) i++ if i>len(a$) then exit j-- } j-- insert j, len(k$) Z$=K$ } else j-- :Insert j,1 z$=k$ if i>=len(a$) then exit i++ } Always Print len(z$), len.disp(z$) Print z$="f̅ds⃝a" Print z$ } ReverseString
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#zig	zig	const laugh = "ha" ** 5;
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#Delphi	Delphi	program Read_a_specific_line_from_a_file; {$APPTYPE CONSOLE} uses System.SysUtils; function ReadLine(position: Cardinal; FileName: TFileName): string; begin Result := ''; if not FileExists(FileName) then raise Exception.Create('Error: File does not exist.'); var F: TextFile; var line: string; AssignFile(F, FileName); Reset(F); for var _ := 1 to position do begin if Eof(F) then begin CloseFile(F); raise Exception.Create(Format('Error: The file "%s" is too short. Cannot read line %d', [FileName, position])); end; Readln(F, line); end; CloseFile(F); Result := line; end; begin Writeln(ReadLine(7, 'test')); Readln; end.
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#SETL	SETL	items := [0,7,6,6,4,9,7,1,2,3,2]; print(unique(items));
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#Perl	Perl	use Benchmark; timethese COUNT,{ 'Job1' => &job1, 'Job2' => &job2 }; sub job1 { ...job1 code... } sub job2 { ...job2 code... }
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#M4	M4	define(`invert',`ifelse(len(`$1'),0,,`invert(substr(`$1',1))'`'substr(`$1',0,1))')
http://rosettacode.org/wiki/Repeat_a_string	Repeat a string	Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#zkl	zkl	"ha" * 5 # --> "hahahahaha"
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#Elixir	Elixir	defmodule LineReader do def get_line(filename, line) do File.stream!(filename) \|> Stream.with_index \|> Stream.filter(fn {_value, index} -> index == line-1 end) \|> Enum.at(0) \|> print_line end defp print_line({value, _line_number}), do: String.trim(value) defp print_line(_), do: {:error, "Invalid Line"} end
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#SETL4	SETL4	set = new('set') * Add all the elements of the array to the set. add(set,array)
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#Phix	Phix	procedure task_to_measure() sleep(0.1) end procedure printf(1,"method 1: calculate reciprocal of elapsed time:\n") for trial=1 to 3 do atom t=time() task_to_measure() t = time()-t string r = iff(t?sprintf("%g",1/t):"inf") printf(1,"rate = %s per second\n",{r}) end for printf(1,"method 2: count completed tasks in one second:\n") for trial=1 to 3 do integer runs=0 atom finish=time()+1 while true do task_to_measure() if time()>=finish then exit end if runs += 1 end while printf(1,"rate = %d per second\n",runs) end for
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Maclisp	Maclisp	(readlist (reverse (explode "my-string")))
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#Erlang	Erlang	-module( read_a_specific_line ). -export( [from_file/2, task/0] ). from_file( File, N ) -> line_nr( N, read_a_file_line_by_line:into_list(File) ). task() -> Lines = read_a_file_line_by_line:into_list( "read_a_specific_line.erl" ), Line_7 = line_nr( 7, Lines ), Line_7. line_nr( N, Lines ) -> try case lists:nth( N, Lines ) of "\n" -> erlang:exit( empty_line ) ; Line -> Line end catch _Type:Error0 -> Error = line_nr_error( Error0 ), io:fwrite( "Error: ~p~n", [Error] ), erlang:exit( Error ) end. line_nr_error( function_clause ) -> too_few_lines_in_file; line_nr_error( Error ) -> Error.
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Sidef	Sidef	var ary = [1,1,2,1,'redundant',[1,2,3],[1,2,3],'redundant']; say ary.uniq.dump; say ary.last_uniq.dump;
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#Phixmonti	Phixmonti	100000 var iterations 2 4 2 tolist for msec var a iterations for over 2 power + drop endfor msec a - var dif "take " print dif print " secs" print " or " print iterations dif / print " sums per second" print nl endfor
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Maple	Maple	> StringTools:-Reverse( "foo" ); "oof"
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#F.23	F#	open System open System.IO [<EntryPoint>] let main args = let n = Int32.Parse(args.[1]) - 1 use r = new StreamReader(args.[0]) let lines = Seq.unfold ( fun (reader : StreamReader) -> if (reader.EndOfStream) then None else Some(reader.ReadLine(), reader)) r let line = Seq.nth n lines // Seq.nth throws an ArgumentException, // if not not enough lines available Console.WriteLine(line) 0
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Slate	Slate	[\|:s\| #(1 2 3 4 1 2 3 4) >> s] writingAs: Set. "==> {"Set traitsWindow" 1. 2. 3. 4}"
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#PicoLisp	PicoLisp	(prin "Hit a key ... ") (key) (prinl) (let Usec (usec) (prin "Hit another key ... ") (key) (prinl) (prinl "This took " (format (- (usec) Usec) 6) " seconds") )
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Mathematica.2FWolfram_Language	Mathematica/Wolfram Language	StringReverse["asdf"]
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#Factor	Factor	USING: continuations fry io io.encodings.utf8 io.files kernel math ; IN: rosetta-code.nth-line : nth-line ( path encoding n -- str/f ) [ f ] 3dip '[ [ _ [ drop readln [ return ] unless* ] times ] with-return ] with-file-reader ; : nth-line-demo ( -- ) "input.txt" utf8 7 nth-line [ "line not found" ] unless* print ; MAIN: nth-line-demo
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Smalltalk	Smalltalk	"Example of creating a collection" \|a\| a := #( 1 1 2 'hello' 'world' #symbol #another 2 'hello' #symbol ). a asSet.
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#PowerShell	PowerShell	[datetime]$start = Get-Date [int]$count = 3 [timespan[]]$times = for ($i = 0; $i -lt $count; $i++) { Measure-Command {0..999999 \| Out-Null} } [datetime]$end = Get-Date $rate = [PSCustomObject]@{ StartTime = $start EndTime = $end Duration = ($end - $start).TotalSeconds TimesRun = $count AverageRunTime = ($times.TotalSeconds \| Measure-Object -Average).Average } $rate \| Format-List
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#MATLAB	MATLAB	>> fliplr(['She told me that she spoke English and I said great. '... 'Grabbed her hand out the club and I said let''s skate.']) ans = .etaks s'tel dias I dna bulc eht tuo dnah reh debbarG .taerg dias I dna hsilgnE ekops ehs taht em dlot ehS
http://rosettacode.org/wiki/Ray-casting_algorithm	Ray-casting algorithm	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) Given a point and a polygon, check if the point is inside or outside the polygon using the ray-casting algorithm. A pseudocode can be simply: count ← 0 foreach side in polygon: if ray_intersects_segment(P,side) then count ← count + 1 if is_odd(count) then return inside else return outside Where the function ray_intersects_segment return true if the horizontal ray starting from the point P intersects the side (segment), false otherwise. An intuitive explanation of why it works is that every time we cross a border, we change "country" (inside-outside, or outside-inside), but the 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). So 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. Looking 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). So the problematic points are those inside the white area (the box delimited by the points A and B), like P4. Let 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). Points 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. An algorithm for the previous speech could be (if P is a point, Px is its x coordinate): ray_intersects_segment: P : the point from which the ray starts A : the end-point of the segment with the smallest y coordinate (A must be "below" B) B : the end-point of the segment with the greatest y coordinate (B must be "above" A) if Py = Ay or Py = By then Py ← Py + ε end if if Py < Ay or Py > By then return false else if Px >= max(Ax, Bx) then return false else if Px < min(Ax, Bx) then return true else if Ax ≠ Bx then m_red ← (By - Ay)/(Bx - Ax) else m_red ← ∞ end if if Ax ≠ Px then m_blue ← (Py - Ay)/(Px - Ax) else m_blue ← ∞ end if if m_blue ≥ m_red then return true else return false end if end if end if (To avoid the "ray on vertex" problem, the point is moved upward of a small quantity ε.)	#11l	11l	T Pt Float x, y F (x, y) .x = x .y = y F String() R ‘Pt(x=#., y=#.)’.format(.x, .y) T Edge Pt a, b F (a, b) .a = a .b = b F String() R ‘Edge(a=#., b=#.)’.format(.a, .b) T Poly String name [Edge] edges F (name, edges) .name = name .edges = edges V _eps = 0.00001 V _huge = 1e+100 V _tiny = 1e-100 F rayintersectseg(=p, edge) V a = edge.a V b = edge.b I a.y > b.y swap(&a, &b) I p.y == a.y \| p.y == b.y p = Pt(p.x, p.y + :_eps) V intersect = 0B I (p.y > b.y \| p.y < a.y) \| (p.x > max(a.x, b.x)) R 0B I p.x < min(a.x, b.x) intersect = 1B E Float m_red, m_blue I abs(a.x - b.x) > :_tiny m_red = (b.y - a.y) / Float(b.x - a.x) E m_red = :_huge I abs(a.x - p.x) > :_tiny m_blue = (p.y - a.y) / Float(p.x - a.x) E m_blue = :_huge intersect = m_blue >= m_red R intersect F ispointinside(p, poly) R sum(poly.edges.map(edge -> Int(rayintersectseg(@p, edge)))) % 2 == 1 F polypp(poly) print("\n Polygon(name='#.', edges=(".format(poly.name)) print(‘ ’(poly.edges.map(e -> String(e)).join(",\n ")"\n ))")) V polys = [ Poly(name' ‘square’, edges' [Edge(Pt(0, 0), Pt(10, 0)), Edge(Pt(10, 0), Pt(10, 10)), Edge(Pt(10, 10), Pt(0, 10)), Edge(Pt(0, 10), Pt(0, 0))]), Poly(name' ‘square_hole’, edges' [Edge(Pt(0, 0), Pt(10, 0)), Edge(Pt(10, 0), Pt(10, 10)), Edge(Pt(10, 10), Pt(0, 10)), Edge(Pt(0, 10), Pt(0, 0)), Edge(Pt(2.5, 2.5), Pt(7.5, 2.5)), Edge(Pt(7.5, 2.5), Pt(7.5, 7.5)), Edge(Pt(7.5, 7.5), Pt(2.5, 7.5)), Edge(Pt(2.5, 7.5), Pt(2.5, 2.5))]), Poly(name' ‘strange’, edges' [Edge(Pt(0, 0), Pt(2.5, 2.5)), Edge(Pt(2.5, 2.5), Pt(0, 10)), Edge(Pt(0, 10), Pt(2.5, 7.5)), Edge(Pt(2.5, 7.5), Pt(7.5, 7.5)), Edge(Pt(7.5, 7.5), Pt(10, 10)), Edge(Pt(10, 10), Pt(10, 0)), Edge(Pt(10, 0), Pt(2.5, 2.5))]), Poly(name' ‘exagon’, edges' [Edge(Pt(3, 0), Pt(7, 0)), Edge(Pt(7, 0), Pt(10, 5)), Edge(Pt(10, 5), Pt(7, 10)), Edge(Pt(7, 10), Pt(3, 10)), Edge(Pt(3, 10), Pt(0, 5)), Edge(Pt(0, 5), Pt(3, 0))])] V testpoints = [Pt(5, 5), Pt(5, 8), Pt(-10, 5), Pt(0, 5), Pt(10, 5), Pt(8, 5), Pt(10, 10)] print("\n TESTING WHETHER POINTS ARE WITHIN POLYGONS") L(poly) polys polypp(poly) print(‘ ’testpoints[0.<3].map(p -> ‘#.: #.’.format(p, I ispointinside(p, @poly) {‘True’} E ‘False’)).join("\t")) print(‘ ’testpoints[3.<6].map(p -> ‘#.: #.’.format(p, I ispointinside(p, @poly) {‘True’} E ‘False’)).join("\t")) print(‘ ’testpoints[6.. ].map(p -> ‘#.: #.’.format(p, I ispointinside(p, @poly) {‘True’} E ‘False’)).join("\t"))
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#Fortran	Fortran	MODULE SAMPLER !To sample a record from a file. SAM00100 CONTAINS SAM00200 CHARACTER20 FUNCTION GETREC(N,F,IS) !Returns a status. SAM00300 Careful. Some compilers get confused over the function name's usage. SAM00400 INTEGER N !The desired record number. SAM00500 INTEGER F !Of this file. SAM00600 CHARACTER() IS !Stashed here. SAM00700 INTEGER I,L !Assistants. SAM00800 IS = "" !Clear previous content, even if null...SAM00900 IF (N.LE.0) THEN !Start on errors. SAM01000 WRITE (GETREC,1) "!No record",N !Could never be found. SAM01100 1 FORMAT (A,1X,I0) !Message, number. SAM01200 ELSE IF (F.LE.0) THEN !Obviously wrong? SAM01300 WRITE (GETREC,1) "!No unit number",F!Positive is valid. SAM01400 ELSE IF (LEN(IS).LE.0) THEN !Space awaits? SAM01500 WRITE (GETREC,1) "!String size",LEN(IS) !Nope. SAM01600 ELSE !Otherwise, there is hope. SAM01700 REWIND (F) !Clarify the file position. SAM01800 DO I = 1,N - 1 !Grind up to the desired record. SAM01900 READ (F,2,END=3) !Ignoring any content. SAM02000 END DO !Are we there yet? SAM02100 READ (F,2,END = 3) L,IS(1:MIN(L,LEN(IS))) !At last. SAM02200 2 FORMAT (Q,A) !Q = characters yet unread. SAM02300 IF (L.LT.LEN(IS)) IS(L + 1:) = "" !Clear the tail. SAM02400 IF (L.GT.LEN(IS)) THEN !Now for more silliness.SAM02500 WRITE (GETREC,1) "+Length",L !Too long to fit in IS. SAM02600 ELSE IF (L.LE.0) THEN !A zero-length record SAM02700 WRITE (GETREC,1) "+Null" !Is not the same SAM02800 ELSE IF (IS.EQ."") THEN !As a record SAM02900 WRITE (GETREC,1) "+Blank",L !Containing spaces. SAM03000 ELSE !But otherwise, SAM03100 WRITE (GETREC,1) " Length",L !Note the leading space.SAM03200 END IF !Righto, we've decided. SAM03300 END IF !And, no more options. SAM03400 RETURN !So, done. SAM03500 3 WRITE (GETREC,1) "!End on read",I !An alternative ending. SAM03600 END FUNCTION GETREC !That was interesting. SAM03700 END MODULE SAMPLER !Just a sample of possibility. SAM03800 SAM03900 PROGRAM POKE POK00100 USE SAMPLER POK00200 INTEGER ENUFF !Some sizes. POK00300 PARAMETER (ENUFF = 666) !Sufficient? POK00400 CHARACTER(ENUFF) STUFF !Lots of memory these days. POK00500 CHARACTER20 RESULT POK00600 INTEGER MSG,F !I/O unit numbers. POK00700 MSG = 6 !Standard output. POK00800 F = 10 !Chooose a unit number. POK00900 WRITE (MSG,) " To select record 7 from a disc file." POK01000 POK01100 WRITE (MSG,) "As a FORMATTED file." POK01200 OPEN (F,FILE="FileSlurpN.for",STATUS="OLD",ACTION="READ") POK01300 RESULT = GETREC(7,F,STUFF) POK01400 WRITE (MSG,1) "Result",RESULT POK01500 WRITE (MSG,1) "Record",STUFF POK01600 1 FORMAT (A,":",A) POK01700 POK01800 CLOSE (F) POK01900 WRITE (MSG,) "As a random-access unformatted file." POK02000 OPEN (F,FILE="FileSlurpN.for",STATUS="OLD",ACTION="READ", POK02100 1 ACCESS="DIRECT",FORM="UNFORMATTED",RECL=82) !Not 80! POK02200 STUFF = "Cleared." POK02300 READ (F,REC = 7,ERR = 666) STUFF(1:80) POK02400 WRITE (MSG,1) "Record",STUFF(1:80) POK02500 STOP POK02600 666 WRITE (MSG,*) "Can't get the record!" POK02700 END !That was easy. POK02800
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Sparkling	Sparkling	function undupe(arr) { var t = {}; foreach(arr, function(key, val) { t[val] = true; }); var r = {}; foreach(t, function(key) { r[sizeof r] = key; }); return r; }
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#SQL	SQL	/* This code is an implementation of "Remove duplicate elements" in SQL ORACLE 19c p_in_str -- input string p_delimiter -- delimeter */ WITH FUNCTION remove_duplicate_elements(p_in_str IN varchar2, p_delimiter IN varchar2 DEFAULT ',') RETURN varchar2 IS v_in_str varchar2(32767) := REPLACE(p_in_str,p_delimiter,','); v_res varchar2(32767); BEGIN -- EXECUTE immediate 'select listagg(distinct cv,:p_delimiter) from (select (column_value).getstringval() cv from xmltable(:v_in_str))' INTO v_res USING p_delimiter, v_in_str; -- RETURN v_res; -- END; --Test SELECT remove_duplicate_elements('1, 2, 3, "a", "b", "c", 2, 3, 4, "b", "c", "d"') AS res FROM dual UNION ALL SELECT remove_duplicate_elements('3 9 1 10 3 7 6 5 2 7 4 7 4 2 2 2 2 8 2 10 4 9 2 4 9 3 4 3 4 7',' ') AS res FROM dual ;
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#PureBasic	PureBasic	Procedure.d TimesPSec(Reset=#False) Static starttime, cnt Protected Result.d, dt If Reset starttime=ElapsedMilliseconds(): cnt=0 Else cnt+1 dt=(ElapsedMilliseconds()-starttime) If dt Result=cnt/(ElapsedMilliseconds()-starttime) EndIf EndIf ProcedureReturn Result*1000 EndProcedure If OpenWindow(0,#PB_Ignore,#PB_Ignore,220,110,"",#PB_Window_SystemMenu) Define Event, r.d, GadgetNumber ButtonGadget(0,10, 5,200,35,"Click me!") ButtonGadget(1,10,70,100,35,"Reset") TextGadget (2,10,45,200,25,"") TimesPSec(1) Repeat Event=WaitWindowEvent() If Event=#PB_Event_Gadget GadgetNumber =EventGadget() If GadgetNumber=0 r=TimesPSec() SetGadgetText(2,"You are clicking at "+StrD(r,5)+" Hz.") ElseIf GadgetNumber=1 TimesPSec(1) SetGadgetText(2,"Counter zeroed.") EndIf EndIf Until Event=#PB_Event_CloseWindow EndIf
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Maxima	Maxima	sreverse("abcdef"); /* "fedcba" / sreverse("rats live on no evil star"); / not a bug :o) */
http://rosettacode.org/wiki/Ray-casting_algorithm	Ray-casting algorithm	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) Given a point and a polygon, check if the point is inside or outside the polygon using the ray-casting algorithm. A pseudocode can be simply: count ← 0 foreach side in polygon: if ray_intersects_segment(P,side) then count ← count + 1 if is_odd(count) then return inside else return outside Where the function ray_intersects_segment return true if the horizontal ray starting from the point P intersects the side (segment), false otherwise. An intuitive explanation of why it works is that every time we cross a border, we change "country" (inside-outside, or outside-inside), but the 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). So 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. Looking 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). So the problematic points are those inside the white area (the box delimited by the points A and B), like P4. Let 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). Points 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. An algorithm for the previous speech could be (if P is a point, Px is its x coordinate): ray_intersects_segment: P : the point from which the ray starts A : the end-point of the segment with the smallest y coordinate (A must be "below" B) B : the end-point of the segment with the greatest y coordinate (B must be "above" A) if Py = Ay or Py = By then Py ← Py + ε end if if Py < Ay or Py > By then return false else if Px >= max(Ax, Bx) then return false else if Px < min(Ax, Bx) then return true else if Ax ≠ Bx then m_red ← (By - Ay)/(Bx - Ax) else m_red ← ∞ end if if Ax ≠ Px then m_blue ← (Py - Ay)/(Px - Ax) else m_blue ← ∞ end if if m_blue ≥ m_red then return true else return false end if end if end if (To avoid the "ray on vertex" problem, the point is moved upward of a small quantity ε.)	#Ada	Ada	package Polygons is type Point is record X, Y : Float; end record; type Point_List is array (Positive range <>) of Point; subtype Segment is Point_List (1 .. 2); type Polygon is array (Positive range <>) of Segment; function Create_Polygon (List : Point_List) return Polygon; function Is_Inside (Who : Point; Where : Polygon) return Boolean; end Polygons;
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#FreeBASIC	FreeBASIC	' FB 1.05.0 Win64 Open "input.txt" For Input As #1 Dim line_ As String Dim count As Integer = 0 While Not Eof(1) Line Input #1, line_ '' read each line count += 1 If count = 7 Then line_ = Trim(line_, Any !" \t") '' remove any leading or trailing spaces or tabs If line_ = "" Then Print "The 7th line is empty" Else Print "The 7th line is : "; line_ End If Exit While End If Wend If count < 7 Then Print "There are only"; count; " lines in the file" End If Close #1 Print Print "Press any key to quit" Sleep
http://rosettacode.org/wiki/Ranking_methods	Ranking methods	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort 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. The numerical rank of a competitor can be assigned in several different ways. Task The following scores are accrued for all competitors of a competition (in best-first order): 44 Solomon 42 Jason 42 Errol 41 Garry 41 Bernard 41 Barry 39 Stephen For 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: Standard. (Ties share what would have been their first ordinal number). Modified. (Ties share what would have been their last ordinal number). Dense. (Ties share the next available integer). Ordinal. ((Competitors take the next available integer. Ties are not treated otherwise). Fractional. (Ties share the mean of what would have been their ordinal numbers). See the wikipedia article for a fuller description. Show here, on this page, the ranking of the test scores under each of the numbered ranking methods.	#11l	11l	F mc_rank([(Int, String)] iterable) ‘Modified competition ranking’ [(Float, (Int, String))] r V lastresult = -1 [(Int, String)] fifo L(item) iterable I item[0] == lastresult fifo [+]= item E V n = L.index L !fifo.empty r.append((n, fifo.pop(0))) lastresult = item[0] fifo [+]= item L !fifo.empty r.append((iterable.len, fifo.pop(0))) R r F sc_rank([(Int, String)] iterable) ‘Standard competition ranking’ [(Float, (Int, String))] r V lastresult = -1 V lastrank = -1 L(item) iterable I item[0] == lastresult r.append((lastrank, item)) E V n = L.index + 1 r.append((n, item)) lastresult = item[0] lastrank = n R r F d_rank([(Int, String)] iterable) ‘Dense ranking’ [(Float, (Int, String))] r V lastresult = -1 V lastrank = 0 L(item) iterable I item[0] == lastresult r.append((lastrank, item)) E lastresult = item[0] lastrank++ r.append((lastrank, item)) R r F o_rank([(Int, String)] iterable) ‘Ordinal ranking’ R enumerate(iterable, 1).map((i, item) -> ((Float(i), item))) F f_rank([(Int, String)] iterable) ‘Fractional ranking’ [(Float, (Int, String))] r V last = -1 [(Int, (Int, String))] fifo L(item) iterable I item[0] != last I !fifo.empty V mean = Float(sum(fifo.map(f -> f[0]))) / fifo.len L !fifo.empty r.append((mean, fifo.pop(0)[1])) last = item[0] fifo.append((L.index + 1, item)) I !fifo.empty V mean = sum(fifo.map(f -> f[0])) / fifo.len L !fifo.empty r.append((mean, fifo.pop(0)[1])) R r V scores = [(44, ‘Solomon’), (42, ‘Jason’), (42, ‘Errol’), (41, ‘Garry’), (41, ‘Bernard’), (41, ‘Barry’), (39, ‘Stephen’)] print("\nScores to be ranked (best first):") L(n, s) scores print(‘ #2 #.’.format(n, s)) L(ranker, ranking_method) [(sc_rank, ‘Standard competition ranking’), (mc_rank, ‘Modified competition ranking’), (d_rank, ‘Dense ranking’), (o_rank, ‘Ordinal ranking’), (f_rank, ‘Fractional ranking’)] print("\n#.:".format(ranking_method)) L(rank, score) ranker(scores) print(‘ #3, (#., #.)’.format(rank, score[0], score[1]))
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Stata	Stata	. clear all . input x y 1 1 1 1 1 2 2 1 2 2 1 1 2 1 2 1 1 2 2 2 end . duplicates drop x y, force . list +-------+ \| x y \| \|-------\| 1. \| 1 1 \| 2. \| 1 2 \| 3. \| 2 1 \| 4. \| 2 2 \| +-------+
http://rosettacode.org/wiki/Remove_duplicate_elements	Remove duplicate elements	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).	#Swift	Swift	println(Array(Set([3,2,1,2,3,4])))
http://rosettacode.org/wiki/Rate_counter	Rate counter	Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function	#Python	Python	import subprocess import time class Tlogger(object): def __init__(self): self.counts = 0 self.tottime = 0.0 self.laststart = 0.0 self.lastreport = time.time() def logstart(self): self.laststart = time.time() def logend(self): self.counts +=1 self.tottime += (time.time()-self.laststart) if (time.time()-self.lastreport)>5.0: # report once every 5 seconds self.report() def report(self): if ( self.counts > 4self.tottime): print "Subtask execution rate: %f times/second"% (self.counts/self.tottime); else: print "Average execution time: %f seconds"%(self.tottime/self.counts); self.lastreport = time.time() def taskTimer( n, subproc_args ): logger = Tlogger() for x in range(n): logger.logstart() p = subprocess.Popen(subproc_args) p.wait() logger.logend() logger.report() import timeit import sys def main( ): # for accurate timing of code segments s = """j = [4n for n in range(50)]""" timer = timeit.Timer(s) rzlts = timer.repeat(5, 5000) for t in rzlts: print "Time for 5000 executions of statement = ",t # subprocess execution timing print "#times:",sys.argv[1] print "Command:",sys.argv[2:] print "" for k in range(3): taskTimer( int(sys.argv[1]), sys.argv[2:]) main()
http://rosettacode.org/wiki/Reverse_a_string	Reverse a string	Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#MAXScript	MAXScript	fn reverseString s = ( local reversed = "" for i in s.count to 1 by -1 do reversed += s[i] reversed )
http://rosettacode.org/wiki/Ray-casting_algorithm	Ray-casting algorithm	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) Given a point and a polygon, check if the point is inside or outside the polygon using the ray-casting algorithm. A pseudocode can be simply: count ← 0 foreach side in polygon: if ray_intersects_segment(P,side) then count ← count + 1 if is_odd(count) then return inside else return outside Where the function ray_intersects_segment return true if the horizontal ray starting from the point P intersects the side (segment), false otherwise. An intuitive explanation of why it works is that every time we cross a border, we change "country" (inside-outside, or outside-inside), but the 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). So 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. Looking 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). So the problematic points are those inside the white area (the box delimited by the points A and B), like P4. Let 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). Points 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. An algorithm for the previous speech could be (if P is a point, Px is its x coordinate): ray_intersects_segment: P : the point from which the ray starts A : the end-point of the segment with the smallest y coordinate (A must be "below" B) B : the end-point of the segment with the greatest y coordinate (B must be "above" A) if Py = Ay or Py = By then Py ← Py + ε end if if Py < Ay or Py > By then return false else if Px >= max(Ax, Bx) then return false else if Px < min(Ax, Bx) then return true else if Ax ≠ Bx then m_red ← (By - Ay)/(Bx - Ax) else m_red ← ∞ end if if Ax ≠ Px then m_blue ← (Py - Ay)/(Px - Ax) else m_blue ← ∞ end if if m_blue ≥ m_red then return true else return false end if end if end if (To avoid the "ray on vertex" problem, the point is moved upward of a small quantity ε.)	#ANSI_Standard_BASIC	ANSI Standard BASIC	1000 PUBLIC NUMERIC x,y 1010 LET x=1 1020 LET y=2 1030 ! 1040 DEF isLeft2(L(,),p()) = -SGN( (L(1,x)-L(2,x))(p(y)-L(2,y)) - (p(x)-L(2,x))(L(1,y)-L(2,y))) 1050 ! 1060 FUNCTION inpolygon(p1(,),p2()) 1070 LET k=UBOUND(p1,1)+1 1080 DIM send (1 TO 2,2) 1090 LET wn=0 1100 FOR n=1 TO UBOUND(p1,1) 1110 LET index=MOD(n, k) 1120 LET nextindex=MOD(n+1, k) 1130 IF nextindex=0 THEN LET nextindex=1 1140 LET send(1,x)=p1(index,x) 1150 LET send(2,x)=p1(nextindex,x) 1160 LET send(1,y)=p1(index,y) 1170 LET send(2,y)=p1(nextindex,y) 1180 IF p1(index,y)<=p2(y) THEN 1190 IF p1(nextindex,y)>p2(y) THEN 1200 IF isleft2(send,p2)>=0 THEN !'= 1210 LET wn=wn+1 1220 END IF 1230 END IF 1240 ELSE 1250 IF p1(nextindex,y)<=p2(y) THEN 1260 IF isleft2(send,p2)<=0 THEN !'= 1270 LET wn=wn-1 1280 END IF 1290 END IF 1300 END IF 1310 NEXT n 1320 LET inpolygon = wn 1330 END FUNCTION 1340 ! 1350 DIM type(1 TO 2) 1360 ! 1370 DIM square(4,2) 1380 MAT READ square 1390 DATA 0,0,10,0,10,10,0,10 1400 ! 1410 DIM hole(4,2) 1420 MAT READ hole 1430 DATA 2.5,2.5,7.5,2.5,7.5,7.5,2.5,7.5 1440 ! 1450 DIM strange(8,2) 1460 MAT READ strange 1470 DATA 0,0,2.5,2.5,0,10,2.5,7.5,7.5,7.5,10,10,10,0,2.5,2.5 1480 ! 1490 DIM exagon(6,2) 1500 MAT READ exagon 1510 DATA 3,0,7,0,10,5,7,10,3,10,0,5 1520 ! 1530 ! printouts 1540 FOR z=1 TO 4 1550 SELECT CASE z 1560 CASE 1 1570 PRINT "squared" 1580 PRINT "(5,5) ";TAB(12); 1590 MAT READ type 1600 DATA 5,5 1610 IF inpolygon(square,type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1620 MAT READ type 1630 DATA 5,8 1640 PRINT "(5,8) ";TAB(12); 1650 IF inpolygon(square,type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1660 PRINT "(-10,5) ";TAB(12); 1670 MAT READ type 1680 DATA -10,5 1690 IF inpolygon(square,type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1700 Print "(0,5) ";Tab(12); 1710 MAT READ type 1720 DATA 0,5 1730 IF inpolygon(square,type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1740 Print "(10,5) ";Tab(12); 1750 MAT READ type 1760 DATA 10,5 1770 IF inpolygon(square,type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1780 PRINT "(8,5) ";TAB(12); 1790 MAT READ type 1800 DATA 8,5 1810 IF inpolygon(square,Type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1820 PRINT "(10,10) ";TAB(12); 1830 MAT READ type 1840 DATA 10,10 1850 IF inpolygon(square,Type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1860 PRINT 1870 CASE 2 1880 PRINT "squared hole" 1890 PRINT "(5,5) ";TAB(12); 1900 MAT READ type 1910 DATA 5,5 1920 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 1930 Print "(5,8) ";Tab(12); 1940 MAT READ type 1950 DATA 5,8 1960 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 1970 PRINT "(-10,5) ";TAB(12); 1980 MAT READ type 1990 DATA -10,5 2000 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2010 PRINT "(0,5) ";TAB(12); 2020 MAT READ type 2030 DATA 0,5 2040 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2050 PRINT "(10,5) ";TAB(12); 2060 MAT READ type 2070 DATA 10,5 2080 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2090 PRINT "(8,5) ";TAB(12); 2100 MAT READ type 2110 DATA 8,5 2120 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2130 PRINT "(10,10) ";TAB(12); 2140 MAT READ type 2150 DATA 10,10 2160 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2170 PRINT 2180 CASE 3 2190 PRINT "strange" 2200 PRINT "(5,5) ";TAB(12); 2210 MAT READ type 2220 DATA 5,5 2230 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2240 PRINT "(5,8) ";TAB(12); 2250 MAT READ type 2260 DATA 5,8 2270 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2280 PRINT "(-10,5) ";TAB(12); 2290 MAT READ type 2300 DATA -10,5 2310 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2320 PRINT "(0,5) ";TAB(12); 2330 MAT READ type 2340 DATA 0,5 2350 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2360 PRINT "(10,5) ";TAB(12); 2370 MAT READ type 2380 DATA 10,5 2390 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2400 PRINT "(8,5) ";TAB(12); 2410 MAT READ type 2420 DATA 8,5 2430 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2440 PRINT "(10,10) ";TAB(12); 2450 MAT READ type 2460 DATA 10,10 2470 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2480 PRINT 2490 CASE 4 2500 PRINT "exagon" 2510 PRINT "(5,5) ";TAB(12); 2520 MAT READ type 2530 DATA 5,5 2540 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2550 PRINT "(5,8) ";TAB(12); 2560 MAT READ type 2570 DATA 5,8 2580 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2590 PRINT "(-10,5) ";TAB(12); 2600 MAT READ type 2610 DATA -10,5 2620 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2630 PRINT "(0,5) ";TAB(12); 2640 MAT READ type 2650 DATA 0,5 2660 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2670 PRINT "(10,5) ";TAB(12); 2680 MAT READ type 2690 DATA 10,5 2700 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2710 PRINT "(8,5) ";TAB(12); 2720 MAT READ type 2730 DATA 8,5 2740 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2750 PRINT "(10,10) ";TAB(12); 2760 MAT READ type 2770 DATA 10,10 2780 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2790 PRINT 2800 END SELECT 2810 NEXT z 2820 END
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#Frink	Frink	nthLine[filename, lineNum] := { line = nth[lines[filenameToURL[filename]], lineNum-1] if line != undef return line else { println["The file $filename does not contain a line number $lineNum"] return undef } }
http://rosettacode.org/wiki/Read_a_specific_line_from_a_file	Read a specific line from a file	Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.	#FutureBasic	FutureBasic	window 1 long i = 1 Str255 s, lineSeven CFURLRef url url = openpanel 1, @"Select text file" if ( url ) open "I", 2, url while ( not eof(2) ) line input #2, s if ( i == 7 ) lineSeven = s : break end if i++ wend close 2 if ( lineSeven[0] ) print lineSeven else print "File did not contain seven lines, or line was empty." end if end if HandleEvents
http://rosettacode.org/wiki/Ranking_methods	Ranking methods	Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort \| Merge sort \| Patience sort \| Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort \| Cocktail sort \| Cocktail sort with shifting bounds \| Comb sort \| Cycle sort \| Gnome sort \| Insertion sort \| Selection sort \| Strand sort other sorts Bead sort \| Bogo sort \| Common sorted list \| Composite structures sort \| Custom comparator sort \| Counting sort \| Disjoint sublist sort \| External sort \| Jort sort \| Lexicographical sort \| Natural sorting \| Order by pair comparisons \| Order disjoint list items \| Order two numerical lists \| Object identifier (OID) sort \| Pancake sort \| Quickselect \| Permutation sort \| Radix sort \| Ranking methods \| Remove duplicate elements \| Sleep sort \| Stooge sort \| [Sort letters of a string] \| Three variable sort \| Topological sort \| Tree sort 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. The numerical rank of a competitor can be assigned in several different ways. Task The following scores are accrued for all competitors of a competition (in best-first order): 44 Solomon 42 Jason 42 Errol 41 Garry 41 Bernard 41 Barry 39 Stephen For 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: Standard. (Ties share what would have been their first ordinal number). Modified. (Ties share what would have been their last ordinal number). Dense. (Ties share the next available integer). Ordinal. ((Competitors take the next available integer. Ties are not treated otherwise). Fractional. (Ties share the mean of what would have been their ordinal numbers). See the wikipedia article for a fuller description. Show here, on this page, the ranking of the test scores under each of the numbered ranking methods.	#AppleScript	AppleScript	(* The five ranking methods are implemented here as script objects sharing inherited code rather than as simple handlers, although there appears to be little advantage either way. This way needs fewer lines of code but more lines of explanatory comments! *) use AppleScript version "2.4" -- Mac OS 10.11 (Yosemite) or later (for these 'use' commands). use sorter : script "Custom Iterative Ternary Merge Sort" -- <https://macscripter.net/viewtopic.php?pid=194430#p194430> script standardRanking -- Properties and handlers inherited or overridden by the other script objects. -- The 'references' are to values that won't be available until 'results' is set to a list. -- 'me' and 'my' refer to the script object using the code at the time. property results : missing value property startIndex : 1 property endIndex : a reference to length of (a reference to results) property step : 1 property currentRank : missing value property currentScore : missing value -- Main handler. on resultsFrom(theScores) copy theScores to my results -- The task description specifies that the input list is already ordered, but that's not assumed here. -- Additionally, competitors with equal scores are arranged alphabetically by name. -- The comparer here is 'me' because the current script object contains the isGreater(a, b) handler to be used. tell sorter to sort(my results, my startIndex, my endIndex, {comparer:me}) set my currentScore to score of item (my startIndex) of my results set my currentRank to my startIndex's contents repeat with i from (my startIndex) to (my endIndex) by (my step) my rankResult(i) end repeat -- Since these script objects are assigned to top-level variables in a running script, make sure the potentially -- long 'results' list isn't saved back to the script file with them at the end of the run. This precaution isn't -- necessary in a library script or if the scripts are instantiated and assigned to local variables at run time. set localVariable to my results set my results to missing value return localVariable end resultsFrom -- Comparison handler used by the sort. The returned boolean indicates whether or not record 'a' should go after record 'b'. on isGreater(a, b) if (a's score is less than b's score) then return true return ((a's score is equal to b's score) and (a's competitor comes after b's competitor)) end isGreater -- Specialist ranking handler. Inherited by the modifiedRanking script, but overridden by the others. on rankResult(i) set thisResult to item i of my results set thisScore to thisResult's score if (thisScore is not currentScore) then set my currentRank to i set my currentScore to thisScore end if set item i of my results to thisResult & {rank:my currentRank} end rankResult end script script modifiedRanking -- Uses the standardRanking code, but works backwards through the results list. property parent : standardRanking property startIndex : a reference to length of (a reference to results) property endIndex : 1 property step : -1 end script script denseRanking property parent : standardRanking on rankResult(i) set thisResult to item i of my results set thisScore to thisResult's score if (thisScore is not my currentScore) then set my currentRank to (my currentRank) + 1 set my currentScore to thisScore end if set item i of my results to thisResult & {rank:my currentRank} end rankResult end script script ordinalRanking property parent : standardRanking on rankResult(i) set item i of my results to (item i of my results) & {rank:i} end rankResult end script script fractionalRanking property parent : standardRanking on rankResult(i) set thisResult to item i of my results set thisScore to thisResult's score if (thisScore is not my currentScore) then -- i and currentRank are simultaneously indices and ranks. -- The average of any run of consecutive integers is that of the first and last. set average to (i - 1 + (my currentRank)) / 2 repeat with j from (my currentRank) to (i - 1) set rank of item j of my results to average end repeat set my currentRank to i set my currentScore to thisScore end if set item i of my results to thisResult & {rank:i as real} end rankResult end script -- Task code: on formatRankings(type, theResults) set rankings to {type} repeat with thisResult in theResults set end of rankings to (thisResult's rank as text) & tab & thisResult's competitor & " (" & thisResult's score & ")" end repeat return joinStrings(rankings, linefeed) end formatRankings on joinStrings(listOfText, delimiter) set astid to AppleScript's text item delimiters set AppleScript's text item delimiters to delimiter set output to listOfText as text set AppleScript's text item delimiters to astid return output end joinStrings local theScores, output set theScores to {{score:44, competitor:"Solomon"}, {score:42, competitor:"Jason"}, {score:42, competitor:"Errol"}, ¬ {score:41, competitor:"Garry"}, {score:41, competitor:"Bernard"}, {score:41, competitor:"Barry"}, ¬ {score:39, competitor:"Stephen"}} set output to {} set end of output to formatRankings("Standard ranking:", standardRanking's resultsFrom(theScores)) set end of output to formatRankings("Modified ranking:", modifiedRanking's resultsFrom(theScores)) set end of output to formatRankings("Dense ranking:", denseRanking's resultsFrom(theScores)) set end of output to formatRankings("Ordinal ranking:", ordinalRanking's resultsFrom(theScores)) set end of output to formatRankings("Fractional ranking:", fractionalRanking's resultsFrom(theScores)) return joinStrings(output, linefeed & linefeed)

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#LFE

LFE

> (lists:reverse "asdf") "fdsa"

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#VBA

VBA

Public Function RepeatStr(aString As String, aNumber As Integer) As String Dim bString As String, i As Integer bString = "" For i = 1 To aNumber bString = bString & aString Next i RepeatStr = bString End Function Debug.Print RepeatStr("ha", 5)

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#VBScript

VBScript

' VBScript has a String() function that can repeat a character a given number of times ' but this only works with single characters (or the 1st char of a string): WScript.Echo String(10, "123") ' Displays "1111111111" ' To repeat a string of chars, you can use either of the following "hacks"... WScript.Echo Replace(Space(10), " ", "Ha") WScript.Echo Replace(String(10, "X"), "X", "Ha")

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#Batch_File

Batch File

@echo off for /f "skip=6 tokens=*" %%i in (file.txt) do ( set line7=%%i goto break ) :break echo Line 7 is: %line7% pause>nul

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#BBC_BASIC

BBC BASIC

filepath$ = @lib$ + "..\licence.txt" requiredline% = 7 file% = OPENIN(filepath$) IF file%=0 ERROR 100, "File could not be opened" FOR i% = 1 TO requiredline% IF EOF#file% ERROR 100, "File contains too few lines" INPUT #file%, text$ NEXT CLOSE #file% IF ASCtext$=10 text$ = MID$(text$,2) PRINT text$

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Red

Red

>> items: [1 "a" "c" 1 3 4 5 "c" 3 4 5] >> unique items == [1 "a" "c" 3 4 5]

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#REXX

REXX

/*REXX program removes any duplicate elements (items) that are in a list (using a hash).*/ $= '2 3 5 7 11 13 17 19 cats 222 -100.2 +11 1.1 +7 7. 7 5 5 3 2 0 4.4 2' /*item list.*/ say 'original list:' $ say right( words($), 17, '─') 'words in the original list.' z=; @.= /*initialize the NEW list & index list.*/ do j=1 for words($); y= word($, j) /*process the words (items) in the list*/ if @.y=='' then z= z y; @.y= . /*Not duplicated? Add to Z list,@ array*/ end /*j*/ say say 'modified list:' space(z) /*stick a fork in it, we're all done. */ say right( words(z), 17, '─') 'words in the modified list.'

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#QBasic

QBasic

f = FREEFILE filename$ = "file.txt" OPEN filename$ FOR BINARY AS #f WHILE NOT EOF(f) char$ = STR$(LOF(f)) GET #f, , char$ PRINT char$; WEND CLOSE #f

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#Racket

Racket

#lang racket ; This file contains utf-8 charachters: λ, α, γ ... (for ([c (in-port read-char (open-input-file "read-file.rkt"))]) (display c))

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#JavaScript

JavaScript

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Liberty_BASIC

Liberty BASIC

input$ ="abcdefgABCDEFG012345" print input$ print ReversedStr$( input$) end function ReversedStr$(in$) for i =len(in$) to 1 step -1 ReversedStr$ =ReversedStr$ +mid$( in$, i, 1) next i end function

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Vedit_macro_language

Vedit macro language

Ins_Text("ha", COUNT, 5)

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Visual_Basic

Visual Basic

Public Function StrRepeat(s As String, n As Integer) As String Dim r As String, i As Integer r = "" For i = 1 To n r = r & s Next i StrRepeat = r End Function Debug.Print StrRepeat("ha", 5)

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#C

C

#include <unistd.h> #include <sys/types.h> #include <sys/mman.h> #include <sys/stat.h> #include <fcntl.h> #include <err.h> /* following code assumes all file operations succeed. In practice, * return codes from open, close, fstat, mmap, munmap all need to be * checked for error. */ int read_file_line(const char *path, int line_no) { struct stat s; char *buf; off_t start = -1, end = -1; size_t i; int ln, fd, ret = 1; if (line_no == 1) start = 0; else if (line_no < 1){ warn("line_no too small"); return 0; /* line_no starts at 1; less is error */ } line_no--; /* back to zero based, easier */ fd = open(path, O_RDONLY); fstat(fd, &s); /* Map the whole file. If the file is huge (up to GBs), OS will swap * pages in and out, and because search for lines goes sequentially * and never accesses more than one page at a time, penalty is low. * If the file is HUGE, such that OS can't find an address space to map * it, we got a real problem. In practice one would repeatedly map small * chunks, say 1MB at a time, and find the offsets of the line along the * way. Although, if file is really so huge, the line itself can't be * guaranteed small enough to be "stored in memory", so there. */ buf = mmap(0, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0); /* optional; if the file is large, tell OS to read ahead */ madvise(buf, s.st_size, MADV_SEQUENTIAL); for (i = ln = 0; i < s.st_size && ln <= line_no; i++) { if (buf[i] != '\n') continue; if (++ln == line_no) start = i + 1; else if (ln == line_no + 1) end = i + 1; } if (start >= s.st_size || start < 0) { warn("file does not have line %d", line_no + 1); ret = 0; } else { /* do something with the line here, like write(STDOUT_FILENO, buf + start, end - start); or copy it out, or something */ } munmap(buf, s.st_size); close(fd); return ret; }

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Ring

Ring

list = ["Now", "is", "the", "time", "for", "all", "good", "men", "to", "come", "to", "the", "aid", "of", "the", "party."] for i = 1 to len(list) for j = i + 1 to len(list) if list[i] = list[j] del(list, j) j-- ok next next for n = 1 to len(list) see list[n] + " " next see nl

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Ruby

Ruby

ary = [1,1,2,1,'redundant',[1,2,3],[1,2,3],'redundant'] p ary.uniq # => [1, 2, "redundant", [1, 2, 3]]

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#Raku

Raku

.say while defined $_ = $*IN.getc;

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#REXX

REXX

/*REXX program reads and displays a file char by char, returning 'EOF' when done. */ parse arg iFID . /*iFID: is the fileID to be read. */ /* [↓] show the file's contents. */ if iFID\=='' then do j=1 until x=='EOF' /*J count's the file's characters. */ x=getchar(iFID); y= /*get a character or an 'EOF'. */ if x>>' ' then y=x /*display X if presentable. */ say right(j, 12) 'character, (hex,char)' c2x(x) y end /*j*/ /* [↑] only display X if not low hex*/ exit /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ getchar: procedure; parse arg z; if chars(z)==0 then return 'EOF'; return charin(z)

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#Jsish

Jsish

#!/usr/bin/env jsish "use strict"; /* Rate counter, timer access, in Jsish */ /* System time in milliseconds */ var runs = 0, newMs; function countJobsIsTheJob() { runs += 1; } var milliSeconds = strptime(); while ((newMs = strptime()) < (milliSeconds + 1000)) { countJobsIsTheJob(); } puts(runs, 'runs in', newMs - milliSeconds, 'ms'); /* Builtin times test(callback, runs), result in microseconds */ function sleeper() { sleep(10); } var timer; for (var i = 1; i < 4; i++) { timer = times(sleeper, 100); puts(timer, 'μs to sleep 10 ms, 100 times'); }

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Lingo

Lingo

on reverse (str) res = "" repeat with i = str.length down to 1 put str.char[i] after res end repeat return res end

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Visual_Basic_.NET

Visual Basic .NET

Debug.Print(Replace(Space(5), " ", "Ha"))

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Visual_FoxPro

Visual FoxPro

? REPLICATE("HO", 3)

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#C.23

C#

using System; using System.IO; namespace GetLine { internal class Program { private static void Main(string[] args) { Console.WriteLine(GetLine(args[0], uint.Parse(args[1]))); } private static string GetLine(string path, uint line) { using (var reader = new StreamReader(path)) { try { for (uint i = 0; i <= line; i++) { if (reader.EndOfStream) return string.Format("There {1} less than {0} line{2} in the file.", line, ((line == 1) ? "is" : "are"), ((line == 1) ? "" : "s")); if (i == line) return reader.ReadLine(); reader.ReadLine(); } } catch (IOException ex) { return ex.Message; } catch (OutOfMemoryException ex) { return ex.Message; } } throw new Exception("Something bad happened."); } } }

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Run_BASIC

Run BASIC

a$ = "2 3 5 7 11 13 17 19 cats 222 -100.2 +11 1.1 +7 7. 7 5 5 3 2 0 4.4 2" for i = 1 to len(a$) a1$ = word$(a$,i) if a1$ = "" then exit for for i1 = 1 to len(b$) if a1$ = word$(b$,i1) then [nextWord] next i1 b$ = b$ + a1$ + " " [nextWord] next i print "Dups:";a$ print "No Dups:";b$

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#Ring

Ring

fp = fopen("C:\Ring\ReadMe.txt","r") r = fgetc(fp) while isstring(r) r = fgetc(fp) see r end fclose(fp)

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#Ruby

Ruby

File.open('input.txt', 'r:utf-8') do |f| f.each_char{|c| p c} end

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#Julia

Julia

dosomething() = sleep(abs(randn())) function runNsecondsworthofjobs(N) times = Vector{Float64}() totaltime = 0 runcount = 0 while totaltime < N t = @elapsed(dosomething()) push!(times, t) totaltime += t runcount += 1 end println("Ran job $runcount times, for total time of $totaltime seconds.") println("Average time per run was $(sum(times)/length(times)) seconds.") println("Individual times of the jobs in seconds were:") for t in times println(" $t") end end runNsecondsworthofjobs(5)

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#Kotlin

Kotlin

// version 1.1.3 typealias Func<T> = (T) -> T fun cube(n: Int) = n * n * n fun <T> benchmark(n: Int, func: Func<T>, arg: T): LongArray { val times = LongArray(n) for (i in 0 until n) { val m = System.nanoTime() func(arg) times[i] = System.nanoTime() - m } return times } fun main(args: Array<String>) { println("\nTimings (nanoseconds) : ") for (time in benchmark(10, ::cube, 5)) println(time) }

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#LiveCode

LiveCode

function reverseString S repeat with i = length(S) down to 1 put char i of S after R end repeat return R end reverseString

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Vlang

Vlang

// Repeat a string, in V // Tectonics: v run repeat-a-string.v module main import strings // starts here pub fn main() { // A strings module function to repeat strings println(strings.repeat_string("ha", 5)) // Another strings module function to repeat a byte // This indexes the string to get the first byte of the rune array println(strings.repeat("*"[0], 5)) }

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Wart

Wart

def (s * n) :case (string? s) with outstring repeat n pr s ("ha" * 5) => "hahahahaha"

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#C.2B.2B

C++

#include <string> #include <fstream> #include <iostream> int main( ) { std::cout << "Which file do you want to look at ?\n" ; std::string input ; std::getline( std::cin , input ) ; std::ifstream infile( input.c_str( ) , std::ios::in ) ; std::string file( input ) ; std::cout << "Which file line do you want to see ? ( Give a number > 0 ) ?\n" ; std::getline( std::cin , input ) ; int linenumber = std::stoi( input ) ; int lines_read = 0 ; std::string line ; if ( infile.is_open( ) ) { while ( infile ) { getline( infile , line ) ; lines_read++ ; if ( lines_read == linenumber ) { std::cout << line << std::endl ; break ; } } infile.close( ) ; if ( lines_read < linenumber ) std::cout << "No " << linenumber << " lines in " << file << " !\n" ; return 0 ; } else { std::cerr << "Could not find file " << file << " !\n" ; return 1 ; } }

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Rust

Rust

use std::collections::HashSet; use std::hash::Hash; fn remove_duplicate_elements_hashing<T: Hash + Eq>(elements: &mut Vec<T>) { let set: HashSet<_> = elements.drain(..).collect(); elements.extend(set.into_iter()); } fn remove_duplicate_elements_sorting<T: Ord>(elements: &mut Vec<T>) { elements.sort_unstable(); // order does not matter elements.dedup(); } fn main() { let mut sample_elements = vec![0, 0, 1, 1, 2, 3, 2]; println!("Before removal of duplicates : {:?}", sample_elements); remove_duplicate_elements_sorting(&mut sample_elements); println!("After removal of duplicates : {:?}", sample_elements); }

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#Run_BASIC

Run BASIC

open file.txt" for binary as #f numChars = 1 ' specify number of characters to read a$ = input$(#f,numChars) ' read number of characters specified b$ = input$(#f,1) ' read one character close #f

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#Rust

Rust

use std::{ convert::TryFrom, fmt::{Debug, Display, Formatter}, io::Read, }; pub struct ReadUtf8<I: Iterator> { source: std::iter::Peekable<I>, } impl<R: Read> From<R> for ReadUtf8<std::io::Bytes<R>> { fn from(source: R) -> Self { ReadUtf8 { source: source.bytes().peekable(), } } } impl<I, E> Iterator for ReadUtf8<I> where I: Iterator<Item = Result<u8, E>>, { type Item = Result<char, Error<E>>; fn next(&mut self) -> Option<Self::Item> { self.source.next().map(|next| match next { Ok(lead) => self.complete_char(lead), Err(e) => Err(Error::SourceError(e)), }) } } impl<I, E> ReadUtf8<I> where I: Iterator<Item = Result<u8, E>>, { fn continuation(&mut self) -> Result<u32, Error<E>> { if let Some(Ok(byte)) = self.source.peek() { let byte = *byte; return if byte & 0b1100_0000 == 0b1000_0000 { self.source.next(); Ok((byte & 0b0011_1111) as u32) } else { Err(Error::InvalidByte(byte)) }; } match self.source.next() { None => Err(Error::InputTruncated), Some(Err(e)) => Err(Error::SourceError(e)), Some(Ok(_)) => unreachable!(), } } fn complete_char(&mut self, lead: u8) -> Result<char, Error<E>> { let a = lead as u32; // Let's name the bytes in the sequence let result = if a & 0b1000_0000 == 0 { Ok(a) } else if lead & 0b1110_0000 == 0b1100_0000 { let b = self.continuation()?; Ok((a & 0b0001_1111) << 6 | b) } else if a & 0b1111_0000 == 0b1110_0000 { let b = self.continuation()?; let c = self.continuation()?; Ok((a & 0b0000_1111) << 12 | b << 6 | c) } else if a & 0b1111_1000 == 0b1111_0000 { let b = self.continuation()?; let c = self.continuation()?; let d = self.continuation()?; Ok((a & 0b0000_0111) << 18 | b << 12 | c << 6 | d) } else { Err(Error::InvalidByte(lead)) }; Ok(char::try_from(result?).unwrap()) } } #[derive(Debug, Clone)] pub enum Error<E> { InvalidByte(u8), InputTruncated, SourceError(E), } impl<E: Display> Display for Error<E> { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { match self { Self::InvalidByte(b) => write!(f, "invalid byte 0x{:x}", b), Self::InputTruncated => write!(f, "character truncated"), Self::SourceError(e) => e.fmt(f), } } } fn main() -> std::io::Result<()> { for (index, value) in ReadUtf8::from(std::fs::File::open("test.txt")?).enumerate() { match value { Ok(c) => print!("{}", c), Err(e) => { print!("\u{fffd}"); eprintln!("offset {}: {}", index, e); } } } Ok(()) }

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#Liberty_BASIC

Liberty BASIC

Print "Rate counter" print "Precision: system clock, ms "; t0=time$("ms") while time$("ms")=t0 'busy loop till click ticks wend print time$("ms")-t0 print Print "Run jobs N times, report every time" Print "After that, report average time" N=10 t00=time$("ms") for i = 1 to 10 scan t0=time$("ms") 'any code we want to measure goes here res = testFunc() 'end of measured code t1=time$("ms") ElapsedTime = t1-t0 print "Job #";i;" Elapsed time, ms ";ElapsedTime, 1000/ElapsedTime; " ticks per second" next print "---------------------------------" print "Average time, ms, is ";(t1-t00)/N, 1000/((t1-t00)/N); " ticks per second" print print "Run jobs for not less then N seconds (if time up, it'll finish last job)" print "After that, report average time" NSec=5 i = 0 t00=time$("ms") while time$("ms")<t00+NSec*1000 scan i = i+1 t0=time$("ms") 'any code we want to measure goes here res = testFunc() 'end of measured code t1=time$("ms") ElapsedTime = t1-t0 print "Job #";i;" Elapsed time, ms ";ElapsedTime, 1000/ElapsedTime; " ticks per second" wend print "---------------------------------" print "Average time, ms, is ";(t1-t00)/i, 1000/((t1-t00)/i); " ticks per second" end function testFunc() s=0 for i = 1 to 30000 s=s+sin(i)/30000 next testFunc = s end function

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#LLVM

LLVM

; This is not strictly LLVM, as it uses the C library function "printf". ; LLVM does not provide a way to print values, so the alternative would be ; to just load the string into memory, and that would be boring. ; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps $"main.printf" = comdat any @main.str = private unnamed_addr constant [12 x i8] c"Hello world\00", align 1 @"main.printf" = linkonce_odr unnamed_addr constant [4 x i8] c"%s\0A\00", comdat, align 1 define void @reverse(i64, i8*) { %3 = alloca i8*, align 8 ; allocate str (local) %4 = alloca i64, align 8 ; allocate len (local) %5 = alloca i64, align 8 ; allocate i %6 = alloca i64, align 8 ; allocate j %7 = alloca i8, align 1 ; allocate t store i8* %1, i8** %3, align 8 ; set str (local) to the parameter str store i64 %0, i64* %4, align 8 ; set len (local) to the paremeter len store i64 0, i64* %5, align 8 ; i = 0 %8 = load i64, i64* %4, align 8 ; load len %9 = sub i64 %8, 1 ; decrement len store i64 %9, i64* %6, align 8 ; j = br label %loop loop: %10 = load i64, i64* %5, align 8 ; load i %11 = load i64, i64* %6, align 8 ; load j %12 = icmp ult i64 %10, %11 ; i < j br i1 %12, label %loop_body, label %exit loop_body: %13 = load i8*, i8** %3, align 8 ; load str %14 = load i64, i64* %5, align 8 ; load i %15 = getelementptr inbounds i8, i8* %13, i64 %14 ; address of str[i] %16 = load i8, i8* %15, align 1 ; load str[i] store i8 %16, i8* %7, align 1 ; t = str[i] %17 = load i64, i64* %6, align 8 ; load j %18 = getelementptr inbounds i8, i8* %13, i64 %17 ; address of str[j] %19 = load i8, i8* %18, align 1 ; load str[j] %20 = getelementptr inbounds i8, i8* %13, i64 %14 ; address of str[i] store i8 %19, i8* %20, align 1 ; str[i] = str[j] %21 = load i8, i8* %7, align 1 ; load t %22 = getelementptr inbounds i8, i8* %13, i64 %17 ; address of str[j] store i8 %21, i8* %22, align 1 ; str[j] = t ;-- loop increment %23 = load i64, i64* %5, align 8 ; load i %24 = add i64 %23, 1 ; increment i store i64 %24, i64* %5, align 8 ; store i %25 = load i64, i64* %6, align 8 ; load j %26 = add i64 %25, -1 ; decrement j store i64 %26, i64* %6, align 8 ; store j br label %loop exit: ret void } define i32 @main() { ;-- char str[] %1 = alloca [12 x i8], align 1 ;-- memcpy(str, "Hello world") %2 = bitcast [12 x i8]* %1 to i8* call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @main.str, i32 0, i32 0), i64 12, i32 1, i1 false) ;-- printf("%s\n", str) %3 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0 %4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main.printf", i32 0, i32 0), i8* %3) ;-- %7 = strlen(str) %5 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0 %6 = call i64 @strlen(i8* %5) ;-- reverse(%6, str) call void @reverse(i64 %6, i8* %5) ;-- printf("%s\n", str) %7 = getelementptr inbounds [12 x i8], [12 x i8]* %1, i32 0, i32 0 %8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main.printf", i32 0, i32 0), i8* %7) ;-- end of main ret i32 0 } ;--- The declaration for the external C printf function. declare i32 @printf(i8*, ...) ; Function Attrs: argmemonly nounwind declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1) declare i64 @strlen(i8*)

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Wortel

Wortel

@join "" @rep 5 "ha" ; returns "hahahahaha"

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Wren

Wren

System.print("ha" * 5)

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#Clojure

Clojure

(defn read-nth-line "Read line-number from the given text file. The first line has the number 1." [file line-number] (with-open [rdr (clojure.java.io/reader file)] (nth (line-seq rdr) (dec line-number))))

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Scala

Scala

val list = List(1,2,3,4,2,3,4,99) val l2 = list.distinct // l2: scala.List[scala.Int] = List(1,2,3,4,99) val arr = Array(1,2,3,4,2,3,4,99) val arr2 = arr.distinct // arr2: Array[Int] = Array(1, 2, 3, 4, 99)

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#Seed7

Seed7

$ include "seed7_05.s7i"; include "utf8.s7i"; const proc: main is func local var file: inFile is STD_NULL; var char: ch is ' '; begin OUT := STD_UTF8_OUT; inFile := openUtf8("readAFileCharacterByCharacterUtf8.in", "r"); if inFile <> STD_NULL then while hasNext(inFile) do ch := getc(inFile); writeln("got character " <& ch <& " [U+" <& ord(ch) radix 16 <& "]"); end while; close(inFile); end if; end func;

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#Sidef

Sidef

var file = File('input.txt') # the input file contains: "aă€⼥" var fh = file.open_r # equivalent with: file.open('<:utf8') fh.each_char { |char| printf("got character #{char} [U+%04x]\n", char.ord) }

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#Mathematica.2FWolfram_Language

Mathematica/Wolfram Language

jobRateCounted[fn_,Y_Integer]:=First[AbsoluteTiming[Do[fn,{Y}]]/Y; SetAttributes[jobRateCounted,HoldFirst] jobRatePeriod[fn_,time_]:=Block[{n=0},TimeConstrained[While[True,fn;n++]];n/time]; SetAttributes[jobRatePeriod,HoldFirst]

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#Nim

Nim

import sugar, std/monotimes, times type Func[T] = (T) -> T func cube(n: int): int = n * n * n proc benchmark[T](n: int; f: Func[T]; arg: T): seq[Duration] = result.setLen(n) for i in 0..<n: let m = getMonoTime() discard f(arg) result[i] = getMonoTime() - m echo "Timings (nanoseconds):" for time in benchmark(10, cube, 5): echo time.inNanoseconds

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Logo

Logo

print reverse "cat ; tac

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#XPL0

XPL0

cod T=12; int I; for I gets 1,5 do T(0,"ha")

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Yorick

Yorick

array("ha", 5)(sum)

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#Common_Lisp

Common Lisp

(defun read-nth-line (file n &aux (line-number 0)) "Read the nth line from a text file. The first line has the number 1" (assert (> n 0) (n)) (with-open-file (stream file) (loop for line = (read-line stream nil nil) if (and (null line) (< line-number n)) do (error "file ~a is too short, just ~a, not ~a lines long" file line-number n) do (incf line-number) if (and line (= line-number n)) do (return line))))

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Scheme

Scheme

(define (remove-duplicates l) (cond ((null? l) '()) ((member (car l) (cdr l)) (remove-duplicates (cdr l))) (else (cons (car l) (remove-duplicates (cdr l)))))) (remove-duplicates '(1 2 1 3 2 4 5))

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#Smalltalk

Smalltalk

|utfStream| utfStream := 'input' asFilename readStream asUTF8EncodedStream. [utfStream atEnd] whileFalse:[ Transcript showCR:'got char ',utfStream next. ]. utfStream close.

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#Tcl

Tcl

set ch [read $channel 1]

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#OxygenBasic

OxygenBasic

'======== 'TIME API '======== 'http://msdn.microsoft.com/en-us/library/windows/desktop/ms724950(v=vs.85).aspx extern lib "kernel32.dll" type SYSTEMTIME WORD wYear WORD wMonth WORD wDayOfWeek WORD wDay WORD wHour WORD wMinute WORD wSecond WORD wMilliseconds end type void GetSystemTime(SYSTEMTIME*t) void GetLocalTime(SYSTEMTIME*t) void QueryPerformanceCounter(quad*c) void QueryPerformanceFrequency(quad*freq) void Sleep(sys millisecods) end extern String WeekDay[7]={"Sunday","Monday","Tuesday","Wednesday", "Thursday","Friday","Saturday"} String MonthName[12]={"January","February","March","April","May","June", "July","August","September","October","November","December"} '============== Class Jobrecord '============== has SYSTEMTIME stt has SYSTEMTIME fin quad countA quad CountB quad freq sys serial method pad(string s) as string method=s if len(method)<2 then method="0"+method end method method ShowDateTime(sys a,f) as string SYSTEMTIME *t if a then @t=@fin else @t=@stt end if ' String month=pad(str t.wMonth) String day=pad(str t.wDay) if f=0 then return "" t.wYear "-" month "-" day " "+ pad(t.wHour) ":" pad(t.wMinute) ":" pad(t.wSecond) ":" t.wMilliSeconds elseif f=1 return WeekDay[t.wDayOfWeek+1 and 7 ] " " + MonthName[t.wMonth and 31] " " day " " t.wYear end if end method method Start() QueryPerformanceCounter countA QueryPerformanceFrequency freq serial++ GetLocalTime stt end method method Finish() GetLocalTime fin QueryPerformanceCounter countB end method method ShowDuration() as string return str((countB-countA)/freq,6) 'seconds with microsecond resolution end method method report() as string string tab=chr(9), cr=chr(13)+chr(10) method="Job:" tab serial cr + "Duration:" tab ShowDuration() cr + "Start: " tab ShowDateTime(0,0) cr + "Finish:" tab ShowDateTime(1,0) cr + ShowDateTime(1,1) cr end method end class '#recordof JobRecord '==== 'TEST '==== JobRecord JR JR.start sleep 100 'JOB! JR.finish print JR.Report 'putfile "s.txt",JR.Report ' 'Job: 1 'Duration: 0.099026 'Start: 2012-07-01 00:52:36:874 'Finish: 2012-07-01 00:52:36:974 'Sunday July 01 2012

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Lua

Lua

theString = theString:reverse()

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Z80_Assembly

Z80 Assembly

PrintChar equ &BB5A ;Amstrad CPC BIOS call, prints the ascii code in the accumulator to the screen. org &8000 ld b,5 ; repeat 5 times loop: call PrintImmediate byte "ha",0 djnz loop ret ; return to basic ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PrintImmediate: pop hl ; get the return address into HL, it's the start of the embedded string. call PrintString ; inc hl ; if your strings are null-terminated you can omit this, since a 0 equals the "NOP" instruction jp (hl) ; acts as a ret, returning execution to the instruction just after the embedded string. PrintString: ld a,(hl) ; read in a character from the string or a ; if your strings are null-terminated you can use this as a shortcut, otherwise use the compare instruction ret z ; exit once the terminator is reached. call PrintChar ; BIOS call, all regs are preserved. inc hl ; next char jr PrintString ; back to start.

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#D

D

void main() { import std.stdio, std.file, std.string; auto file_lines = readText("input.txt").splitLines(); //file_lines becomes an array of strings, each line is one element writeln((file_lines.length > 6) ? file_lines[6] : "line not found"); }

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Seed7

Seed7

$ include "seed7_05.s7i"; const proc: main is func local const array integer: data is [] (1, 3, 2, 9, 1, 2, 3, 8, 8, 1, 0, 2); var set of integer: dataSet is (set of integer).value; var integer: number is 0; begin for number range data do incl(dataSet, number); end for; writeln(dataSet); end func;

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#Wren

Wren

import "io" for File File.open("input.txt") { |file| var offset = 0 var char = "" // stores each byte read till we have a complete UTF encoded character while(true) { var b = file.readBytes(1, offset) if (b == "") return // end of stream char = char + b if (char.codePoints[0] >= 0) { // a UTF encoded character is complete System.write(char) // print it char = "" // reset store } offset = offset + 1 } }

http://rosettacode.org/wiki/Read_a_file_character_by_character/UTF8

Read a file character by character/UTF8

Task Read a file one character at a time, as opposed to reading the entire file at once. The 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). The procedure should support the reading of files containing UTF8 encoded wide characters, returning whole characters for each consecutive read. Related task Read a file line by line

#zkl

zkl

fcn readUTF8c(chr,s=""){ // transform UTF-8 character stream s+=chr; try{ s.len(8); return(s) } catch{ if(s.len()>6) throw(__exception) } // 6 bytes max for UTF-8 return(Void.Again,s); // call me again with s & another character }

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#PARI.2FGP

PARI/GP

a=0; b=0; for(n=1,20000000, a=a+gettime(); if(a>60000,print(b);a=0;b=0); '''code to test''' b=b+1; a=a+gettime(); if(a>60000,print(b);a=0;b=0) )

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#M2000_Interpreter

M2000 Interpreter

Module ReverseString { a$="as⃝df̅" Print Len(a$), len.disp(a$) Let i=1, j=Len(a$) z$=String$(" ",j) j++ do { k$=mid$(a$, i, 1) if i<len(a$) then { while len.disp(k$+mid$(a$, i+1,1)) =len.disp(k$) { k$+=mid$(a$, i+1,1) i++ if i>len(a$) then exit j-- } j-- insert j, len(k$) Z$=K$ } else j-- :Insert j,1 z$=k$ if i>=len(a$) then exit i++ } Always Print len(z$), len.disp(z$) Print z$="f̅ds⃝a" Print z$ } ReverseString

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#zig

zig

const laugh = "ha" ** 5;

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#Delphi

Delphi

program Read_a_specific_line_from_a_file; {$APPTYPE CONSOLE} uses System.SysUtils; function ReadLine(position: Cardinal; FileName: TFileName): string; begin Result := ''; if not FileExists(FileName) then raise Exception.Create('Error: File does not exist.'); var F: TextFile; var line: string; AssignFile(F, FileName); Reset(F); for var _ := 1 to position do begin if Eof(F) then begin CloseFile(F); raise Exception.Create(Format('Error: The file "%s" is too short. Cannot read line %d', [FileName, position])); end; Readln(F, line); end; CloseFile(F); Result := line; end; begin Writeln(ReadLine(7, 'test')); Readln; end.

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#SETL

SETL

items := [0,7,6,6,4,9,7,1,2,3,2]; print(unique(items));

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#Perl

Perl

use Benchmark; timethese COUNT,{ 'Job1' => &job1, 'Job2' => &job2 }; sub job1 { ...job1 code... } sub job2 { ...job2 code... }

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#M4

M4

define(`invert',`ifelse(len(`$1'),0,,`invert(substr(`$1',1))'`'substr(`$1',0,1))')

http://rosettacode.org/wiki/Repeat_a_string

Repeat a string

Take a string and repeat it some number of times. Example: repeat("ha", 5) => "hahahahaha" If 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) => "*****"). Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#zkl

zkl

"ha" * 5 # --> "hahahahaha"

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#Elixir

Elixir

defmodule LineReader do def get_line(filename, line) do File.stream!(filename) |> Stream.with_index |> Stream.filter(fn {_value, index} -> index == line-1 end) |> Enum.at(0) |> print_line end defp print_line({value, _line_number}), do: String.trim(value) defp print_line(_), do: {:error, "Invalid Line"} end

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#SETL4

SETL4

set = new('set') * Add all the elements of the array to the set. add(set,array)

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#Phix

Phix

procedure task_to_measure() sleep(0.1) end procedure printf(1,"method 1: calculate reciprocal of elapsed time:\n") for trial=1 to 3 do atom t=time() task_to_measure() t = time()-t string r = iff(t?sprintf("%g",1/t):"inf") printf(1,"rate = %s per second\n",{r}) end for printf(1,"method 2: count completed tasks in one second:\n") for trial=1 to 3 do integer runs=0 atom finish=time()+1 while true do task_to_measure() if time()>=finish then exit end if runs += 1 end while printf(1,"rate = %d per second\n",runs) end for

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Maclisp

Maclisp

(readlist (reverse (explode "my-string")))

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#Erlang

Erlang

-module( read_a_specific_line ). -export( [from_file/2, task/0] ). from_file( File, N ) -> line_nr( N, read_a_file_line_by_line:into_list(File) ). task() -> Lines = read_a_file_line_by_line:into_list( "read_a_specific_line.erl" ), Line_7 = line_nr( 7, Lines ), Line_7. line_nr( N, Lines ) -> try case lists:nth( N, Lines ) of "\n" -> erlang:exit( empty_line ) ; Line -> Line end catch _Type:Error0 -> Error = line_nr_error( Error0 ), io:fwrite( "Error: ~p~n", [Error] ), erlang:exit( Error ) end. line_nr_error( function_clause ) -> too_few_lines_in_file; line_nr_error( Error ) -> Error.

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Sidef

Sidef

var ary = [1,1,2,1,'redundant',[1,2,3],[1,2,3],'redundant']; say ary.uniq.dump; say ary.last_uniq.dump;

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#Phixmonti

Phixmonti

100000 var iterations 2 4 2 tolist for msec var a iterations for over 2 power + drop endfor msec a - var dif "take " print dif print " secs" print " or " print iterations dif / print " sums per second" print nl endfor

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Maple

Maple

> StringTools:-Reverse( "foo" ); "oof"

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#F.23

F#

open System open System.IO [<EntryPoint>] let main args = let n = Int32.Parse(args.[1]) - 1 use r = new StreamReader(args.[0]) let lines = Seq.unfold ( fun (reader : StreamReader) -> if (reader.EndOfStream) then None else Some(reader.ReadLine(), reader)) r let line = Seq.nth n lines // Seq.nth throws an ArgumentException, // if not not enough lines available Console.WriteLine(line) 0

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Slate

Slate

[|:s| #(1 2 3 4 1 2 3 4) >> s] writingAs: Set. "==> {"Set traitsWindow" 1. 2. 3. 4}"

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#PicoLisp

PicoLisp

(prin "Hit a key ... ") (key) (prinl) (let Usec (usec) (prin "Hit another key ... ") (key) (prinl) (prinl "This took " (format (- (usec) Usec) 6) " seconds") )

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Mathematica.2FWolfram_Language

Mathematica/Wolfram Language

StringReverse["asdf"]

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#Factor

Factor

USING: continuations fry io io.encodings.utf8 io.files kernel math ; IN: rosetta-code.nth-line : nth-line ( path encoding n -- str/f ) [ f ] 3dip '[ [ _ [ drop readln [ return ] unless* ] times ] with-return ] with-file-reader ; : nth-line-demo ( -- ) "input.txt" utf8 7 nth-line [ "line not found" ] unless* print ; MAIN: nth-line-demo

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Smalltalk

Smalltalk

"Example of creating a collection" |a| a := #( 1 1 2 'hello' 'world' #symbol #another 2 'hello' #symbol ). a asSet.

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#PowerShell

PowerShell

[datetime]$start = Get-Date [int]$count = 3 [timespan[]]$times = for ($i = 0; $i -lt $count; $i++) { Measure-Command {0..999999 | Out-Null} } [datetime]$end = Get-Date $rate = [PSCustomObject]@{ StartTime = $start EndTime = $end Duration = ($end - $start).TotalSeconds TimesRun = $count AverageRunTime = ($times.TotalSeconds | Measure-Object -Average).Average } $rate | Format-List

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#MATLAB

MATLAB

>> fliplr(['She told me that she spoke English and I said great. '... 'Grabbed her hand out the club and I said let''s skate.']) ans = .etaks s'tel dias I dna bulc eht tuo dnah reh debbarG .taerg dias I dna hsilgnE ekops ehs taht em dlot ehS

http://rosettacode.org/wiki/Ray-casting_algorithm

Ray-casting algorithm

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) Given a point and a polygon, check if the point is inside or outside the polygon using the ray-casting algorithm. A pseudocode can be simply: count ← 0 foreach side in polygon: if ray_intersects_segment(P,side) then count ← count + 1 if is_odd(count) then return inside else return outside Where the function ray_intersects_segment return true if the horizontal ray starting from the point P intersects the side (segment), false otherwise. An intuitive explanation of why it works is that every time we cross a border, we change "country" (inside-outside, or outside-inside), but the 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). So 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. Looking 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). So the problematic points are those inside the white area (the box delimited by the points A and B), like P4. Let 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). Points 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. An algorithm for the previous speech could be (if P is a point, Px is its x coordinate): ray_intersects_segment: P : the point from which the ray starts A : the end-point of the segment with the smallest y coordinate (A must be "below" B) B : the end-point of the segment with the greatest y coordinate (B must be "above" A) if Py = Ay or Py = By then Py ← Py + ε end if if Py < Ay or Py > By then return false else if Px >= max(Ax, Bx) then return false else if Px < min(Ax, Bx) then return true else if Ax ≠ Bx then m_red ← (By - Ay)/(Bx - Ax) else m_red ← ∞ end if if Ax ≠ Px then m_blue ← (Py - Ay)/(Px - Ax) else m_blue ← ∞ end if if m_blue ≥ m_red then return true else return false end if end if end if (To avoid the "ray on vertex" problem, the point is moved upward of a small quantity ε.)

#11l

11l

T Pt Float x, y F (x, y) .x = x .y = y F String() R ‘Pt(x=#., y=#.)’.format(.x, .y) T Edge Pt a, b F (a, b) .a = a .b = b F String() R ‘Edge(a=#., b=#.)’.format(.a, .b) T Poly String name [Edge] edges F (name, edges) .name = name .edges = edges V _eps = 0.00001 V _huge = 1e+100 V _tiny = 1e-100 F rayintersectseg(=p, edge) V a = edge.a V b = edge.b I a.y > b.y swap(&a, &b) I p.y == a.y | p.y == b.y p = Pt(p.x, p.y + :_eps) V intersect = 0B I (p.y > b.y | p.y < a.y) | (p.x > max(a.x, b.x)) R 0B I p.x < min(a.x, b.x) intersect = 1B E Float m_red, m_blue I abs(a.x - b.x) > :_tiny m_red = (b.y - a.y) / Float(b.x - a.x) E m_red = :_huge I abs(a.x - p.x) > :_tiny m_blue = (p.y - a.y) / Float(p.x - a.x) E m_blue = :_huge intersect = m_blue >= m_red R intersect F ispointinside(p, poly) R sum(poly.edges.map(edge -> Int(rayintersectseg(@p, edge)))) % 2 == 1 F polypp(poly) print("\n Polygon(name='#.', edges=(".format(poly.name)) print(‘ ’(poly.edges.map(e -> String(e)).join(",\n ")"\n ))")) V polys = [ Poly(name' ‘square’, edges' [Edge(Pt(0, 0), Pt(10, 0)), Edge(Pt(10, 0), Pt(10, 10)), Edge(Pt(10, 10), Pt(0, 10)), Edge(Pt(0, 10), Pt(0, 0))]), Poly(name' ‘square_hole’, edges' [Edge(Pt(0, 0), Pt(10, 0)), Edge(Pt(10, 0), Pt(10, 10)), Edge(Pt(10, 10), Pt(0, 10)), Edge(Pt(0, 10), Pt(0, 0)), Edge(Pt(2.5, 2.5), Pt(7.5, 2.5)), Edge(Pt(7.5, 2.5), Pt(7.5, 7.5)), Edge(Pt(7.5, 7.5), Pt(2.5, 7.5)), Edge(Pt(2.5, 7.5), Pt(2.5, 2.5))]), Poly(name' ‘strange’, edges' [Edge(Pt(0, 0), Pt(2.5, 2.5)), Edge(Pt(2.5, 2.5), Pt(0, 10)), Edge(Pt(0, 10), Pt(2.5, 7.5)), Edge(Pt(2.5, 7.5), Pt(7.5, 7.5)), Edge(Pt(7.5, 7.5), Pt(10, 10)), Edge(Pt(10, 10), Pt(10, 0)), Edge(Pt(10, 0), Pt(2.5, 2.5))]), Poly(name' ‘exagon’, edges' [Edge(Pt(3, 0), Pt(7, 0)), Edge(Pt(7, 0), Pt(10, 5)), Edge(Pt(10, 5), Pt(7, 10)), Edge(Pt(7, 10), Pt(3, 10)), Edge(Pt(3, 10), Pt(0, 5)), Edge(Pt(0, 5), Pt(3, 0))])] V testpoints = [Pt(5, 5), Pt(5, 8), Pt(-10, 5), Pt(0, 5), Pt(10, 5), Pt(8, 5), Pt(10, 10)] print("\n TESTING WHETHER POINTS ARE WITHIN POLYGONS") L(poly) polys polypp(poly) print(‘ ’testpoints[0.<3].map(p -> ‘#.: #.’.format(p, I ispointinside(p, @poly) {‘True’} E ‘False’)).join("\t")) print(‘ ’testpoints[3.<6].map(p -> ‘#.: #.’.format(p, I ispointinside(p, @poly) {‘True’} E ‘False’)).join("\t")) print(‘ ’testpoints[6.. ].map(p -> ‘#.: #.’.format(p, I ispointinside(p, @poly) {‘True’} E ‘False’)).join("\t"))

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#Fortran

Fortran

MODULE SAMPLER !To sample a record from a file. SAM00100 CONTAINS SAM00200 CHARACTER*20 FUNCTION GETREC(N,F,IS) !Returns a status. SAM00300 Careful. Some compilers get confused over the function name's usage. SAM00400 INTEGER N !The desired record number. SAM00500 INTEGER F !Of this file. SAM00600 CHARACTER*(*) IS !Stashed here. SAM00700 INTEGER I,L !Assistants. SAM00800 IS = "" !Clear previous content, even if null...SAM00900 IF (N.LE.0) THEN !Start on errors. SAM01000 WRITE (GETREC,1) "!No record",N !Could never be found. SAM01100 1 FORMAT (A,1X,I0) !Message, number. SAM01200 ELSE IF (F.LE.0) THEN !Obviously wrong? SAM01300 WRITE (GETREC,1) "!No unit number",F!Positive is valid. SAM01400 ELSE IF (LEN(IS).LE.0) THEN !Space awaits? SAM01500 WRITE (GETREC,1) "!String size",LEN(IS) !Nope. SAM01600 ELSE !Otherwise, there is hope. SAM01700 REWIND (F) !Clarify the file position. SAM01800 DO I = 1,N - 1 !Grind up to the desired record. SAM01900 READ (F,2,END=3) !Ignoring any content. SAM02000 END DO !Are we there yet? SAM02100 READ (F,2,END = 3) L,IS(1:MIN(L,LEN(IS))) !At last. SAM02200 2 FORMAT (Q,A) !Q = characters yet unread. SAM02300 IF (L.LT.LEN(IS)) IS(L + 1:) = "" !Clear the tail. SAM02400 IF (L.GT.LEN(IS)) THEN !Now for more silliness.SAM02500 WRITE (GETREC,1) "+Length",L !Too long to fit in IS. SAM02600 ELSE IF (L.LE.0) THEN !A zero-length record SAM02700 WRITE (GETREC,1) "+Null" !Is not the same SAM02800 ELSE IF (IS.EQ."") THEN !As a record SAM02900 WRITE (GETREC,1) "+Blank",L !Containing spaces. SAM03000 ELSE !But otherwise, SAM03100 WRITE (GETREC,1) " Length",L !Note the leading space.SAM03200 END IF !Righto, we've decided. SAM03300 END IF !And, no more options. SAM03400 RETURN !So, done. SAM03500 3 WRITE (GETREC,1) "!End on read",I !An alternative ending. SAM03600 END FUNCTION GETREC !That was interesting. SAM03700 END MODULE SAMPLER !Just a sample of possibility. SAM03800 SAM03900 PROGRAM POKE POK00100 USE SAMPLER POK00200 INTEGER ENUFF !Some sizes. POK00300 PARAMETER (ENUFF = 666) !Sufficient? POK00400 CHARACTER*(ENUFF) STUFF !Lots of memory these days. POK00500 CHARACTER*20 RESULT POK00600 INTEGER MSG,F !I/O unit numbers. POK00700 MSG = 6 !Standard output. POK00800 F = 10 !Chooose a unit number. POK00900 WRITE (MSG,*) " To select record 7 from a disc file." POK01000 POK01100 WRITE (MSG,*) "As a FORMATTED file." POK01200 OPEN (F,FILE="FileSlurpN.for",STATUS="OLD",ACTION="READ") POK01300 RESULT = GETREC(7,F,STUFF) POK01400 WRITE (MSG,1) "Result",RESULT POK01500 WRITE (MSG,1) "Record",STUFF POK01600 1 FORMAT (A,":",A) POK01700 POK01800 CLOSE (F) POK01900 WRITE (MSG,*) "As a random-access unformatted file." POK02000 OPEN (F,FILE="FileSlurpN.for",STATUS="OLD",ACTION="READ", POK02100 1 ACCESS="DIRECT",FORM="UNFORMATTED",RECL=82) !Not 80! POK02200 STUFF = "Cleared." POK02300 READ (F,REC = 7,ERR = 666) STUFF(1:80) POK02400 WRITE (MSG,1) "Record",STUFF(1:80) POK02500 STOP POK02600 666 WRITE (MSG,*) "Can't get the record!" POK02700 END !That was easy. POK02800

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Sparkling

Sparkling

function undupe(arr) { var t = {}; foreach(arr, function(key, val) { t[val] = true; }); var r = {}; foreach(t, function(key) { r[sizeof r] = key; }); return r; }

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#SQL

SQL

/* This code is an implementation of "Remove duplicate elements" in SQL ORACLE 19c p_in_str -- input string p_delimiter -- delimeter */ WITH FUNCTION remove_duplicate_elements(p_in_str IN varchar2, p_delimiter IN varchar2 DEFAULT ',') RETURN varchar2 IS v_in_str varchar2(32767) := REPLACE(p_in_str,p_delimiter,','); v_res varchar2(32767); BEGIN -- EXECUTE immediate 'select listagg(distinct cv,:p_delimiter) from (select (column_value).getstringval() cv from xmltable(:v_in_str))' INTO v_res USING p_delimiter, v_in_str; -- RETURN v_res; -- END; --Test SELECT remove_duplicate_elements('1, 2, 3, "a", "b", "c", 2, 3, 4, "b", "c", "d"') AS res FROM dual UNION ALL SELECT remove_duplicate_elements('3 9 1 10 3 7 6 5 2 7 4 7 4 2 2 2 2 8 2 10 4 9 2 4 9 3 4 3 4 7',' ') AS res FROM dual ;

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#PureBasic

PureBasic

Procedure.d TimesPSec(Reset=#False) Static starttime, cnt Protected Result.d, dt If Reset starttime=ElapsedMilliseconds(): cnt=0 Else cnt+1 dt=(ElapsedMilliseconds()-starttime) If dt Result=cnt/(ElapsedMilliseconds()-starttime) EndIf EndIf ProcedureReturn Result*1000 EndProcedure If OpenWindow(0,#PB_Ignore,#PB_Ignore,220,110,"",#PB_Window_SystemMenu) Define Event, r.d, GadgetNumber ButtonGadget(0,10, 5,200,35,"Click me!") ButtonGadget(1,10,70,100,35,"Reset") TextGadget (2,10,45,200,25,"") TimesPSec(1) Repeat Event=WaitWindowEvent() If Event=#PB_Event_Gadget GadgetNumber =EventGadget() If GadgetNumber=0 r=TimesPSec() SetGadgetText(2,"You are clicking at "+StrD(r,5)+" Hz.") ElseIf GadgetNumber=1 TimesPSec(1) SetGadgetText(2,"Counter zeroed.") EndIf EndIf Until Event=#PB_Event_CloseWindow EndIf

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Maxima

Maxima

sreverse("abcdef"); /* "fedcba" */ sreverse("rats live on no evil star"); /* not a bug :o) */

http://rosettacode.org/wiki/Ray-casting_algorithm

Ray-casting algorithm

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) Given a point and a polygon, check if the point is inside or outside the polygon using the ray-casting algorithm. A pseudocode can be simply: count ← 0 foreach side in polygon: if ray_intersects_segment(P,side) then count ← count + 1 if is_odd(count) then return inside else return outside Where the function ray_intersects_segment return true if the horizontal ray starting from the point P intersects the side (segment), false otherwise. An intuitive explanation of why it works is that every time we cross a border, we change "country" (inside-outside, or outside-inside), but the 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). So 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. Looking 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). So the problematic points are those inside the white area (the box delimited by the points A and B), like P4. Let 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). Points 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. An algorithm for the previous speech could be (if P is a point, Px is its x coordinate): ray_intersects_segment: P : the point from which the ray starts A : the end-point of the segment with the smallest y coordinate (A must be "below" B) B : the end-point of the segment with the greatest y coordinate (B must be "above" A) if Py = Ay or Py = By then Py ← Py + ε end if if Py < Ay or Py > By then return false else if Px >= max(Ax, Bx) then return false else if Px < min(Ax, Bx) then return true else if Ax ≠ Bx then m_red ← (By - Ay)/(Bx - Ax) else m_red ← ∞ end if if Ax ≠ Px then m_blue ← (Py - Ay)/(Px - Ax) else m_blue ← ∞ end if if m_blue ≥ m_red then return true else return false end if end if end if (To avoid the "ray on vertex" problem, the point is moved upward of a small quantity ε.)

#Ada

Ada

package Polygons is type Point is record X, Y : Float; end record; type Point_List is array (Positive range <>) of Point; subtype Segment is Point_List (1 .. 2); type Polygon is array (Positive range <>) of Segment; function Create_Polygon (List : Point_List) return Polygon; function Is_Inside (Who : Point; Where : Polygon) return Boolean; end Polygons;

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#FreeBASIC

FreeBASIC

' FB 1.05.0 Win64 Open "input.txt" For Input As #1 Dim line_ As String Dim count As Integer = 0 While Not Eof(1) Line Input #1, line_ '' read each line count += 1 If count = 7 Then line_ = Trim(line_, Any !" \t") '' remove any leading or trailing spaces or tabs If line_ = "" Then Print "The 7th line is empty" Else Print "The 7th line is : "; line_ End If Exit While End If Wend If count < 7 Then Print "There are only"; count; " lines in the file" End If Close #1 Print Print "Press any key to quit" Sleep

http://rosettacode.org/wiki/Ranking_methods

Ranking methods

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort 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. The numerical rank of a competitor can be assigned in several different ways. Task The following scores are accrued for all competitors of a competition (in best-first order): 44 Solomon 42 Jason 42 Errol 41 Garry 41 Bernard 41 Barry 39 Stephen For 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: Standard. (Ties share what would have been their first ordinal number). Modified. (Ties share what would have been their last ordinal number). Dense. (Ties share the next available integer). Ordinal. ((Competitors take the next available integer. Ties are not treated otherwise). Fractional. (Ties share the mean of what would have been their ordinal numbers). See the wikipedia article for a fuller description. Show here, on this page, the ranking of the test scores under each of the numbered ranking methods.

#11l

11l

F mc_rank([(Int, String)] iterable) ‘Modified competition ranking’ [(Float, (Int, String))] r V lastresult = -1 [(Int, String)] fifo L(item) iterable I item[0] == lastresult fifo [+]= item E V n = L.index L !fifo.empty r.append((n, fifo.pop(0))) lastresult = item[0] fifo [+]= item L !fifo.empty r.append((iterable.len, fifo.pop(0))) R r F sc_rank([(Int, String)] iterable) ‘Standard competition ranking’ [(Float, (Int, String))] r V lastresult = -1 V lastrank = -1 L(item) iterable I item[0] == lastresult r.append((lastrank, item)) E V n = L.index + 1 r.append((n, item)) lastresult = item[0] lastrank = n R r F d_rank([(Int, String)] iterable) ‘Dense ranking’ [(Float, (Int, String))] r V lastresult = -1 V lastrank = 0 L(item) iterable I item[0] == lastresult r.append((lastrank, item)) E lastresult = item[0] lastrank++ r.append((lastrank, item)) R r F o_rank([(Int, String)] iterable) ‘Ordinal ranking’ R enumerate(iterable, 1).map((i, item) -> ((Float(i), item))) F f_rank([(Int, String)] iterable) ‘Fractional ranking’ [(Float, (Int, String))] r V last = -1 [(Int, (Int, String))] fifo L(item) iterable I item[0] != last I !fifo.empty V mean = Float(sum(fifo.map(f -> f[0]))) / fifo.len L !fifo.empty r.append((mean, fifo.pop(0)[1])) last = item[0] fifo.append((L.index + 1, item)) I !fifo.empty V mean = sum(fifo.map(f -> f[0])) / fifo.len L !fifo.empty r.append((mean, fifo.pop(0)[1])) R r V scores = [(44, ‘Solomon’), (42, ‘Jason’), (42, ‘Errol’), (41, ‘Garry’), (41, ‘Bernard’), (41, ‘Barry’), (39, ‘Stephen’)] print("\nScores to be ranked (best first):") L(n, s) scores print(‘ #2 #.’.format(n, s)) L(ranker, ranking_method) [(sc_rank, ‘Standard competition ranking’), (mc_rank, ‘Modified competition ranking’), (d_rank, ‘Dense ranking’), (o_rank, ‘Ordinal ranking’), (f_rank, ‘Fractional ranking’)] print("\n#.:".format(ranking_method)) L(rank, score) ranker(scores) print(‘ #3, (#., #.)’.format(rank, score[0], score[1]))

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Stata

Stata

. clear all . input x y 1 1 1 1 1 2 2 1 2 2 1 1 2 1 2 1 1 2 2 2 end . duplicates drop x y, force . list +-------+ | x y | |-------| 1. | 1 1 | 2. | 1 2 | 3. | 2 1 | 4. | 2 2 | +-------+

http://rosettacode.org/wiki/Remove_duplicate_elements

Remove duplicate elements

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort Given an Array, derive a sequence of elements in which all duplicates are removed. There are basically three approaches seen here: Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n2) 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. 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. 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(n2). The up-shot is that this always works on any type (provided that you can test for equality).

#Swift

Swift

println(Array(Set([3,2,1,2,3,4])))

http://rosettacode.org/wiki/Rate_counter

Rate counter

Of 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. Multiple approaches are allowed (even preferable), so long as they can accomplish these goals: Run N seconds worth of jobs and/or Y jobs. Report at least three distinct times. Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. See also: System time, Time a function

#Python

Python

import subprocess import time class Tlogger(object): def __init__(self): self.counts = 0 self.tottime = 0.0 self.laststart = 0.0 self.lastreport = time.time() def logstart(self): self.laststart = time.time() def logend(self): self.counts +=1 self.tottime += (time.time()-self.laststart) if (time.time()-self.lastreport)>5.0: # report once every 5 seconds self.report() def report(self): if ( self.counts > 4*self.tottime): print "Subtask execution rate: %f times/second"% (self.counts/self.tottime); else: print "Average execution time: %f seconds"%(self.tottime/self.counts); self.lastreport = time.time() def taskTimer( n, subproc_args ): logger = Tlogger() for x in range(n): logger.logstart() p = subprocess.Popen(subproc_args) p.wait() logger.logend() logger.report() import timeit import sys def main( ): # for accurate timing of code segments s = """j = [4*n for n in range(50)]""" timer = timeit.Timer(s) rzlts = timer.repeat(5, 5000) for t in rzlts: print "Time for 5000 executions of statement = ",t # subprocess execution timing print "#times:",sys.argv[1] print "Command:",sys.argv[2:] print "" for k in range(3): taskTimer( int(sys.argv[1]), sys.argv[2:]) main()

http://rosettacode.org/wiki/Reverse_a_string

Reverse a string

Task Take a string and reverse it. For example, "asdf" becomes "fdsa". Extra credit Preserve Unicode combining characters. For example, "as⃝df̅" becomes "f̅ds⃝a", not "̅fd⃝sa". Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#MAXScript

MAXScript

fn reverseString s = ( local reversed = "" for i in s.count to 1 by -1 do reversed += s[i] reversed )

http://rosettacode.org/wiki/Ray-casting_algorithm

Ray-casting algorithm

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) Given a point and a polygon, check if the point is inside or outside the polygon using the ray-casting algorithm. A pseudocode can be simply: count ← 0 foreach side in polygon: if ray_intersects_segment(P,side) then count ← count + 1 if is_odd(count) then return inside else return outside Where the function ray_intersects_segment return true if the horizontal ray starting from the point P intersects the side (segment), false otherwise. An intuitive explanation of why it works is that every time we cross a border, we change "country" (inside-outside, or outside-inside), but the 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). So 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. Looking 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). So the problematic points are those inside the white area (the box delimited by the points A and B), like P4. Let 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). Points 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. An algorithm for the previous speech could be (if P is a point, Px is its x coordinate): ray_intersects_segment: P : the point from which the ray starts A : the end-point of the segment with the smallest y coordinate (A must be "below" B) B : the end-point of the segment with the greatest y coordinate (B must be "above" A) if Py = Ay or Py = By then Py ← Py + ε end if if Py < Ay or Py > By then return false else if Px >= max(Ax, Bx) then return false else if Px < min(Ax, Bx) then return true else if Ax ≠ Bx then m_red ← (By - Ay)/(Bx - Ax) else m_red ← ∞ end if if Ax ≠ Px then m_blue ← (Py - Ay)/(Px - Ax) else m_blue ← ∞ end if if m_blue ≥ m_red then return true else return false end if end if end if (To avoid the "ray on vertex" problem, the point is moved upward of a small quantity ε.)

#ANSI_Standard_BASIC

ANSI Standard BASIC

1000 PUBLIC NUMERIC x,y 1010 LET x=1 1020 LET y=2 1030 ! 1040 DEF isLeft2(L(,),p()) = -SGN( (L(1,x)-L(2,x))*(p(y)-L(2,y)) - (p(x)-L(2,x))*(L(1,y)-L(2,y))) 1050 ! 1060 FUNCTION inpolygon(p1(,),p2()) 1070 LET k=UBOUND(p1,1)+1 1080 DIM send (1 TO 2,2) 1090 LET wn=0 1100 FOR n=1 TO UBOUND(p1,1) 1110 LET index=MOD(n, k) 1120 LET nextindex=MOD(n+1, k) 1130 IF nextindex=0 THEN LET nextindex=1 1140 LET send(1,x)=p1(index,x) 1150 LET send(2,x)=p1(nextindex,x) 1160 LET send(1,y)=p1(index,y) 1170 LET send(2,y)=p1(nextindex,y) 1180 IF p1(index,y)<=p2(y) THEN 1190 IF p1(nextindex,y)>p2(y) THEN 1200 IF isleft2(send,p2)>=0 THEN !'= 1210 LET wn=wn+1 1220 END IF 1230 END IF 1240 ELSE 1250 IF p1(nextindex,y)<=p2(y) THEN 1260 IF isleft2(send,p2)<=0 THEN !'= 1270 LET wn=wn-1 1280 END IF 1290 END IF 1300 END IF 1310 NEXT n 1320 LET inpolygon = wn 1330 END FUNCTION 1340 ! 1350 DIM type(1 TO 2) 1360 ! 1370 DIM square(4,2) 1380 MAT READ square 1390 DATA 0,0,10,0,10,10,0,10 1400 ! 1410 DIM hole(4,2) 1420 MAT READ hole 1430 DATA 2.5,2.5,7.5,2.5,7.5,7.5,2.5,7.5 1440 ! 1450 DIM strange(8,2) 1460 MAT READ strange 1470 DATA 0,0,2.5,2.5,0,10,2.5,7.5,7.5,7.5,10,10,10,0,2.5,2.5 1480 ! 1490 DIM exagon(6,2) 1500 MAT READ exagon 1510 DATA 3,0,7,0,10,5,7,10,3,10,0,5 1520 ! 1530 ! printouts 1540 FOR z=1 TO 4 1550 SELECT CASE z 1560 CASE 1 1570 PRINT "squared" 1580 PRINT "(5,5) ";TAB(12); 1590 MAT READ type 1600 DATA 5,5 1610 IF inpolygon(square,type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1620 MAT READ type 1630 DATA 5,8 1640 PRINT "(5,8) ";TAB(12); 1650 IF inpolygon(square,type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1660 PRINT "(-10,5) ";TAB(12); 1670 MAT READ type 1680 DATA -10,5 1690 IF inpolygon(square,type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1700 Print "(0,5) ";Tab(12); 1710 MAT READ type 1720 DATA 0,5 1730 IF inpolygon(square,type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1740 Print "(10,5) ";Tab(12); 1750 MAT READ type 1760 DATA 10,5 1770 IF inpolygon(square,type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1780 PRINT "(8,5) ";TAB(12); 1790 MAT READ type 1800 DATA 8,5 1810 IF inpolygon(square,Type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1820 PRINT "(10,10) ";TAB(12); 1830 MAT READ type 1840 DATA 10,10 1850 IF inpolygon(square,Type) <> 0 THEN PRINT "in" ELSE PRINT "out" 1860 PRINT 1870 CASE 2 1880 PRINT "squared hole" 1890 PRINT "(5,5) ";TAB(12); 1900 MAT READ type 1910 DATA 5,5 1920 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 1930 Print "(5,8) ";Tab(12); 1940 MAT READ type 1950 DATA 5,8 1960 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 1970 PRINT "(-10,5) ";TAB(12); 1980 MAT READ type 1990 DATA -10,5 2000 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2010 PRINT "(0,5) ";TAB(12); 2020 MAT READ type 2030 DATA 0,5 2040 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2050 PRINT "(10,5) ";TAB(12); 2060 MAT READ type 2070 DATA 10,5 2080 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2090 PRINT "(8,5) ";TAB(12); 2100 MAT READ type 2110 DATA 8,5 2120 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2130 PRINT "(10,10) ";TAB(12); 2140 MAT READ type 2150 DATA 10,10 2160 IF NOT inpolygon(hole,Type)<>0 AND inpolygon(square,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2170 PRINT 2180 CASE 3 2190 PRINT "strange" 2200 PRINT "(5,5) ";TAB(12); 2210 MAT READ type 2220 DATA 5,5 2230 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2240 PRINT "(5,8) ";TAB(12); 2250 MAT READ type 2260 DATA 5,8 2270 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2280 PRINT "(-10,5) ";TAB(12); 2290 MAT READ type 2300 DATA -10,5 2310 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2320 PRINT "(0,5) ";TAB(12); 2330 MAT READ type 2340 DATA 0,5 2350 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2360 PRINT "(10,5) ";TAB(12); 2370 MAT READ type 2380 DATA 10,5 2390 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2400 PRINT "(8,5) ";TAB(12); 2410 MAT READ type 2420 DATA 8,5 2430 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2440 PRINT "(10,10) ";TAB(12); 2450 MAT READ type 2460 DATA 10,10 2470 IF inpolygon(strange,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2480 PRINT 2490 CASE 4 2500 PRINT "exagon" 2510 PRINT "(5,5) ";TAB(12); 2520 MAT READ type 2530 DATA 5,5 2540 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2550 PRINT "(5,8) ";TAB(12); 2560 MAT READ type 2570 DATA 5,8 2580 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2590 PRINT "(-10,5) ";TAB(12); 2600 MAT READ type 2610 DATA -10,5 2620 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2630 PRINT "(0,5) ";TAB(12); 2640 MAT READ type 2650 DATA 0,5 2660 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2670 PRINT "(10,5) ";TAB(12); 2680 MAT READ type 2690 DATA 10,5 2700 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2710 PRINT "(8,5) ";TAB(12); 2720 MAT READ type 2730 DATA 8,5 2740 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2750 PRINT "(10,10) ";TAB(12); 2760 MAT READ type 2770 DATA 10,10 2780 IF inpolygon(exagon,Type)<>0 THEN PRINT "in" ELSE PRINT "out" 2790 PRINT 2800 END SELECT 2810 NEXT z 2820 END

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#Frink

Frink

nthLine[filename, lineNum] := { line = nth[lines[filenameToURL[filename]], lineNum-1] if line != undef return line else { println["The file $filename does not contain a line number $lineNum"] return undef } }

http://rosettacode.org/wiki/Read_a_specific_line_from_a_file

Read a specific line from a file

Some languages have special semantics for obtaining a known line number from a file. Task Demonstrate how to obtain the contents of a specific line within a file. For 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). If the file does not contain seven lines, or the seventh line is empty, or too big to be retrieved, output an appropriate message. If no special semantics are available for obtaining the required line, it is permissible to read line by line. Note that empty lines are considered and should still be counted. Also note that for functional languages or languages without variables or storage, it is permissible to output the extracted data to standard output.

#FutureBasic

FutureBasic

window 1 long i = 1 Str255 s, lineSeven CFURLRef url url = openpanel 1, @"Select text file" if ( url ) open "I", 2, url while ( not eof(2) ) line input #2, s if ( i == 7 ) lineSeven = s : break end if i++ wend close 2 if ( lineSeven[0] ) print lineSeven else print "File did not contain seven lines, or line was empty." end if end if HandleEvents

http://rosettacode.org/wiki/Ranking_methods

Ranking methods

Sorting Algorithm This is a sorting algorithm. It may be applied to a set of data in order to sort it. For comparing various sorts, see compare sorts. For other sorting algorithms, see sorting algorithms, or: O(n logn) sorts Heap sort | Merge sort | Patience sort | Quick sort O(n log2n) sorts Shell Sort O(n2) sorts Bubble sort | Cocktail sort | Cocktail sort with shifting bounds | Comb sort | Cycle sort | Gnome sort | Insertion sort | Selection sort | Strand sort other sorts Bead sort | Bogo sort | Common sorted list | Composite structures sort | Custom comparator sort | Counting sort | Disjoint sublist sort | External sort | Jort sort | Lexicographical sort | Natural sorting | Order by pair comparisons | Order disjoint list items | Order two numerical lists | Object identifier (OID) sort | Pancake sort | Quickselect | Permutation sort | Radix sort | Ranking methods | Remove duplicate elements | Sleep sort | Stooge sort | [Sort letters of a string] | Three variable sort | Topological sort | Tree sort 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. The numerical rank of a competitor can be assigned in several different ways. Task The following scores are accrued for all competitors of a competition (in best-first order): 44 Solomon 42 Jason 42 Errol 41 Garry 41 Bernard 41 Barry 39 Stephen For 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: Standard. (Ties share what would have been their first ordinal number). Modified. (Ties share what would have been their last ordinal number). Dense. (Ties share the next available integer). Ordinal. ((Competitors take the next available integer. Ties are not treated otherwise). Fractional. (Ties share the mean of what would have been their ordinal numbers). See the wikipedia article for a fuller description. Show here, on this page, the ranking of the test scores under each of the numbered ranking methods.

#AppleScript

AppleScript

(* The five ranking methods are implemented here as script objects sharing inherited code rather than as simple handlers, although there appears to be little advantage either way. This way needs fewer lines of code but more lines of explanatory comments! *) use AppleScript version "2.4" -- Mac OS 10.11 (Yosemite) or later (for these 'use' commands). use sorter : script "Custom Iterative Ternary Merge Sort" -- <https://macscripter.net/viewtopic.php?pid=194430#p194430> script standardRanking -- Properties and handlers inherited or overridden by the other script objects. -- The 'references' are to values that won't be available until 'results' is set to a list. -- 'me' and 'my' refer to the script object using the code at the time. property results : missing value property startIndex : 1 property endIndex : a reference to length of (a reference to results) property step : 1 property currentRank : missing value property currentScore : missing value -- Main handler. on resultsFrom(theScores) copy theScores to my results -- The task description specifies that the input list is already ordered, but that's not assumed here. -- Additionally, competitors with equal scores are arranged alphabetically by name. -- The comparer here is 'me' because the current script object contains the isGreater(a, b) handler to be used. tell sorter to sort(my results, my startIndex, my endIndex, {comparer:me}) set my currentScore to score of item (my startIndex) of my results set my currentRank to my startIndex's contents repeat with i from (my startIndex) to (my endIndex) by (my step) my rankResult(i) end repeat -- Since these script objects are assigned to top-level variables in a running script, make sure the potentially -- long 'results' list isn't saved back to the script file with them at the end of the run. This precaution isn't -- necessary in a library script or if the scripts are instantiated and assigned to local variables at run time. set localVariable to my results set my results to missing value return localVariable end resultsFrom -- Comparison handler used by the sort. The returned boolean indicates whether or not record 'a' should go after record 'b'. on isGreater(a, b) if (a's score is less than b's score) then return true return ((a's score is equal to b's score) and (a's competitor comes after b's competitor)) end isGreater -- Specialist ranking handler. Inherited by the modifiedRanking script, but overridden by the others. on rankResult(i) set thisResult to item i of my results set thisScore to thisResult's score if (thisScore is not currentScore) then set my currentRank to i set my currentScore to thisScore end if set item i of my results to thisResult & {rank:my currentRank} end rankResult end script script modifiedRanking -- Uses the standardRanking code, but works backwards through the results list. property parent : standardRanking property startIndex : a reference to length of (a reference to results) property endIndex : 1 property step : -1 end script script denseRanking property parent : standardRanking on rankResult(i) set thisResult to item i of my results set thisScore to thisResult's score if (thisScore is not my currentScore) then set my currentRank to (my currentRank) + 1 set my currentScore to thisScore end if set item i of my results to thisResult & {rank:my currentRank} end rankResult end script script ordinalRanking property parent : standardRanking on rankResult(i) set item i of my results to (item i of my results) & {rank:i} end rankResult end script script fractionalRanking property parent : standardRanking on rankResult(i) set thisResult to item i of my results set thisScore to thisResult's score if (thisScore is not my currentScore) then -- i and currentRank are simultaneously indices and ranks. -- The average of any run of consecutive integers is that of the first and last. set average to (i - 1 + (my currentRank)) / 2 repeat with j from (my currentRank) to (i - 1) set rank of item j of my results to average end repeat set my currentRank to i set my currentScore to thisScore end if set item i of my results to thisResult & {rank:i as real} end rankResult end script -- Task code: on formatRankings(type, theResults) set rankings to {type} repeat with thisResult in theResults set end of rankings to (thisResult's rank as text) & tab & thisResult's competitor & " (" & thisResult's score & ")" end repeat return joinStrings(rankings, linefeed) end formatRankings on joinStrings(listOfText, delimiter) set astid to AppleScript's text item delimiters set AppleScript's text item delimiters to delimiter set output to listOfText as text set AppleScript's text item delimiters to astid return output end joinStrings local theScores, output set theScores to {{score:44, competitor:"Solomon"}, {score:42, competitor:"Jason"}, {score:42, competitor:"Errol"}, ¬ {score:41, competitor:"Garry"}, {score:41, competitor:"Bernard"}, {score:41, competitor:"Barry"}, ¬ {score:39, competitor:"Stephen"}} set output to {} set end of output to formatRankings("Standard ranking:", standardRanking's resultsFrom(theScores)) set end of output to formatRankings("Modified ranking:", modifiedRanking's resultsFrom(theScores)) set end of output to formatRankings("Dense ranking:", denseRanking's resultsFrom(theScores)) set end of output to formatRankings("Ordinal ranking:", ordinalRanking's resultsFrom(theScores)) set end of output to formatRankings("Fractional ranking:", fractionalRanking's resultsFrom(theScores)) return joinStrings(output, linefeed & linefeed)